obsidian-dev-utils 55.4.1 → 56.0.0

package/dist/lib/esm/obsidian/command-handlers/abstract-file-command-handler.d.mts

@@ -0,0 +1,178 @@
+/**
+ * @file
+ *
+ * Command handler for abstract file commands with file/files menu integration.
+ */
+import type { IconName, TAbstractFile, WorkspaceLeaf } from 'obsidian';
+import type { CommandHandlerParams, CommandHandlerRegistrationContext } from './command-handler.mjs';
+import { GlobalCommandHandler } from './global-command-handler.mjs';
+/**
+ * Parameters for creating an abstract file command handler.
+ */
+export interface AbstractFileCommandHandlerParams extends CommandHandlerParams {
+    /**
+     * The item name to use in the single-file menu.
+     */
+    readonly fileMenuItemName?: string | undefined;
+    /**
+     * The section to use in the single-file menu.
+     */
+    readonly fileMenuSection?: string | undefined;
+    /**
+     * The icon to use in the single-file menu submenu.
+     */
+    readonly fileMenuSubmenuIcon?: IconName | undefined;
+    /**
+     * The item name to use in the multi-file menu.
+     */
+    readonly filesMenuItemName?: string | undefined;
+    /**
+     * The section to use in the multi-file menu.
+     */
+    readonly filesMenuSection?: string | undefined;
+    /**
+     * The icon to use in the multi-file menu submenu.
+     */
+    readonly filesMenuSubmenuIcon?: IconName | undefined;
+    /**
+     * Whether to add the command to a submenu.
+     */
+    readonly shouldAddCommandToSubmenu?: boolean | undefined;
+}
+/**
+ * Command handler for abstract file commands.
+ *
+ * Handles both single-file and multi-file context menus.
+ * Subclasses override {@link canExecuteAbstractFile} and {@link executeAbstractFile}.
+ */
+export declare abstract class AbstractFileCommandHandler extends GlobalCommandHandler {
+    /**
+     * Gets the item name to use in the single-file menu.
+     *
+     * @returns The item name, or `undefined` to use the command name.
+     */
+    protected get fileMenuItemName(): string | undefined;
+    /**
+     * Gets the section to use in the single-file menu.
+     *
+     * @returns The section name, or `undefined` to use the plugin name.
+     */
+    protected get fileMenuSection(): string | undefined;
+    /**
+     * Gets the icon to use in the single-file menu submenu.
+     *
+     * @returns The icon, or `undefined` for no icon.
+     */
+    protected get fileMenuSubmenuIcon(): IconName | undefined;
+    /**
+     * 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.
+     */
+    protected get filesMenuItemName(): string | undefined;
+    /**
+     * Gets the section to use in the multi-file menu.
+     *
+     * @returns The section name, or `undefined` to fall back to single-file section.
+     */
+    protected get filesMenuSection(): string | undefined;
+    /**
+     * Gets the icon to use in the multi-file menu submenu.
+     *
+     * @returns The icon, or `undefined` to fall back to single-file submenu icon.
+     */
+    protected get filesMenuSubmenuIcon(): IconName | undefined;
+    /**
+     * Gets whether to add the command to a submenu.
+     *
+     * @returns Whether to add to a submenu.
+     */
+    protected get shouldAddCommandToSubmenu(): boolean | undefined;
+    private readonly _fileMenuItemName?;
+    private readonly _fileMenuSection?;
+    private readonly _fileMenuSubmenuIcon?;
+    private readonly _filesMenuItemName?;
+    private readonly _filesMenuSection?;
+    private readonly _filesMenuSubmenuIcon?;
+    private readonly _shouldAddCommandToSubmenu?;
+    private activeFileProvider?;
+    /**
+     * Creates a new abstract file command handler.
+     *
+     * @param params - The parameters for the abstract file command handler.
+     */
+    constructor(params: AbstractFileCommandHandlerParams);
+    /**
+     * Registers file-menu and files-menu event handlers.
+     *
+     * @param context - The registration context.
+     */
+    onRegistered(context: CommandHandlerRegistrationContext): Promise<void>;
+    /**
+     * Checks whether the command can execute from the command palette.
+     * Uses the active file as the target.
+     *
+     * @returns Whether the command can execute.
+     */
+    protected canExecute(): boolean;
+    /**
+     * Checks whether the command can execute for a single abstract file.
+     *
+     * @param _abstractFile - The file or folder.
+     * @returns Whether the command can execute.
+     */
+    protected canExecuteAbstractFile(_abstractFile: TAbstractFile): boolean;
+    /**
+     * 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.
+     */
+    protected canExecuteAbstractFiles(abstractFiles: TAbstractFile[]): boolean;
+    /**
+     * Executes the command from the command palette using the active file.
+     */
+    protected execute(): Promise<void>;
+    /**
+     * Executes the command for a single abstract file.
+     *
+     * @param abstractFile - The file or folder.
+     */
+    protected abstract executeAbstractFile(abstractFile: TAbstractFile): Promise<void>;
+    /**
+     * Executes the command for multiple abstract files.
+     * Default implementation executes sequentially.
+     *
+     * @param abstractFiles - The files or folders.
+     */
+    protected executeAbstractFiles(abstractFiles: TAbstractFile[]): Promise<void>;
+    /**
+     * Checks whether the command should appear in the single-file context menu.
+     *
+     * @param _abstractFile - The file or folder.
+     * @param _source - The source of the event.
+     * @param _leaf - The workspace leaf, if available.
+     * @returns Whether to add to the file menu.
+     */
+    protected shouldAddToAbstractFileMenu(_abstractFile: TAbstractFile, _source: string, _leaf?: WorkspaceLeaf): boolean;
+    /**
+     * Checks whether the command should appear in the multi-file context menu.
+     * Default implementation checks each file individually.
+     *
+     * @param abstractFiles - The files or folders.
+     * @param source - The source of the event.
+     * @param leaf - The workspace leaf, if available.
+     * @returns Whether to add to the files menu.
+     */
+    protected shouldAddToAbstractFilesMenu(abstractFiles: TAbstractFile[], source: string, leaf?: WorkspaceLeaf): boolean;
+    /**
+     * Checks whether the command should appear in the command palette.
+     *
+     * @returns Whether to add to the command palette.
+     */
+    protected shouldAddToCommandPalette(): boolean;
+    private getActiveFile;
+    private handleAbstractFileMenu;
+    private handleAbstractFilesMenu;
+}

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

