feat: add some common codes

Author: 1ncounter

packages/engine-core/package.json

@@ -35,9 +35,6 @@
   "devDependencies": {
     "@types/lodash-es": "^4.17.12"
   },
-  "peerDependencies": {
-    "@alilc/lowcode-shared": "workspace:*"
-  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"

packages/engine-core/src/lifeCycle/lifeCycleService.ts renamed to packages/engine-core/src/command/action.ts

@@ -1,4 +1,4 @@
-import { type InstanceAccessor } from '@alilc/lowcode-shared';
+import { type InstanceAccessor, type TypeConstraint } from '@alilc/lowcode-shared';
 
 export interface ICommandEvent {
   commandId: string;
@@ -16,19 +16,12 @@ export interface ICommand {
 }
 
 export interface ICommandMetadata {
-  /**
-   * A short summary of what the command does. This will be used in:
-   * - API commands
-   * - when showing keybindings that have no other UX
-   * - when searching for commands in the Command Palette
-   */
   readonly description: string;
   readonly args?: ReadonlyArray<{
     readonly name: string;
     readonly isOptional?: boolean;
     readonly description?: string;
-    // readonly constraint?: TypeConstraint;
-    // readonly schema?: IJSONSchema;
+    readonly constraint?: TypeConstraint;
+    readonly default?: any;
   }>;
-  readonly returns?: string;
 }

packages/engine-core/src/command/command.ts

@@ -3,9 +3,14 @@ import {
   type EventDisposable,
   type EventListener,
   Emitter,
+  LinkedList,
+  TypeConstraint,
+  validateConstraints,
+  Iterable,
 } from '@alilc/lowcode-shared';
 import { ICommand, ICommandHandler } from './command';
-import { Registry } from '../extension';
+import { Extensions, Registry } from '../common/registry';
+import { ICommandService } from './commandService';
 
 export type ICommandsMap = Map<string, ICommand>;
 
@@ -24,10 +29,10 @@ export interface ICommandRegistry {
 class CommandsRegistry implements ICommandRegistry {
   private readonly _commands = new Map<string, LinkedList<ICommand>>();
 
-  private readonly _onDidRegisterCommand = new Emitter<string>();
+  private readonly _didRegisterCommandEmitter = new Emitter<string>();
 
   onDidRegisterCommand(fn: EventListener<string>) {
-    return this._onDidRegisterCommand.on(fn);
+    return this._didRegisterCommandEmitter.on(fn);
   }
 
   registerCommand(idOrCommand: string | ICommand, handler?: ICommandHandler): EventDisposable {
@@ -66,21 +71,21 @@ class CommandsRegistry implements ICommandRegistry {
 
     const removeFn = commands.unshift(idOrCommand);
 
-    const ret = toDisposable(() => {
+    const ret = () => {
       removeFn();
       const command = this._commands.get(id);
       if (command?.isEmpty()) {
         this._commands.delete(id);
       }
-    });
+    };
 
     // tell the world about this command
-    this._onDidRegisterCommand.emit(id);
+    this._didRegisterCommandEmitter.emit(id);
 
     return ret;
   }
 
-  registerCommandAlias(oldId: string, newId: string): IDisposable {
+  registerCommandAlias(oldId: string, newId: string): EventDisposable {
     return this.registerCommand(oldId, (accessor, ...args) =>
       accessor.get(ICommandService).executeCommand(newId, ...args),
     );
@@ -108,8 +113,4 @@ class CommandsRegistry implements ICommandRegistry {
 
 const commandsRegistry = new CommandsRegistry();
 
-export const Extension = {
-  command: 'base.contributions.command',
-};
-
-Registry.add(Extension.command, commandsRegistry);
+Registry.add(Extensions.Command, commandsRegistry);

packages/engine-core/src/command/commandRegistry.ts

@@ -1,6 +1,6 @@
-import { createDecorator, Provide } from '@alilc/lowcode-shared';
-import { Registry } from '../extension';
-import { ICommandRegistry, Extension } from './commandRegistry';
+import { createDecorator, Provide, IInstantiationService } from '@alilc/lowcode-shared';
+import { Registry, Extensions } from '../common/registry';
+import { ICommandRegistry } from './commandRegistry';
 
 export interface ICommandService {
   executeCommand<T = any>(commandId: string, ...args: any[]): Promise<T | undefined>;
@@ -10,11 +10,23 @@ export const ICommandService = createDecorator<ICommandService>('commandService'
 
 @Provide(ICommandService)
 export class CommandService implements ICommandService {
+  constructor(@IInstantiationService private instantiationService: IInstantiationService) {}
+
   executeCommand<T = any>(id: string, ...args: any[]): Promise<T | undefined> {
-    const command = Registry.as<ICommandRegistry>(Extension.command).getCommand(id);
+    return this.tryExecuteCommand(id, args);
+  }
 
+  private tryExecuteCommand(id: string, args: any[]): Promise<any> {
+    const command = Registry.as<ICommandRegistry>(Extensions.Command).getCommand(id);
     if (!command) {
       return Promise.reject(new Error(`command '${id}' not found`));
     }
+
+    try {
+      const result = this.instantiationService.invokeFunction(command.handler, ...args);
+      return Promise.resolve(result);
+    } catch (err) {
+      return Promise.reject(err);
+    }
   }
 }

packages/engine-core/src/command/commandService.ts

@@ -0,0 +1,3 @@
+export * from './command';
+export * from './commandRegistry';
+export * from './commandService';

packages/engine-core/src/command/index.ts

@@ -37,3 +37,9 @@ class RegistryImpl implements IRegistry {
 }
 
 export const Registry: IRegistry = new RegistryImpl();
+
+export const Extensions = {
+  Configuration: 'base.contributions.configuration',
+  Command: 'base.contributions.command',
+  Widget: 'base.contributions.widget',
+};

packages/engine-core/src/extension/registry.ts renamed to packages/engine-core/src/common/registry.ts

@@ -1,81 +1,105 @@
-import { type StringDictionary, Emitter, type EventListener } from '@alilc/lowcode-shared';
-import { ConfigurationModel } from './configurationModel';
-import {
-  type IConfigurationRegistry,
-  type IRegisteredConfigurationPropertySchema,
-  Extension,
-} from './configurationRegistry';
-import { Registry } from '../extension';
+import { type StringDictionary } from '@alilc/lowcode-shared';
+import { uniq } from 'lodash-es';
 
-export interface IConfigurationOverrides {
-  overrideIdentifier?: string | null;
+export interface IInspectValue<T> {
+  readonly value?: T;
+  readonly override?: T;
+  readonly overrides?: { readonly identifiers: string[]; readonly value: T }[];
 }
 
-export interface IConfigurationUpdateOverrides {
-  overrideIdentifiers?: string[] | null;
-}
-
-export class DefaultConfiguration {
-  private emitter = new Emitter<{
-    defaults: ConfigurationModel;
-    properties: string[];
-  }>();
+export function toValuesTree(properties: StringDictionary): any {
+  const root = Object.create(null);
 
-  private _configurationModel = ConfigurationModel.createEmptyModel();
-
-  get configurationModel(): ConfigurationModel {
-    return this._configurationModel;
+  for (const key of Object.keys(properties)) {
+    addToValueTree(root, key, properties[key]);
   }
 
-  initialize(): ConfigurationModel {
-    this.resetConfigurationModel();
-    Registry.as<IConfigurationRegistry>(Extension.Configuration).onDidUpdateConfiguration(
-      ({ properties }) => this.onDidUpdateConfiguration([...properties]),
-    );
-
-    return this.configurationModel;
-  }
+  return root;
+}
 
-  reload(): ConfigurationModel {
-    this.resetConfigurationModel();
-    return this.configurationModel;
-  }
+export function addToValueTree(
+  settingsTreeRoot: any,
+  key: string,
+  value: any,
+  conflictReporter: (message: string) => void = console.error,
+): void {
+  const segments = key.split('.');
+  const last = segments.pop()!;
 
-  onDidChangeConfiguration(
-    listener: EventListener<[{ defaults: ConfigurationModel; properties: string[] }]>,
-  ) {
-    return this.emitter.on(listener);
+  let curr = settingsTreeRoot;
+  for (let i = 0; i < segments.length; i++) {
+    const s = segments[i];
+    let obj = curr[s];
+    switch (typeof obj) {
+      case 'undefined':
+        obj = curr[s] = Object.create(null);
+        break;
+      case 'object':
+        if (obj === null) {
+          conflictReporter(`Ignoring ${key} as ${segments.slice(0, i + 1).join('.')} is null`);
+          return;
+        }
+        break;
+      default:
+        conflictReporter(
+          `Ignoring ${key} as ${segments.slice(0, i + 1).join('.')} is ${JSON.stringify(obj)}`,
+        );
+        return;
+    }
+    curr = obj;
   }
 
-  private onDidUpdateConfiguration(properties: string[]): void {
-    this.updateConfigurationModel(
-      properties,
-      Registry.as<IConfigurationRegistry>(Extension.Configuration).getConfigurationProperties(),
-    );
-    this.emitter.emit({ defaults: this.configurationModel, properties });
+  if (typeof curr === 'object' && curr !== null) {
+    try {
+      curr[last] = value; // workaround https://github.com/microsoft/vscode/issues/13606
+    } catch (e) {
+      conflictReporter(`Ignoring ${key} as ${segments.join('.')} is ${JSON.stringify(curr)}`);
+    }
+  } else {
+    conflictReporter(`Ignoring ${key} as ${segments.join('.')} is ${JSON.stringify(curr)}`);
   }
+}
 
-  private resetConfigurationModel(): void {
-    this._configurationModel = ConfigurationModel.createEmptyModel();
+export function removeFromValueTree(valueTree: any, key: string): void {
+  const segments = key.split('.');
+  doRemoveFromValueTree(valueTree, segments);
+}
 
-    const properties = Registry.as<IConfigurationRegistry>(
-      Extension.Configuration,
-    ).getConfigurationProperties();
+function doRemoveFromValueTree(valueTree: any, segments: string[]): void {
+  const first = segments.shift()!;
+  if (segments.length === 0) {
+    // Reached last segment
+    delete valueTree[first];
+    return;
+  }
 
-    this.updateConfigurationModel(Object.keys(properties), properties);
+  if (Object.keys(valueTree).includes(first)) {
+    const value = valueTree[first];
+    if (typeof value === 'object' && !Array.isArray(value)) {
+      doRemoveFromValueTree(value, segments);
+      if (Object.keys(value).length === 0) {
+        delete valueTree[first];
+      }
+    }
   }
+}
+
+const OVERRIDE_IDENTIFIER_PATTERN = `\\[([^\\]]+)\\]`;
+const OVERRIDE_IDENTIFIER_REGEX = new RegExp(OVERRIDE_IDENTIFIER_PATTERN, 'g');
+export const OVERRIDE_PROPERTY_PATTERN = `^(${OVERRIDE_IDENTIFIER_PATTERN})+$`;
+export const OVERRIDE_PROPERTY_REGEX = new RegExp(OVERRIDE_PROPERTY_PATTERN);
 
-  private updateConfigurationModel(
-    properties: string[],
-    configurationProperties: StringDictionary<IRegisteredConfigurationPropertySchema>,
-  ): void {
-    for (const key of properties) {
-      const propertySchema = configurationProperties[key];
-      if (propertySchema) {
-        this.configurationModel.setValue(key, propertySchema.default);
-      } else {
-        this.configurationModel.removeValue(key);
+export function overrideIdentifiersFromKey(key: string): string[] {
+  const identifiers: string[] = [];
+  if (OVERRIDE_PROPERTY_REGEX.test(key)) {
+    let matches = OVERRIDE_IDENTIFIER_REGEX.exec(key);
+    while (matches?.length) {
+      const identifier = matches[1].trim();
+      if (identifier) {
+        identifiers.push(identifier);
       }
+      matches = OVERRIDE_IDENTIFIER_REGEX.exec(key);
     }
   }
+  return uniq(identifiers);
 }