@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/command-handlers/abstract-file-command-handler.mjs

@@ -0,0 +1,330 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  chain,
+  convertAsyncToSync
+} from "@mnaoumov/typescript-lib/async";
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { GlobalCommandHandler } from "./global-command-handler.mjs";
+class AbstractFileCommandHandler extends GlobalCommandHandler {
+  /**
+   * Get the active file provider.
+   *
+   * @returns The active file provider.
+   */
+  get activeFileProvider() {
+    return ensureNonNullable(this._activeFileProvider);
+  }
+  /**
+   * Gets the item name to use in the single-file menu.
+   *
+   * @returns The item name, or `undefined` to use the command name.
+   */
+  get fileMenuItemName() {
+    return this._fileMenuItemName;
+  }
+  /**
+   * Gets the section to use in the single-file menu.
+   *
+   * @returns The section name, or `undefined` to use the plugin name.
+   */
+  get fileMenuSection() {
+    return this._fileMenuSection;
+  }
+  /**
+   * Gets the icon to use in the single-file menu submenu.
+   *
+   * @returns The icon, or `undefined` for no icon.
+   */
+  get fileMenuSubmenuIcon() {
+    return this._fileMenuSubmenuIcon;
+  }
+  /**
+   * Gets the item name to use in the multi-file menu.
+   *
+   * @returns The item name, or `undefined` to fall back to single-file item name.
+   */
+  get filesMenuItemName() {
+    return this._filesMenuItemName;
+  }
+  /**
+   * Gets the section to use in the multi-file menu.
+   *
+   * @returns The section name, or `undefined` to fall back to single-file section.
+   */
+  get filesMenuSection() {
+    return this._filesMenuSection;
+  }
+  /**
+   * Gets the icon to use in the multi-file menu submenu.
+   *
+   * @returns The icon, or `undefined` to fall back to single-file submenu icon.
+   */
+  get filesMenuSubmenuIcon() {
+    return this._filesMenuSubmenuIcon;
+  }
+  _activeFileProvider;
+  _fileMenuItemName;
+  _fileMenuSection;
+  _fileMenuSubmenuIcon;
+  _filesMenuItemName;
+  _filesMenuSection;
+  _filesMenuSubmenuIcon;
+  _registrationShouldAddCommandToSubmenu;
+  _shouldAddCommandToSubmenu;
+  /**
+   * Creates a new abstract file command handler.
+   *
+   * @param params - The parameters for the abstract file command handler.
+   */
+  constructor(params) {
+    super(params);
+    this._fileMenuItemName = params.fileMenuItemName;
+    this._fileMenuSection = params.fileMenuSection;
+    this._fileMenuSubmenuIcon = params.fileMenuSubmenuIcon;
+    this._filesMenuItemName = params.filesMenuItemName;
+    this._filesMenuSection = params.filesMenuSection;
+    this._filesMenuSubmenuIcon = params.filesMenuSubmenuIcon;
+    this._shouldAddCommandToSubmenu = params.shouldAddCommandToSubmenu;
+  }
+  /**
+   * Registers file-menu and files-menu event handlers.
+   *
+   * @param context - The registration context.
+   */
+  async onRegistered(context) {
+    await super.onRegistered(context);
+    this._activeFileProvider = context.activeFileProvider;
+    this._registrationShouldAddCommandToSubmenu = context.shouldAddCommandToSubmenu;
+    context.menuEventRegistrar.registerFileMenuEventHandler((menu, abstractFile, source, leaf) => {
+      this.handleAbstractFileMenu({
+        abstractFile,
+        leaf,
+        menu,
+        source
+      });
+    });
+    context.menuEventRegistrar.registerFilesMenuEventHandler((menu, abstractFiles, source, leaf) => {
+      this.handleAbstractFilesMenu({
+        abstractFiles,
+        leaf,
+        menu,
+        source
+      });
+    });
+  }
+  /**
+   * Checks whether the command can execute from the command palette.
+   * Uses the active file as the target.
+   *
+   * @returns Whether the command can execute.
+   */
+  canExecute() {
+    if (!this.shouldAddToCommandPalette()) {
+      return false;
+    }
+    const activeFile = this.getActiveFile();
+    return !!activeFile && this.canExecuteAbstractFile(activeFile);
+  }
+  /**
+   * Checks whether the command can execute for a single abstract file.
+   *
+   * @param _abstractFile - The file or folder.
+   * @returns Whether the command can execute.
+   */
+  canExecuteAbstractFile(_abstractFile) {
+    return true;
+  }
+  /**
+   * Checks whether the command can execute for multiple abstract files.
+   * Default implementation checks each file individually.
+   *
+   * @param abstractFiles - The files or folders.
+   * @returns Whether the command can execute.
+   */
+  canExecuteAbstractFiles(abstractFiles) {
+    return abstractFiles.length > 0 && abstractFiles.every((f) => this.canExecuteAbstractFile(f));
+  }
+  /**
+   * Executes the command from the command palette using the active file.
+   *
+   * @returns `Promisable<void>` that resolves when command had been executed.
+   */
+  execute() {
+    const activeFile = this.getActiveFile();
+    if (activeFile) {
+      return this.executeAbstractFile(activeFile);
+    }
+  }
+  /**
+   * Executes the command for multiple abstract files.
+   * Default implementation executes sequentially.
+   *
+   * @param abstractFiles - The files or folders.
+   * @returns `Promisable<void>` that resolves when all abstract files have been executed.
+   */
+  executeAbstractFiles(abstractFiles) {
+    let promise = null;
+    for (const file of abstractFiles) {
+      promise = chain(promise, () => this.executeAbstractFile(file));
+    }
+    if (promise) {
+      return promise;
+    }
+  }
+  /**
+   * Gets the active file, if any, to use as the target when executing from the command palette.
+   *
+   * @returns The active file or `null` if none is active.
+   */
+  getActiveFile() {
+    return this.activeFileProvider.getActiveFile() ?? null;
+  }
+  /**
+   * Gets whether to add the command to a submenu.
+   *
+   * The registration context wins over the constructor value: a menu surface that already wraps every
+   * contributed item in a plugin-titled parent entry forces this off, because a section submenu
+   * declared here would make `Menu.sort()` nest a second plugin-titled entry inside the first.
+   *
+   * @returns Whether to add to a submenu.
+   */
+  shouldAddCommandToSubmenu() {
+    return this._registrationShouldAddCommandToSubmenu ?? this._shouldAddCommandToSubmenu;
+  }
+  /**
+   * Checks whether the command should appear in the single-file context menu.
+   *
+   * @param params - The parameters for the single-file menu check.
+   * @returns Whether to add to the file menu.
+   */
+  shouldAddToAbstractFileMenu(params) {
+    const { abstractFile: _abstractFile, leaf: _leaf, source: _source } = params;
+    return false;
+  }
+  /**
+   * Checks whether the command should appear in the multi-file context menu.
+   * Default implementation checks each file individually.
+   *
+   * @param params - The parameters for the multi-file menu check.
+   * @returns Whether to add to the files menu.
+   */
+  shouldAddToAbstractFilesMenu(params) {
+    return params.abstractFiles.every(
+      (f) => this.shouldAddToAbstractFileMenu({
+        abstractFile: f,
+        leaf: params.leaf,
+        source: params.source
+      })
+    );
+  }
+  /**
+   * Checks whether the command should appear in the command palette.
+   *
+   * @returns Whether to add to the command palette.
+   */
+  shouldAddToCommandPalette() {
+    return true;
+  }
+  handleAbstractFileMenu(params) {
+    const {
+      abstractFile,
+      leaf,
+      menu,
+      source
+    } = params;
+    if (!this.shouldAddToAbstractFileMenu({
+      abstractFile,
+      leaf,
+      source
+    }) || !this.canExecuteAbstractFile(abstractFile)) {
+      return;
+    }
+    const section = this.fileMenuSection ?? this.pluginName;
+    if (this.shouldAddCommandToSubmenu()) {
+      menu.setSectionSubmenu(section, {
+        icon: this.fileMenuSubmenuIcon ?? "",
+        title: section
+      });
+    }
+    menu.addItem((item) => {
+      item.setTitle(this.fileMenuItemName ?? this.name).setIcon(this.icon).setSection(section).onClick(convertAsyncToSync(async () => this.executeAbstractFile(abstractFile)));
+    });
+  }
+  handleAbstractFilesMenu(params) {
+    const {
+      abstractFiles,
+      leaf,
+      menu,
+      source
+    } = params;
+    if (!this.shouldAddToAbstractFilesMenu({
+      abstractFiles,
+      leaf,
+      source
+    }) || !this.canExecuteAbstractFiles(abstractFiles)) {
+      return;
+    }
+    const section = this.filesMenuSection ?? this.fileMenuSection ?? this.pluginName;
+    if (this.shouldAddCommandToSubmenu()) {
+      menu.setSectionSubmenu(section, {
+        icon: this.filesMenuSubmenuIcon ?? this.fileMenuSubmenuIcon ?? "",
+        title: section
+      });
+    }
+    menu.addItem((item) => {
+      item.setTitle(this.filesMenuItemName ?? this.fileMenuItemName ?? this.name).setIcon(this.icon).setSection(section).onClick(convertAsyncToSync(async () => this.executeAbstractFiles(abstractFiles)));
+    });
+  }
+}
+export {
+  AbstractFileCommandHandler
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/command-handlers/abstract-file-command-handler.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Command handler for abstract file commands with file/files menu integration.\n */\n\nimport type {\n  IconName,\n  Menu,\n  TAbstractFile,\n  WorkspaceLeaf\n} from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  chain,\n  convertAsyncToSync\n} from '@mnaoumov/typescript-lib/async';\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\nimport type { ActiveFileProvider } from '../active-file-provider.ts';\nimport type {\n  CommandHandlerConstructorParams,\n  CommandHandlerRegistrationContext\n} from './command-handler.ts';\n\nimport { GlobalCommandHandler } from './global-command-handler.ts';\n\n/**\n * Parameters for creating an abstract file command handler.\n */\nexport interface AbstractFileCommandHandlerConstructorParams extends CommandHandlerConstructorParams {\n  /**\n   * The item name to use in the single-file menu.\n   */\n  readonly fileMenuItemName?: string | undefined;\n\n  /**\n   * The section to use in the single-file menu.\n   */\n  readonly fileMenuSection?: string | undefined;\n\n  /**\n   * The icon to use in the single-file menu submenu.\n   */\n  readonly fileMenuSubmenuIcon?: IconName | undefined;\n\n  /**\n   * The item name to use in the multi-file menu.\n   */\n  readonly filesMenuItemName?: string | undefined;\n\n  /**\n   * The section to use in the multi-file menu.\n   */\n  readonly filesMenuSection?: string | undefined;\n\n  /**\n   * The icon to use in the multi-file menu submenu.\n   */\n  readonly filesMenuSubmenuIcon?: IconName | undefined;\n\n  /**\n   * Whether to add the command to a submenu.\n   *\n   * @default `false`\n   */\n  readonly shouldAddCommandToSubmenu?: boolean | undefined;\n}\n\n/**\n * Parameters for {@link AbstractFileCommandHandler.handleAbstractFileMenu}.\n */\nexport interface AbstractFileCommandHandlerHandleAbstractFileMenuParams {\n  /**\n   * The file or folder.\n   */\n  readonly abstractFile: TAbstractFile;\n\n  /**\n   * The workspace leaf, if available.\n   */\n  readonly leaf?: undefined | WorkspaceLeaf;\n\n  /**\n   * The menu to add items to.\n   */\n  readonly menu: Menu;\n\n  /**\n   * The source of the event.\n   */\n  readonly source: string;\n}\n\n/**\n * Parameters for {@link AbstractFileCommandHandler.handleAbstractFilesMenu}.\n */\nexport interface AbstractFileCommandHandlerHandleAbstractFilesMenuParams {\n  /**\n   * The files or folders.\n   */\n  readonly abstractFiles: TAbstractFile[];\n\n  /**\n   * The workspace leaf, if available.\n   */\n  readonly leaf?: undefined | WorkspaceLeaf;\n\n  /**\n   * The menu to add items to.\n   */\n  readonly menu: Menu;\n\n  /**\n   * The source of the event.\n   */\n  readonly source: string;\n}\n\n/**\n * Parameters for {@link AbstractFileCommandHandler.shouldAddToAbstractFileMenu}.\n */\nexport interface AbstractFileCommandHandlerShouldAddToAbstractFileMenuParams {\n  /**\n   * The file or folder.\n   */\n  readonly abstractFile: TAbstractFile;\n\n  /**\n   * The workspace leaf, if available.\n   */\n  readonly leaf?: undefined | WorkspaceLeaf;\n\n  /**\n   * The source of the event.\n   */\n  readonly source: string;\n}\n\n/**\n * Parameters for {@link AbstractFileCommandHandler.shouldAddToAbstractFilesMenu}.\n */\nexport interface AbstractFileCommandHandlerShouldAddToAbstractFilesMenuParams {\n  /**\n   * The files or folders.\n   */\n  readonly abstractFiles: TAbstractFile[];\n\n  /**\n   * The workspace leaf, if available.\n   */\n  readonly leaf?: undefined | WorkspaceLeaf;\n\n  /**\n   * The source of the event.\n   */\n  readonly source: string;\n}\n\n/**\n * Command handler for abstract file commands.\n *\n * Handles both single-file and multi-file context menus.\n * Subclasses override {@link canExecuteAbstractFile} and {@link executeAbstractFile}.\n */\nexport abstract class AbstractFileCommandHandler extends GlobalCommandHandler {\n  /**\n   * Get the active file provider.\n   *\n   * @returns The active file provider.\n   */\n  protected get activeFileProvider(): ActiveFileProvider {\n    return ensureNonNullable(this._activeFileProvider);\n  }\n\n  /**\n   * Gets the item name to use in the single-file menu.\n   *\n   * @returns The item name, or `undefined` to use the command name.\n   */\n  protected get fileMenuItemName(): string | undefined {\n    return this._fileMenuItemName;\n  }\n\n  /**\n   * Gets the section to use in the single-file menu.\n   *\n   * @returns The section name, or `undefined` to use the plugin name.\n   */\n  protected get fileMenuSection(): string | undefined {\n    return this._fileMenuSection;\n  }\n\n  /**\n   * Gets the icon to use in the single-file menu submenu.\n   *\n   * @returns The icon, or `undefined` for no icon.\n   */\n  protected get fileMenuSubmenuIcon(): IconName | undefined {\n    return this._fileMenuSubmenuIcon;\n  }\n\n  /**\n   * Gets the item name to use in the multi-file menu.\n   *\n   * @returns The item name, or `undefined` to fall back to single-file item name.\n   */\n  protected get filesMenuItemName(): string | undefined {\n    return this._filesMenuItemName;\n  }\n\n  /**\n   * Gets the section to use in the multi-file menu.\n   *\n   * @returns The section name, or `undefined` to fall back to single-file section.\n   */\n  protected get filesMenuSection(): string | undefined {\n    return this._filesMenuSection;\n  }\n\n  /**\n   * Gets the icon to use in the multi-file menu submenu.\n   *\n   * @returns The icon, or `undefined` to fall back to single-file submenu icon.\n   */\n  protected get filesMenuSubmenuIcon(): IconName | undefined {\n    return this._filesMenuSubmenuIcon;\n  }\n\n  private _activeFileProvider?: ActiveFileProvider;\n  private readonly _fileMenuItemName?: string | undefined;\n  private readonly _fileMenuSection?: string | undefined;\n  private readonly _fileMenuSubmenuIcon?: IconName | undefined;\n  private readonly _filesMenuItemName?: string | undefined;\n  private readonly _filesMenuSection?: string | undefined;\n  private readonly _filesMenuSubmenuIcon?: IconName | undefined;\n\n  private _registrationShouldAddCommandToSubmenu?: boolean | undefined;\n  private readonly _shouldAddCommandToSubmenu?: boolean | undefined;\n\n  /**\n   * Creates a new abstract file command handler.\n   *\n   * @param params - The parameters for the abstract file command handler.\n   */\n  public constructor(params: AbstractFileCommandHandlerConstructorParams) {\n    super(params);\n    this._fileMenuItemName = params.fileMenuItemName;\n    this._fileMenuSection = params.fileMenuSection;\n    this._fileMenuSubmenuIcon = params.fileMenuSubmenuIcon;\n    this._filesMenuItemName = params.filesMenuItemName;\n    this._filesMenuSection = params.filesMenuSection;\n    this._filesMenuSubmenuIcon = params.filesMenuSubmenuIcon;\n    this._shouldAddCommandToSubmenu = params.shouldAddCommandToSubmenu;\n  }\n\n  /**\n   * Registers file-menu and files-menu event handlers.\n   *\n   * @param context - The registration context.\n   */\n  public override async onRegistered(context: CommandHandlerRegistrationContext): Promise<void> {\n    await super.onRegistered(context);\n    this._activeFileProvider = context.activeFileProvider;\n    this._registrationShouldAddCommandToSubmenu = context.shouldAddCommandToSubmenu;\n    context.menuEventRegistrar.registerFileMenuEventHandler((menu, abstractFile, source, leaf) => {\n      this.handleAbstractFileMenu({\n        abstractFile,\n        leaf,\n        menu,\n        source\n      });\n    });\n    context.menuEventRegistrar.registerFilesMenuEventHandler((menu, abstractFiles, source, leaf) => {\n      this.handleAbstractFilesMenu({\n        abstractFiles,\n        leaf,\n        menu,\n        source\n      });\n    });\n  }\n\n  /**\n   * Checks whether the command can execute from the command palette.\n   * Uses the active file as the target.\n   *\n   * @returns Whether the command can execute.\n   */\n  protected override canExecute(): boolean {\n    if (!this.shouldAddToCommandPalette()) {\n      return false;\n    }\n\n    const activeFile = this.getActiveFile();\n    return !!activeFile && this.canExecuteAbstractFile(activeFile);\n  }\n\n  /**\n   * Checks whether the command can execute for a single abstract file.\n   *\n   * @param _abstractFile - The file or folder.\n   * @returns Whether the command can execute.\n   */\n  protected canExecuteAbstractFile(_abstractFile: TAbstractFile): boolean {\n    return true;\n  }\n\n  /**\n   * Checks whether the command can execute for multiple abstract files.\n   * Default implementation checks each file individually.\n   *\n   * @param abstractFiles - The files or folders.\n   * @returns Whether the command can execute.\n   */\n  protected canExecuteAbstractFiles(abstractFiles: TAbstractFile[]): boolean {\n    return abstractFiles.length > 0 && abstractFiles.every((f) => this.canExecuteAbstractFile(f));\n  }\n\n  /**\n   * Executes the command from the command palette using the active file.\n   *\n   * @returns `Promisable<void>` that resolves when command had been executed.\n   */\n  protected override execute(): Promisable<void> {\n    const activeFile = this.getActiveFile();\n    if (activeFile) {\n      return this.executeAbstractFile(activeFile);\n    }\n  }\n\n  /**\n   * Executes the command for a single abstract file.\n   *\n   * @param abstractFile - The file or folder.\n   */\n  protected abstract executeAbstractFile(abstractFile: TAbstractFile): Promisable<void>;\n\n  /**\n   * Executes the command for multiple abstract files.\n   * Default implementation executes sequentially.\n   *\n   * @param abstractFiles - The files or folders.\n   * @returns `Promisable<void>` that resolves when all abstract files have been executed.\n   */\n  protected executeAbstractFiles(abstractFiles: TAbstractFile[]): Promisable<void> {\n    let promise: null | Promise<void> = null;\n    for (const file of abstractFiles) {\n      promise = chain(promise, () => this.executeAbstractFile(file));\n    }\n\n    if (promise) {\n      return promise;\n    }\n  }\n\n  /**\n   * Gets the active file, if any, to use as the target when executing from the command palette.\n   *\n   * @returns The active file or `null` if none is active.\n   */\n  protected getActiveFile(): null | TAbstractFile {\n    return this.activeFileProvider.getActiveFile() ?? null;\n  }\n\n  /**\n   * Gets whether to add the command to a submenu.\n   *\n   * The registration context wins over the constructor value: a menu surface that already wraps every\n   * contributed item in a plugin-titled parent entry forces this off, because a section submenu\n   * declared here would make `Menu.sort()` nest a second plugin-titled entry inside the first.\n   *\n   * @returns Whether to add to a submenu.\n   */\n  protected shouldAddCommandToSubmenu(): boolean | undefined {\n    return this._registrationShouldAddCommandToSubmenu ?? this._shouldAddCommandToSubmenu;\n  }\n\n  /**\n   * Checks whether the command should appear in the single-file context menu.\n   *\n   * @param params - The parameters for the single-file menu check.\n   * @returns Whether to add to the file menu.\n   */\n  protected shouldAddToAbstractFileMenu(params: AbstractFileCommandHandlerShouldAddToAbstractFileMenuParams): boolean {\n    const { abstractFile: _abstractFile, leaf: _leaf, source: _source } = params;\n    return false;\n  }\n\n  /**\n   * Checks whether the command should appear in the multi-file context menu.\n   * Default implementation checks each file individually.\n   *\n   * @param params - The parameters for the multi-file menu check.\n   * @returns Whether to add to the files menu.\n   */\n  protected shouldAddToAbstractFilesMenu(params: AbstractFileCommandHandlerShouldAddToAbstractFilesMenuParams): boolean {\n    return params.abstractFiles.every((f) =>\n      this.shouldAddToAbstractFileMenu({\n        abstractFile: f,\n        leaf: params.leaf,\n        source: params.source\n      })\n    );\n  }\n\n  /**\n   * Checks whether the command should appear in the command palette.\n   *\n   * @returns Whether to add to the command palette.\n   */\n  protected shouldAddToCommandPalette(): boolean {\n    return true;\n  }\n\n  private handleAbstractFileMenu(params: AbstractFileCommandHandlerHandleAbstractFileMenuParams): void {\n    const {\n      abstractFile,\n      leaf,\n      menu,\n      source\n    } = params;\n    if (\n      !this.shouldAddToAbstractFileMenu({\n        abstractFile,\n        leaf,\n        source\n      }) || !this.canExecuteAbstractFile(abstractFile)\n    ) {\n      return;\n    }\n\n    const section = this.fileMenuSection ?? this.pluginName;\n    if (this.shouldAddCommandToSubmenu()) {\n      menu.setSectionSubmenu(section, {\n        icon: this.fileMenuSubmenuIcon ?? '',\n        title: section\n      });\n    }\n\n    menu.addItem((item) => {\n      item\n        .setTitle(this.fileMenuItemName ?? this.name)\n        .setIcon(this.icon)\n        .setSection(section)\n        .onClick(convertAsyncToSync(async () => this.executeAbstractFile(abstractFile)));\n    });\n  }\n\n  private handleAbstractFilesMenu(params: AbstractFileCommandHandlerHandleAbstractFilesMenuParams): void {\n    const {\n      abstractFiles,\n      leaf,\n      menu,\n      source\n    } = params;\n    if (\n      !this.shouldAddToAbstractFilesMenu({\n        abstractFiles,\n        leaf,\n        source\n      }) || !this.canExecuteAbstractFiles(abstractFiles)\n    ) {\n      return;\n    }\n\n    const section = this.filesMenuSection ?? this.fileMenuSection ?? this.pluginName;\n    if (this.shouldAddCommandToSubmenu()) {\n      menu.setSectionSubmenu(section, {\n        icon: this.filesMenuSubmenuIcon ?? this.fileMenuSubmenuIcon ?? '',\n        title: section\n      });\n    }\n\n    menu.addItem((item) => {\n      item\n        .setTitle(this.filesMenuItemName ?? this.fileMenuItemName ?? this.name)\n        .setIcon(this.icon)\n        .setSection(section)\n        .onClick(convertAsyncToSync(async () => this.executeAbstractFiles(abstractFiles)));\n    });\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/command-handlers/command-handler-component.d.mts

@@ -0,0 +1,146 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Component that registers {@link CommandHandler}s with Obsidian and ties their removal to a chosen lifetime.
+ */
+import type { DisposableEx } from '@mnaoumov/typescript-lib/disposable';
+import type { ActiveFileProvider } from '../active-file-provider.mjs';
+import type { CommandRegistrar } from '../command-registrar.mjs';
+import type { MenuEventRegistrar } from '../menu-event-registrar.mjs';
+import type { CommandHandler } from './command-handler.mjs';
+import { ComponentEx } from '../components/component-ex.mjs';
+/**
+ * Builds a fresh set of {@link CommandHandler}s.
+ *
+ * A factory rather than a ready-made array because {@link CommandHandlerComponent} registers the same
+ * handlers against several menu surfaces, and a handler carries per-registration state (its
+ * active-file provider, its plugin name, and whatever a subclass records in
+ * {@link CommandHandler.onRegistered}) — so every surface needs its own instances.
+ *
+ * Returning shared instances (`() => [handler1Singleton, handler2Singleton]`) reintroduces exactly the
+ * bug the factory exists to avoid, so it is not merely discouraged: {@link CommandHandler.onRegistered}
+ * throws on the second registration of an instance. {@link CommandHandlerComponent.registerCommandHandlers}
+ * awaits it, so that throw rejects the caller's promise instead of degrading into a wrong context menu.
+ *
+ * @returns The command handlers to register. A NEW instance of each on every call.
+ */
+export type CommandHandlerFactory = () => CommandHandler[];
+interface CommandHandlerComponentConstructorParams {
+    readonly activeFileProvider: ActiveFileProvider;
+    readonly additionalMenuEventRegistrars?: readonly MenuEventRegistrar[] | undefined;
+    /**
+     * Resolves the lifetime owner for a registration that names none of its own.
+     *
+     * When omitted, every registration is owned by the component itself, so its unload removes every command
+     * it registered — the behavior a standalone component has always had. No `@default` tag, because the
+     * effective default is a closure over `this` rather than a literal or a linkable symbol.
+     */
+    readonly commandLifetimeOwnerProvider?: CommandLifetimeOwnerProvider | undefined;
+    readonly commandRegistrar: CommandRegistrar;
+    readonly menuEventRegistrar: MenuEventRegistrar;
+    readonly pluginName: string;
+}
+interface CommandHandlerComponentRegisterCommandHandlersOptions {
+    /**
+     * The component whose unload removes the commands this call registers, overriding the component's
+     * {@link CommandLifetimeOwnerProvider} for this one call.
+     *
+     * Name one when the batch's lifetime differs from the default — the caller that needs it is one
+     * registering through a component whose default owner is some SHORTER-lived surface, and whose own
+     * commands have to outlive it.
+     */
+    readonly lifetimeOwner?: ComponentEx | undefined;
+}
+/**
+ * Resolves the component that owns the teardown of the commands a {@link CommandHandlerComponent.registerCommandHandlers}
+ * call registers — the one whose unload removes them from the palette.
+ *
+ * A provider rather than a component, because the owner is not stable for the life of the registering
+ * component. `PluginBase` hands back the wrapper holding the plugin's feature surface, and that wrapper is
+ * REPLACED wholesale every time the surface goes down and comes back (a declared dependency lost and
+ * regained, a declared conflict appearing and being resolved). A value captured once would tie the second
+ * cycle's commands to the first cycle's dead wrapper, where nothing would ever dispose them.
+ *
+ * @returns The component that should own the registration's teardown.
+ */
+type CommandLifetimeOwnerProvider = () => ComponentEx;
+/**
+ * Registers {@link CommandHandler}s with Obsidian and manages their lifecycle.
+ *
+ * Call {@link registerCommandHandlers} to register a batch of handlers on demand (as many times as
+ * needed while the component is alive); dispose the returned {@link DisposableEx} to unregister exactly
+ * those handlers — including any menu events they registered — or let the batch's LIFETIME OWNER unload to
+ * remove every command still registered through it.
+ *
+ * That owner is this component by default, which is why a standalone component removes its own commands
+ * when it unloads. It is overridable because the registering component and the registered commands do not
+ * always share a lifetime: `PluginBase` keeps ONE of these running for the whole life of the plugin — it is
+ * what the "your dependency went away" notice is built beside — while the commands a subclass registers from
+ * `onloadImpl` belong to the feature surface the gate tears down and rebuilds underneath it. So the owner is
+ * resolved per call, from a {@link CommandLifetimeOwnerProvider} or from the call's own `lifetimeOwner`.
+ *
+ * The same handlers are fed to every menu surface the component knows about: Obsidian's own workspace
+ * events, plus each additional {@link MenuEventRegistrar} bridging another plugin's menus.
+ */
+export declare class CommandHandlerComponent extends ComponentEx {
+    /**
+     * Provider for accessing the currently active file.
+     */
+    protected readonly activeFileProvider: ActiveFileProvider;
+    /**
+     * Registrars for menu surfaces that build their own plugin-titled parent entry, and therefore take
+     * the handlers with their section submenu forced off.
+     */
+    protected readonly additionalMenuEventRegistrars: readonly MenuEventRegistrar[];
+    /**
+     * Registrar used to add and remove commands with Obsidian.
+     */
+    protected readonly commandRegistrar: CommandRegistrar;
+    /**
+     * Registrar for menu event handlers.
+     */
+    protected readonly menuEventRegistrar: MenuEventRegistrar;
+    /**
+     * The name of the plugin that owns the commands.
+     */
+    protected readonly pluginName: string;
+    private readonly commandLifetimeOwnerProvider;
+    /**
+     * Creates a new command handler component.
+     *
+     * @param params - The constructor parameters.
+     */
+    constructor(params: CommandHandlerComponentConstructorParams);
+    /**
+     * Builds the command handlers and registers them with Obsidian, giving each its own runtime
+     * registration context. Each handler's command is added immediately; the returned
+     * {@link DisposableEx} removes the commands registered by this call — and any menu events those
+     * handlers registered via their context's {@link MenuEventRegistrar} — when disposed. Any command
+     * still registered when the component unloads is removed automatically.
+     *
+     * The factory is invoked once more for every additional menu surface, so a plugin declares its
+     * handlers ONCE and all surfaces are fed. Those extra passes add no commands — the palette already
+     * has every command from the first pass.
+     *
+     * Which component's unload removes them is the caller's to choose: `options.lifetimeOwner` for this one
+     * batch, otherwise whatever this component's {@link CommandLifetimeOwnerProvider} resolves to, which
+     * defaults to the component itself. A command must never outlive the collaborators its handler closes
+     * over — left on a longer-lived owner it stays in the palette calling into torn-down objects — so the
+     * owner to name is the shortest-lived thing the batch depends on.
+     *
+     * @param commandHandlerFactory - Builds a fresh set of command handlers, once per menu surface.
+     * @param options - The registration options.
+     * @returns A {@link DisposableEx} that unregisters the handlers (commands + menu events) registered by this call.
+     */
+    registerCommandHandlers(commandHandlerFactory: CommandHandlerFactory, options?: CommandHandlerComponentRegisterCommandHandlersOptions): Promise<DisposableEx>;
+    /**
+     * Hands a command handler its registration context, scoped so that disposing the returned scope
+     * unregisters exactly the menu events that handler registered.
+     *
+     * @param params - The parameters for this registration.
+     * @returns The handler's menu-event scope.
+     */
+    private registerMenuEventHandlers;
+}
+export {};