@@ -0,0 +1,247 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { invokeAsyncSafely } from "../../async.mjs";
+import { GlobalCommandHandler } from "./global-command-handler.mjs";
+class AbstractFileCommandHandler extends GlobalCommandHandler {
+  /**
+   * 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;
+  }
+  /**
+   * Gets whether to add the command to a submenu.
+   *
+   * @returns Whether to add to a submenu.
+   */
+  get shouldAddCommandToSubmenu() {
+    return this._shouldAddCommandToSubmenu;
+  }
+  _fileMenuItemName;
+  _fileMenuSection;
+  _fileMenuSubmenuIcon;
+  _filesMenuItemName;
+  _filesMenuSection;
+  _filesMenuSubmenuIcon;
+  _shouldAddCommandToSubmenu;
+  activeFileProvider;
+  /**
+   * 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;
+    context.menuEventRegistrar.registerFileMenuEventHandler(this.handleAbstractFileMenu.bind(this));
+    context.menuEventRegistrar.registerFilesMenuEventHandler(this.handleAbstractFilesMenu.bind(this));
+  }
+  /**
+   * 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.
+   */
+  async execute() {
+    const activeFile = this.getActiveFile();
+    if (activeFile) {
+      await this.executeAbstractFile(activeFile);
+    }
+  }
+  /**
+   * Executes the command for multiple abstract files.
+   * Default implementation executes sequentially.
+   *
+   * @param abstractFiles - The files or folders.
+   */
+  async executeAbstractFiles(abstractFiles) {
+    for (const file of abstractFiles) {
+      await this.executeAbstractFile(file);
+    }
+  }
+  /**
+   * Checks whether the command should appear in the single-file context menu.
+   *
+   * @param _abstractFile - The file or folder.
+   * @param _source - The source of the event.
+   * @param _leaf - The workspace leaf, if available.
+   * @returns Whether to add to the file menu.
+   */
+  shouldAddToAbstractFileMenu(_abstractFile, _source, _leaf) {
+    return false;
+  }
+  /**
+   * Checks whether the command should appear in the multi-file context menu.
+   * Default implementation checks each file individually.
+   *
+   * @param abstractFiles - The files or folders.
+   * @param source - The source of the event.
+   * @param leaf - The workspace leaf, if available.
+   * @returns Whether to add to the files menu.
+   */
+  shouldAddToAbstractFilesMenu(abstractFiles, source, leaf) {
+    return abstractFiles.every((f) => this.shouldAddToAbstractFileMenu(f, source, leaf));
+  }
+  /**
+   * Checks whether the command should appear in the command palette.
+   *
+   * @returns Whether to add to the command palette.
+   */
+  shouldAddToCommandPalette() {
+    return true;
+  }
+  getActiveFile() {
+    return this.activeFileProvider?.getActiveFile() ?? null;
+  }
+  handleAbstractFileMenu(menu, abstractFile, source, leaf) {
+    if (!this.shouldAddToAbstractFileMenu(abstractFile, source, leaf)) {
+      return;
+    }
+    if (!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(() => {
+        invokeAsyncSafely(() => this.executeAbstractFile(abstractFile));
+      });
+    });
+  }
+  handleAbstractFilesMenu(menu, abstractFiles, source, leaf) {
+    if (!this.shouldAddToAbstractFilesMenu(abstractFiles, source, leaf)) {
+      return;
+    }
+    if (!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(() => {
+        invokeAsyncSafely(() => this.executeAbstractFiles(abstractFiles));
+      });
+    });
+  }
+}
+export {
+  AbstractFileCommandHandler
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/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';\n\nimport type {\n  ActiveFileProvider,\n  CommandHandlerParams,\n  CommandHandlerRegistrationContext\n} from './command-handler.ts';\n\nimport { invokeAsyncSafely } from '../../async.ts';\nimport { GlobalCommandHandler } from './global-command-handler.ts';\n\n/**\n * Parameters for creating an abstract file command handler.\n */\nexport interface AbstractFileCommandHandlerParams extends CommandHandlerParams {\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  readonly shouldAddCommandToSubmenu?: boolean | undefined;\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   * 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  /**\n   * Gets whether to add the command to a submenu.\n   *\n   * @returns Whether to add to a submenu.\n   */\n  protected get shouldAddCommandToSubmenu(): boolean | undefined {\n    return this._shouldAddCommandToSubmenu;\n  }\n\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  private readonly _shouldAddCommandToSubmenu?: boolean | undefined;\n  private activeFileProvider?: ActiveFileProvider;\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: AbstractFileCommandHandlerParams) {\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    context.menuEventRegistrar.registerFileMenuEventHandler(this.handleAbstractFileMenu.bind(this));\n    context.menuEventRegistrar.registerFilesMenuEventHandler(this.handleAbstractFilesMenu.bind(this));\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  protected override async execute(): Promise<void> {\n    const activeFile = this.getActiveFile();\n    if (activeFile) {\n      await 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): Promise<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   */\n  protected async executeAbstractFiles(abstractFiles: TAbstractFile[]): Promise<void> {\n    for (const file of abstractFiles) {\n      await this.executeAbstractFile(file);\n    }\n  }\n\n  /**\n   * Checks whether the command should appear in the single-file context menu.\n   *\n   * @param _abstractFile - The file or folder.\n   * @param _source - The source of the event.\n   * @param _leaf - The workspace leaf, if available.\n   * @returns Whether to add to the file menu.\n   */\n  protected shouldAddToAbstractFileMenu(_abstractFile: TAbstractFile, _source: string, _leaf?: WorkspaceLeaf): boolean {\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 abstractFiles - The files or folders.\n   * @param source - The source of the event.\n   * @param leaf - The workspace leaf, if available.\n   * @returns Whether to add to the files menu.\n   */\n  protected shouldAddToAbstractFilesMenu(abstractFiles: TAbstractFile[], source: string, leaf?: WorkspaceLeaf): boolean {\n    return abstractFiles.every((f) => this.shouldAddToAbstractFileMenu(f, source, leaf));\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 getActiveFile(): null | TAbstractFile {\n    return this.activeFileProvider?.getActiveFile() ?? null;\n  }\n\n  private handleAbstractFileMenu(menu: Menu, abstractFile: TAbstractFile, source: string, leaf?: WorkspaceLeaf): void {\n    if (!this.shouldAddToAbstractFileMenu(abstractFile, source, leaf)) {\n      return;\n    }\n\n    if (!this.canExecuteAbstractFile(abstractFile)) {\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(() => {\n          invokeAsyncSafely(() => this.executeAbstractFile(abstractFile));\n        });\n    });\n  }\n\n  private handleAbstractFilesMenu(menu: Menu, abstractFiles: TAbstractFile[], source: string, leaf?: WorkspaceLeaf): void {\n    if (!this.shouldAddToAbstractFilesMenu(abstractFiles, source, leaf)) {\n      return;\n    }\n\n    if (!this.canExecuteAbstractFiles(abstractFiles)) {\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(() => {\n          invokeAsyncSafely(() => this.executeAbstractFiles(abstractFiles));\n        });\n    });\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/command-handlers/app-active-file-provider.d.mts

@@ -0,0 +1,25 @@
+/**
+ * @file
+ *
+ * App-backed implementation of {@link ActiveFileProvider}.
+ */
+import type { App, TFile } from 'obsidian';
+import type { ActiveFileProvider } from './command-handler.mjs';
+/**
+ * {@link ActiveFileProvider} backed by Obsidian's {@link App}.
+ */
+export declare class AppActiveFileProvider implements ActiveFileProvider {
+    private readonly app;
+    /**
+     * Creates a new app-backed active file provider.
+     *
+     * @param app - The Obsidian app instance.
+     */
+    constructor(app: App);
+    /**
+     * Gets the currently active file from the workspace.
+     *
+     * @returns The active file, or `null` if no file is active.
+     */
+    getActiveFile(): null | TFile;
+}

package/dist/lib/esm/obsidian/command-handlers/app-active-file-provider.mjs

@@ -0,0 +1,46 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+class AppActiveFileProvider {
+  /**
+   * Creates a new app-backed active file provider.
+   *
+   * @param app - The Obsidian app instance.
+   */
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  /**
+   * Gets the currently active file from the workspace.
+   *
+   * @returns The active file, or `null` if no file is active.
+   */
+  getActiveFile() {
+    return this.app.workspace.getActiveFile();
+  }
+}
+export {
+  AppActiveFileProvider
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2NvbW1hbmQtaGFuZGxlcnMvYXBwLWFjdGl2ZS1maWxlLXByb3ZpZGVyLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogQXBwLWJhY2tlZCBpbXBsZW1lbnRhdGlvbiBvZiB7QGxpbmsgQWN0aXZlRmlsZVByb3ZpZGVyfS5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7XG4gIEFwcCxcbiAgVEZpbGVcbn0gZnJvbSAnb2JzaWRpYW4nO1xuXG5pbXBvcnQgdHlwZSB7IEFjdGl2ZUZpbGVQcm92aWRlciB9IGZyb20gJy4vY29tbWFuZC1oYW5kbGVyLnRzJztcblxuLyoqXG4gKiB7QGxpbmsgQWN0aXZlRmlsZVByb3ZpZGVyfSBiYWNrZWQgYnkgT2JzaWRpYW4ncyB7QGxpbmsgQXBwfS5cbiAqL1xuZXhwb3J0IGNsYXNzIEFwcEFjdGl2ZUZpbGVQcm92aWRlciBpbXBsZW1lbnRzIEFjdGl2ZUZpbGVQcm92aWRlciB7XG4gIC8qKlxuICAgKiBDcmVhdGVzIGEgbmV3IGFwcC1iYWNrZWQgYWN0aXZlIGZpbGUgcHJvdmlkZXIuXG4gICAqXG4gICAqIEBwYXJhbSBhcHAgLSBUaGUgT2JzaWRpYW4gYXBwIGluc3RhbmNlLlxuICAgKi9cbiAgcHVibGljIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgYXBwOiBBcHApIHt9XG5cbiAgLyoqXG4gICAqIEdldHMgdGhlIGN1cnJlbnRseSBhY3RpdmUgZmlsZSBmcm9tIHRoZSB3b3Jrc3BhY2UuXG4gICAqXG4gICAqIEByZXR1cm5zIFRoZSBhY3RpdmUgZmlsZSwgb3IgYG51bGxgIGlmIG5vIGZpbGUgaXMgYWN0aXZlLlxuICAgKi9cbiAgcHVibGljIGdldEFjdGl2ZUZpbGUoKTogbnVsbCB8IFRGaWxlIHtcbiAgICByZXR1cm4gdGhpcy5hcHAud29ya3NwYWNlLmdldEFjdGl2ZUZpbGUoKTtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFnQk8sTUFBTSxzQkFBb0Q7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFNeEQsWUFBNkIsS0FBVTtBQUFWO0FBQUEsRUFBVztBQUFBLEVBQVg7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPN0IsZ0JBQThCO0FBQ25DLFdBQU8sS0FBSyxJQUFJLFVBQVUsY0FBYztBQUFBLEVBQzFDO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/obsidian/command-handlers/app-menu-event-registrar.d.mts

@@ -0,0 +1,41 @@
+/**
+ * @file
+ *
+ * App-backed implementation of {@link MenuEventRegistrar}.
+ */
+import type { App, Component } from 'obsidian';
+import type { EditorMenuEventHandler, FileMenuEventHandler, FilesMenuEventHandler, MenuEventRegistrar } from './command-handler.mjs';
+/**
+ * {@link MenuEventRegistrar} backed by Obsidian's {@link App} workspace events.
+ *
+ * Event handlers are registered with the provided {@link Component} for lifecycle management.
+ */
+export declare class AppMenuEventRegistrar implements MenuEventRegistrar {
+    private readonly app;
+    private readonly component;
+    /**
+     * Creates a new app-backed menu event registrar.
+     *
+     * @param app - The Obsidian app instance.
+     * @param component - The component for lifecycle management.
+     */
+    constructor(app: App, component: Component);
+    /**
+     * Registers a handler for the editor context menu event.
+     *
+     * @param handler - The handler to register.
+     */
+    registerEditorMenuEventHandler(handler: EditorMenuEventHandler): void;
+    /**
+     * Registers a handler for the single-file context menu event.
+     *
+     * @param handler - The handler to register.
+     */
+    registerFileMenuEventHandler(handler: FileMenuEventHandler): void;
+    /**
+     * Registers a handler for the multi-file context menu event.
+     *
+     * @param handler - The handler to register.
+     */
+    registerFilesMenuEventHandler(handler: FilesMenuEventHandler): void;
+}

package/dist/lib/esm/obsidian/command-handlers/app-menu-event-registrar.mjs

@@ -0,0 +1,65 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/prefer-active-doc -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+class AppMenuEventRegistrar {
+  /**
+   * Creates a new app-backed menu event registrar.
+   *
+   * @param app - The Obsidian app instance.
+   * @param component - The component for lifecycle management.
+   */
+  constructor(app, component) {
+    this.app = app;
+    this.component = component;
+  }
+  app;
+  component;
+  /**
+   * Registers a handler for the editor context menu event.
+   *
+   * @param handler - The handler to register.
+   */
+  registerEditorMenuEventHandler(handler) {
+    this.component.registerEvent(this.app.workspace.on("editor-menu", handler));
+  }
+  /**
+   * Registers a handler for the single-file context menu event.
+   *
+   * @param handler - The handler to register.
+   */
+  registerFileMenuEventHandler(handler) {
+    this.component.registerEvent(this.app.workspace.on("file-menu", handler));
+  }
+  /**
+   * Registers a handler for the multi-file context menu event.
+   *
+   * @param handler - The handler to register.
+   */
+  registerFilesMenuEventHandler(handler) {
+    this.component.registerEvent(this.app.workspace.on("files-menu", handler));
+  }
+}
+export {
+  AppMenuEventRegistrar
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,26 @@
+/**
+ * @file
+ *
+ * Component that wraps a {@link CommandHandler} and manages its registration with Obsidian.
+ */
+import type { Plugin } from 'obsidian';
+import type { CommandHandler } from './command-handler.mjs';
+import { AsyncComponentBase } from '../components/async-component.mjs';
+/**
+ * Wraps a {@link CommandHandler} and registers it with Obsidian on load.
+ */
+export declare class CommandHandlerComponent extends AsyncComponentBase {
+    private readonly plugin;
+    readonly handler: CommandHandler;
+    /**
+     * Creates a new command handler component.
+     *
+     * @param plugin - The Obsidian plugin instance.
+     * @param handler - The command handler to register.
+     */
+    constructor(plugin: Plugin, handler: CommandHandler);
+    /**
+     * Registers the command with Obsidian and provides runtime context to the handler.
+     */
+    onload(): Promise<void>;
+}