Class Command

packages/editor-core/src/command.ts:15–91

}

export class Command implements ICommand {
  private commands: Map<string, IPublicTypeCommand> = new Map();
  private commandErrors: Function[] = [];

  registerCommand(command: IPublicTypeCommand, options?: ICommandOptions): void {
    if (!options?.commandScope) {
      throw new Error('plugin meta.commandScope is required.');
    }
    const name = `${options.commandScope}:${command.name}`;
    if (this.commands.has(name)) {
      throw new Error(`Command '${command.name}' is already registered.`);
    }
    this.commands.set(name, {
      ...command,
      name,
    });
  }

  unregisterCommand(name: string): void {
    if (!this.commands.has(name)) {
      throw new Error(`Command '${name}' is not registered.`);
    }
    this.commands.delete(name);
  }

  executeCommand(name: string, args: IPublicTypeCommandHandlerArgs): void {
    const command = this.commands.get(name);
    if (!command) {
      throw new Error(`Command '${name}' is not registered.`);
    }
    command.parameters?.forEach(d => {
      if (!checkPropTypes(args[d.name], d.name, d.propType, 'command')) {
        throw new Error(`Command '${name}' arguments ${d.name} is invalid.`);
      }
    });
    try {
      command.handler(args);
    } catch (error) {
      if (this.commandErrors && this.commandErrors.length) {
        this.commandErrors.forEach(callback => callback(name, error));
      } else {
        throw error;
      }
    }
  }

  batchExecuteCommand(commands: { name: string; args: IPublicTypeCommandHandlerArgs }[], pluginContext: IPublicModelPluginContext): void {
    if (!commands || !commands.length) {
      return;
    }
    pluginContext.common.utils.executeTransaction(() => {
      commands.forEach(command => this.executeCommand(command.name, command.args));
    }, IPublicEnumTransitionType.REPAINT);
  }

  listCommands(): IPublicTypeListCommand[] {
    return Array.from(this.commands.values()).map(d => {
      const result: IPublicTypeListCommand = {