obsidian-dev-utils 80.0.2 → 81.0.0

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

@@ -6,8 +6,42 @@
  */
 import type { TAbstractFile, TFolder, WorkspaceLeaf } from 'obsidian';
 import type { Promisable } from 'type-fest';
-import type { AbstractFileCommandHandlerConstructorParams } from './abstract-file-command-handler.mjs';
+import type { AbstractFileCommandHandlerConstructorParams, AbstractFileCommandHandlerShouldAddToAbstractFileMenuParams, AbstractFileCommandHandlerShouldAddToAbstractFilesMenuParams } from './abstract-file-command-handler.mjs';
 import { AbstractFileCommandHandler } from './abstract-file-command-handler.mjs';
+/**
+ * Parameters for {@link FolderCommandHandler.shouldAddToFolderMenu}.
+ */
+export interface FolderCommandHandlerShouldAddToFolderMenuParams {
+    /**
+     * The folder.
+     */
+    readonly folder: TFolder;
+    /**
+     * The workspace leaf, if available.
+     */
+    readonly leaf?: undefined | WorkspaceLeaf;
+    /**
+     * The source of the event.
+     */
+    readonly source: string;
+}
+/**
+ * Parameters for {@link FolderCommandHandler.shouldAddToFoldersMenu}.
+ */
+export interface FolderCommandHandlerShouldAddToFoldersMenuParams {
+    /**
+     * The folders.
+     */
+    readonly folders: TFolder[];
+    /**
+     * The workspace leaf, if available.
+     */
+    readonly leaf?: undefined | WorkspaceLeaf;
+    /**
+     * The source of the event.
+     */
+    readonly source: string;
+}
 /**
  * Command handler for folder-specific commands.
  *
@@ -87,37 +121,29 @@ export declare abstract class FolderCommandHandler extends AbstractFileCommandHa
     /**
      * Filters to only show menu for TFolder instances.
      *
-     * @param abstractFile - The file or folder.
-     * @param source - The source of the event.
-     * @param leaf - The workspace leaf, if available.
+     * @param params - The parameters for the single-file menu check.
      * @returns Whether to add to the file menu.
      */
-    protected shouldAddToAbstractFileMenu(abstractFile: TAbstractFile, source: string, leaf?: WorkspaceLeaf): boolean;
+    protected shouldAddToAbstractFileMenu(params: AbstractFileCommandHandlerShouldAddToAbstractFileMenuParams): boolean;
     /**
      * Filters to only show menu for TFolder arrays.
      *
-     * @param abstractFiles - The files or folders.
-     * @param source - The source of the event.
-     * @param leaf - The workspace leaf, if available.
+     * @param params - The parameters for the multi-file menu check.
      * @returns Whether to add to the files menu.
      */
-    protected shouldAddToAbstractFilesMenu(abstractFiles: TAbstractFile[], source: string, leaf?: WorkspaceLeaf): boolean;
+    protected shouldAddToAbstractFilesMenu(params: AbstractFileCommandHandlerShouldAddToAbstractFilesMenuParams): boolean;
     /**
      * Checks whether the command should appear in the single-folder context menu.
      *
-     * @param _folder - The folder.
-     * @param _source - The source of the event.
-     * @param _leaf - The workspace leaf, if available.
+     * @param params - The parameters for the single-folder menu check.
      * @returns Whether to add to the folder menu.
      */
-    protected shouldAddToFolderMenu(_folder: TFolder, _source: string, _leaf?: WorkspaceLeaf): boolean;
+    protected shouldAddToFolderMenu(params: FolderCommandHandlerShouldAddToFolderMenuParams): boolean;
     /**
      * Checks whether the command should appear in the multi-folder context menu.
      *
-     * @param _folders - The folders.
-     * @param _source - The source of the event.
-     * @param _leaf - The workspace leaf, if available.
+     * @param params - The parameters for the multi-folder menu check.
      * @returns Whether to add to the folders menu.
      */
-    protected shouldAddToFoldersMenu(_folders: TFolder[], _source: string, _leaf?: WorkspaceLeaf): boolean;
+    protected shouldAddToFoldersMenu(params: FolderCommandHandlerShouldAddToFoldersMenuParams): boolean;
 }

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

@@ -120,55 +120,69 @@ class FolderCommandHandler extends AbstractFileCommandHandler {
   /**
    * Filters to only show menu for TFolder instances.
    *
-   * @param abstractFile - The file or folder.
-   * @param source - The source of the event.
-   * @param leaf - The workspace leaf, if available.
+   * @param params - The parameters for the single-file menu check.
    * @returns Whether to add to the file menu.
    */
-  shouldAddToAbstractFileMenu(abstractFile, source, leaf) {
+  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Override keeps the base class param type.
+  shouldAddToAbstractFileMenu(params) {
+    const {
+      abstractFile,
+      leaf,
+      source
+    } = params;
     if (!isFolder(abstractFile)) {
       return false;
     }
-    return this.shouldAddToFolderMenu(abstractFile, source, leaf);
+    return this.shouldAddToFolderMenu({
+      folder: abstractFile,
+      leaf,
+      source
+    });
   }
   /**
    * Filters to only show menu for TFolder arrays.
    *
-   * @param abstractFiles - The files or folders.
-   * @param source - The source of the event.
-   * @param leaf - The workspace leaf, if available.
+   * @param params - The parameters for the multi-file menu check.
    * @returns Whether to add to the files menu.
    */
-  shouldAddToAbstractFilesMenu(abstractFiles, source, leaf) {
+  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Override keeps the base class param type.
+  shouldAddToAbstractFilesMenu(params) {
+    const {
+      abstractFiles,
+      leaf,
+      source
+    } = params;
     if (!abstractFiles.every((f) => isFolder(f))) {
       return false;
     }
-    return this.shouldAddToFoldersMenu(asArrayOfFolders(abstractFiles), source, leaf);
+    return this.shouldAddToFoldersMenu({
+      folders: asArrayOfFolders(abstractFiles),
+      leaf,
+      source
+    });
   }
   /**
    * Checks whether the command should appear in the single-folder context menu.
    *
-   * @param _folder - The folder.
-   * @param _source - The source of the event.
-   * @param _leaf - The workspace leaf, if available.
+   * @param params - The parameters for the single-folder menu check.
    * @returns Whether to add to the folder menu.
    */
-  shouldAddToFolderMenu(_folder, _source, _leaf) {
+  shouldAddToFolderMenu(params) {
+    const { folder: _folder, leaf: _leaf, source: _source } = params;
     return false;
   }
   /**
    * Checks whether the command should appear in the multi-folder context menu.
    *
-   * @param _folders - The folders.
-   * @param _source - The source of the event.
-   * @param _leaf - The workspace leaf, if available.
+   * @param params - The parameters for the multi-folder menu check.
    * @returns Whether to add to the folders menu.
    */
-  shouldAddToFoldersMenu(_folders, _source, _leaf) {
+  shouldAddToFoldersMenu(params) {
+    const { folders: _folders, leaf: _leaf, source: _source } = params;
     return false;
   }
 }
 export {
   FolderCommandHandler
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/command-handlers/folder-command-handler.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Command handler for folder-specific commands (TFolder only, not TFile).\n */\n\nimport type {\n  TAbstractFile,\n  TFolder,\n  WorkspaceLeaf\n} from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport type { AbstractFileCommandHandlerConstructorParams } from './abstract-file-command-handler.ts';\n\nimport { chain } from '../../async.ts';\nimport {\n  asArrayOfFolders,\n  asFolder,\n  isFolder\n} from '../file-system.ts';\nimport { AbstractFileCommandHandler } from './abstract-file-command-handler.ts';\n\n/**\n * Command handler for folder-specific commands.\n *\n * Filters abstract files to only accept {@link TFolder} instances.\n * Subclasses override {@link canExecuteFolder} and {@link executeFolder}.\n */\nexport abstract class FolderCommandHandler extends AbstractFileCommandHandler {\n  /**\n   * Creates a new folder command handler.\n   *\n   * @param params - The parameters for the folder command handler.\n   */\n  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Inherits parent's params type.\n  public constructor(params: AbstractFileCommandHandlerConstructorParams) {\n    super(params);\n  }\n\n  /**\n   * Filters to only accept TFolder instances, then delegates to {@link canExecuteFolder}.\n   *\n   * @param abstractFile - The file or folder.\n   * @returns Whether the command can execute.\n   */\n  protected override canExecuteAbstractFile(abstractFile: TAbstractFile): boolean {\n    return isFolder(abstractFile) && this.canExecuteFolder(abstractFile);\n  }\n\n  /**\n   * Filters to only accept TFolder arrays, then delegates to {@link canExecuteFolders}.\n   *\n   * @param abstractFiles - The files or folders.\n   * @returns Whether the command can execute.\n   */\n  protected override canExecuteAbstractFiles(abstractFiles: TAbstractFile[]): boolean {\n    return abstractFiles.every((f) => isFolder(f)) && this.canExecuteFolders(asArrayOfFolders(abstractFiles));\n  }\n\n  /**\n   * Checks whether the command can execute for a single folder.\n   *\n   * @param _folder - The folder.\n   * @returns Whether the command can execute.\n   */\n  protected canExecuteFolder(_folder: TFolder): boolean {\n    return true;\n  }\n\n  /**\n   * Checks whether the command can execute for multiple folders.\n   * Default implementation checks each folder individually.\n   *\n   * @param folders - The folders.\n   * @returns Whether the command can execute.\n   */\n  protected canExecuteFolders(folders: TFolder[]): boolean {\n    return folders.length > 0 && folders.every((f) => this.canExecuteFolder(f));\n  }\n\n  /**\n   * Delegates to {@link executeFolder}.\n   *\n   * @param abstractFile - The file or folder.\n   * @returns `Promisable<void>` that resolves when abstract file had been executed.\n   */\n  protected override executeAbstractFile(abstractFile: TAbstractFile): Promisable<void> {\n    return this.executeFolder(asFolder(abstractFile));\n  }\n\n  /**\n   * Delegates to {@link executeFolders}.\n   *\n   * @param abstractFiles - The files or folders.\n   * @returns `Promisable<void>` that resolves when all abstract files have been executed.\n   */\n  protected override executeAbstractFiles(abstractFiles: TAbstractFile[]): Promisable<void> {\n    return this.executeFolders(asArrayOfFolders(abstractFiles));\n  }\n\n  /**\n   * Executes the command for a single folder.\n   *\n   * @param folder - The folder.\n   */\n  protected abstract executeFolder(folder: TFolder): Promisable<void>;\n\n  /**\n   * Executes the command for multiple folders.\n   * Default implementation executes sequentially.\n   *\n   * @param folders - The folders.\n   * @returns `Promisable<void>` that resolves when all folders have been executed.\n   */\n  protected executeFolders(folders: TFolder[]): Promisable<void> {\n    let promise: null | Promise<void> = null;\n    for (const folder of folders) {\n      promise = chain(promise, () => this.executeFolder(folder));\n    }\n\n    if (promise) {\n      return promise;\n    }\n  }\n\n  /**\n   * Gets the active folder, if any, to use as the target when executing from the command palette.\n   *\n   * @returns The active folder or `null` if none is active.\n   */\n  protected override getActiveFile(): null | TAbstractFile {\n    return this.activeFileProvider.getActiveFile()?.parent ?? null;\n  }\n\n  /**\n   * Filters to only show menu for TFolder instances.\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 override shouldAddToAbstractFileMenu(abstractFile: TAbstractFile, source: string, leaf?: WorkspaceLeaf): boolean {\n    if (!isFolder(abstractFile)) {\n      return false;\n    }\n    return this.shouldAddToFolderMenu(abstractFile, source, leaf);\n  }\n\n  /**\n   * Filters to only show menu for TFolder arrays.\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 override shouldAddToAbstractFilesMenu(abstractFiles: TAbstractFile[], source: string, leaf?: WorkspaceLeaf): boolean {\n    if (!abstractFiles.every((f) => isFolder(f))) {\n      return false;\n    }\n    return this.shouldAddToFoldersMenu(asArrayOfFolders(abstractFiles), source, leaf);\n  }\n\n  /**\n   * Checks whether the command should appear in the single-folder context menu.\n   *\n   * @param _folder - The folder.\n   * @param _source - The source of the event.\n   * @param _leaf - The workspace leaf, if available.\n   * @returns Whether to add to the folder menu.\n   */\n  protected shouldAddToFolderMenu(_folder: TFolder, _source: string, _leaf?: WorkspaceLeaf): boolean {\n    return false;\n  }\n\n  /**\n   * Checks whether the command should appear in the multi-folder context menu.\n   *\n   * @param _folders - The folders.\n   * @param _source - The source of the event.\n   * @param _leaf - The workspace leaf, if available.\n   * @returns Whether to add to the folders menu.\n   */\n  protected shouldAddToFoldersMenu(_folders: TFolder[], _source: string, _leaf?: WorkspaceLeaf): boolean {\n    return false;\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAeA,SAAS,aAAa;AACtB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,kCAAkC;AAQpC,MAAe,6BAA6B,2BAA2B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOrE,YAAY,QAAqD;AACtE,UAAM,MAAM;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQmB,uBAAuB,cAAsC;AAC9E,WAAO,SAAS,YAAY,KAAK,KAAK,iBAAiB,YAAY;AAAA,EACrE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQmB,wBAAwB,eAAyC;AAClF,WAAO,cAAc,MAAM,CAAC,MAAM,SAAS,CAAC,CAAC,KAAK,KAAK,kBAAkB,iBAAiB,aAAa,CAAC;AAAA,EAC1G;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,iBAAiB,SAA2B;AACpD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASU,kBAAkB,SAA6B;AACvD,WAAO,QAAQ,SAAS,KAAK,QAAQ,MAAM,CAAC,MAAM,KAAK,iBAAiB,CAAC,CAAC;AAAA,EAC5E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQmB,oBAAoB,cAA+C;AACpF,WAAO,KAAK,cAAc,SAAS,YAAY,CAAC;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQmB,qBAAqB,eAAkD;AACxF,WAAO,KAAK,eAAe,iBAAiB,aAAa,CAAC;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBU,eAAe,SAAsC;AAC7D,QAAI,UAAgC;AACpC,eAAW,UAAU,SAAS;AAC5B,gBAAU,MAAM,SAAS,MAAM,KAAK,cAAc,MAAM,CAAC;AAAA,IAC3D;AAEA,QAAI,SAAS;AACX,aAAO;AAAA,IACT;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOmB,gBAAsC;AACvD,WAAO,KAAK,mBAAmB,cAAc,GAAG,UAAU;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUmB,4BAA4B,cAA6B,QAAgB,MAA+B;AACzH,QAAI,CAAC,SAAS,YAAY,GAAG;AAC3B,aAAO;AAAA,IACT;AACA,WAAO,KAAK,sBAAsB,cAAc,QAAQ,IAAI;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUmB,6BAA6B,eAAgC,QAAgB,MAA+B;AAC7H,QAAI,CAAC,cAAc,MAAM,CAAC,MAAM,SAAS,CAAC,CAAC,GAAG;AAC5C,aAAO;AAAA,IACT;AACA,WAAO,KAAK,uBAAuB,iBAAiB,aAAa,GAAG,QAAQ,IAAI;AAAA,EAClF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUU,sBAAsB,SAAkB,SAAiB,OAAgC;AACjG,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUU,uBAAuB,UAAqB,SAAiB,OAAgC;AACrG,WAAO;AAAA,EACT;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/command-handlers/folder-command-handler.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Command handler for folder-specific commands (TFolder only, not TFile).\n */\n\nimport type {\n  TAbstractFile,\n  TFolder,\n  WorkspaceLeaf\n} from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport type {\n  AbstractFileCommandHandlerConstructorParams,\n  AbstractFileCommandHandlerShouldAddToAbstractFileMenuParams,\n  AbstractFileCommandHandlerShouldAddToAbstractFilesMenuParams\n} from './abstract-file-command-handler.ts';\n\nimport { chain } from '../../async.ts';\nimport {\n  asArrayOfFolders,\n  asFolder,\n  isFolder\n} from '../file-system.ts';\nimport { AbstractFileCommandHandler } from './abstract-file-command-handler.ts';\n\n/**\n * Parameters for {@link FolderCommandHandler.shouldAddToFolderMenu}.\n */\nexport interface FolderCommandHandlerShouldAddToFolderMenuParams {\n  /**\n   * The folder.\n   */\n  readonly folder: TFolder;\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 FolderCommandHandler.shouldAddToFoldersMenu}.\n */\nexport interface FolderCommandHandlerShouldAddToFoldersMenuParams {\n  /**\n   * The folders.\n   */\n  readonly folders: TFolder[];\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 folder-specific commands.\n *\n * Filters abstract files to only accept {@link TFolder} instances.\n * Subclasses override {@link canExecuteFolder} and {@link executeFolder}.\n */\nexport abstract class FolderCommandHandler extends AbstractFileCommandHandler {\n  /**\n   * Creates a new folder command handler.\n   *\n   * @param params - The parameters for the folder command handler.\n   */\n  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Inherits parent's params type.\n  public constructor(params: AbstractFileCommandHandlerConstructorParams) {\n    super(params);\n  }\n\n  /**\n   * Filters to only accept TFolder instances, then delegates to {@link canExecuteFolder}.\n   *\n   * @param abstractFile - The file or folder.\n   * @returns Whether the command can execute.\n   */\n  protected override canExecuteAbstractFile(abstractFile: TAbstractFile): boolean {\n    return isFolder(abstractFile) && this.canExecuteFolder(abstractFile);\n  }\n\n  /**\n   * Filters to only accept TFolder arrays, then delegates to {@link canExecuteFolders}.\n   *\n   * @param abstractFiles - The files or folders.\n   * @returns Whether the command can execute.\n   */\n  protected override canExecuteAbstractFiles(abstractFiles: TAbstractFile[]): boolean {\n    return abstractFiles.every((f) => isFolder(f)) && this.canExecuteFolders(asArrayOfFolders(abstractFiles));\n  }\n\n  /**\n   * Checks whether the command can execute for a single folder.\n   *\n   * @param _folder - The folder.\n   * @returns Whether the command can execute.\n   */\n  protected canExecuteFolder(_folder: TFolder): boolean {\n    return true;\n  }\n\n  /**\n   * Checks whether the command can execute for multiple folders.\n   * Default implementation checks each folder individually.\n   *\n   * @param folders - The folders.\n   * @returns Whether the command can execute.\n   */\n  protected canExecuteFolders(folders: TFolder[]): boolean {\n    return folders.length > 0 && folders.every((f) => this.canExecuteFolder(f));\n  }\n\n  /**\n   * Delegates to {@link executeFolder}.\n   *\n   * @param abstractFile - The file or folder.\n   * @returns `Promisable<void>` that resolves when abstract file had been executed.\n   */\n  protected override executeAbstractFile(abstractFile: TAbstractFile): Promisable<void> {\n    return this.executeFolder(asFolder(abstractFile));\n  }\n\n  /**\n   * Delegates to {@link executeFolders}.\n   *\n   * @param abstractFiles - The files or folders.\n   * @returns `Promisable<void>` that resolves when all abstract files have been executed.\n   */\n  protected override executeAbstractFiles(abstractFiles: TAbstractFile[]): Promisable<void> {\n    return this.executeFolders(asArrayOfFolders(abstractFiles));\n  }\n\n  /**\n   * Executes the command for a single folder.\n   *\n   * @param folder - The folder.\n   */\n  protected abstract executeFolder(folder: TFolder): Promisable<void>;\n\n  /**\n   * Executes the command for multiple folders.\n   * Default implementation executes sequentially.\n   *\n   * @param folders - The folders.\n   * @returns `Promisable<void>` that resolves when all folders have been executed.\n   */\n  protected executeFolders(folders: TFolder[]): Promisable<void> {\n    let promise: null | Promise<void> = null;\n    for (const folder of folders) {\n      promise = chain(promise, () => this.executeFolder(folder));\n    }\n\n    if (promise) {\n      return promise;\n    }\n  }\n\n  /**\n   * Gets the active folder, if any, to use as the target when executing from the command palette.\n   *\n   * @returns The active folder or `null` if none is active.\n   */\n  protected override getActiveFile(): null | TAbstractFile {\n    return this.activeFileProvider.getActiveFile()?.parent ?? null;\n  }\n\n  /**\n   * Filters to only show menu for TFolder instances.\n   *\n   * @param params - The parameters for the single-file menu check.\n   * @returns Whether to add to the file menu.\n   */\n  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Override keeps the base class param type.\n  protected override shouldAddToAbstractFileMenu(params: AbstractFileCommandHandlerShouldAddToAbstractFileMenuParams): boolean {\n    const {\n      abstractFile,\n      leaf,\n      source\n    } = params;\n    if (!isFolder(abstractFile)) {\n      return false;\n    }\n    return this.shouldAddToFolderMenu({\n      folder: abstractFile,\n      leaf,\n      source\n    });\n  }\n\n  /**\n   * Filters to only show menu for TFolder arrays.\n   *\n   * @param params - The parameters for the multi-file menu check.\n   * @returns Whether to add to the files menu.\n   */\n  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Override keeps the base class param type.\n  protected override shouldAddToAbstractFilesMenu(params: AbstractFileCommandHandlerShouldAddToAbstractFilesMenuParams): boolean {\n    const {\n      abstractFiles,\n      leaf,\n      source\n    } = params;\n    if (!abstractFiles.every((f) => isFolder(f))) {\n      return false;\n    }\n    return this.shouldAddToFoldersMenu({\n      folders: asArrayOfFolders(abstractFiles),\n      leaf,\n      source\n    });\n  }\n\n  /**\n   * Checks whether the command should appear in the single-folder context menu.\n   *\n   * @param params - The parameters for the single-folder menu check.\n   * @returns Whether to add to the folder menu.\n   */\n  protected shouldAddToFolderMenu(params: FolderCommandHandlerShouldAddToFolderMenuParams): boolean {\n    const { folder: _folder, leaf: _leaf, source: _source } = params;\n    return false;\n  }\n\n  /**\n   * Checks whether the command should appear in the multi-folder context menu.\n   *\n   * @param params - The parameters for the multi-folder menu check.\n   * @returns Whether to add to the folders menu.\n   */\n  protected shouldAddToFoldersMenu(params: FolderCommandHandlerShouldAddToFoldersMenuParams): boolean {\n    const { folders: _folders, leaf: _leaf, source: _source } = params;\n    return false;\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAmBA,SAAS,aAAa;AACtB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,kCAAkC;AAgDpC,MAAe,6BAA6B,2BAA2B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOrE,YAAY,QAAqD;AACtE,UAAM,MAAM;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQmB,uBAAuB,cAAsC;AAC9E,WAAO,SAAS,YAAY,KAAK,KAAK,iBAAiB,YAAY;AAAA,EACrE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQmB,wBAAwB,eAAyC;AAClF,WAAO,cAAc,MAAM,CAAC,MAAM,SAAS,CAAC,CAAC,KAAK,KAAK,kBAAkB,iBAAiB,aAAa,CAAC;AAAA,EAC1G;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,iBAAiB,SAA2B;AACpD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASU,kBAAkB,SAA6B;AACvD,WAAO,QAAQ,SAAS,KAAK,QAAQ,MAAM,CAAC,MAAM,KAAK,iBAAiB,CAAC,CAAC;AAAA,EAC5E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQmB,oBAAoB,cAA+C;AACpF,WAAO,KAAK,cAAc,SAAS,YAAY,CAAC;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQmB,qBAAqB,eAAkD;AACxF,WAAO,KAAK,eAAe,iBAAiB,aAAa,CAAC;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBU,eAAe,SAAsC;AAC7D,QAAI,UAAgC;AACpC,eAAW,UAAU,SAAS;AAC5B,gBAAU,MAAM,SAAS,MAAM,KAAK,cAAc,MAAM,CAAC;AAAA,IAC3D;AAEA,QAAI,SAAS;AACX,aAAO;AAAA,IACT;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOmB,gBAAsC;AACvD,WAAO,KAAK,mBAAmB,cAAc,GAAG,UAAU;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASmB,4BAA4B,QAA8E;AAC3H,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,IACF,IAAI;AACJ,QAAI,CAAC,SAAS,YAAY,GAAG;AAC3B,aAAO;AAAA,IACT;AACA,WAAO,KAAK,sBAAsB;AAAA,MAChC,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASmB,6BAA6B,QAA+E;AAC7H,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,IACF,IAAI;AACJ,QAAI,CAAC,cAAc,MAAM,CAAC,MAAM,SAAS,CAAC,CAAC,GAAG;AAC5C,aAAO;AAAA,IACT;AACA,WAAO,KAAK,uBAAuB;AAAA,MACjC,SAAS,iBAAiB,aAAa;AAAA,MACvC;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,sBAAsB,QAAkE;AAChG,UAAM,EAAE,QAAQ,SAAS,MAAM,OAAO,QAAQ,QAAQ,IAAI;AAC1D,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,uBAAuB,QAAmE;AAClG,UAAM,EAAE,SAAS,UAAU,MAAM,OAAO,QAAQ,QAAQ,IAAI;AAC5D,WAAO;AAAA,EACT;AACF;",
  "names": []
}


package/dist/lib/esm/obsidian/components/all-windows-event-component.d.mts

@@ -6,6 +6,50 @@
  */
 import type { App } from 'obsidian';
 import { ComponentEx } from './component-ex.mjs';
+/**
+ * Parameters for {@link AllWindowsEventComponent.registerAllDocumentsDomEvent}.
+ *
+ * @typeParam DocumentEventType - The type of the event.
+ */
+export interface AllWindowsEventComponentRegisterAllDocumentsDomEventParams<DocumentEventType extends keyof DocumentEventMap> {
+    /**
+     * The callback to execute.
+     *
+     * @param evt - The event.
+     * @returns The result of the callback.
+     */
+    callback(this: HTMLElement, evt: DocumentEventMap[DocumentEventType]): unknown;
+    /**
+     * The options for the event.
+     */
+    readonly options?: AddEventListenerOptions | boolean;
+    /**
+     * The type of the event.
+     */
+    readonly type: DocumentEventType;
+}
+/**
+ * Parameters for {@link AllWindowsEventComponent.registerAllWindowsDomEvent}.
+ *
+ * @typeParam WindowEventType - The type of the event.
+ */
+export interface AllWindowsEventComponentRegisterAllWindowsDomEventParams<WindowEventType extends keyof WindowEventMap> {
+    /**
+     * The callback to execute.
+     *
+     * @param evt - The event.
+     * @returns The result of the callback.
+     */
+    callback(this: HTMLElement, evt: WindowEventMap[WindowEventType]): unknown;
+    /**
+     * The options for the event.
+     */
+    readonly options?: AddEventListenerOptions | boolean;
+    /**
+     * The type of the event.
+     */
+    readonly type: WindowEventType;
+}
 /**
  * Handles registering DOM events and handlers for all windows (main window and all existing/future popup windows) and their documents.
  */
@@ -21,20 +65,16 @@ export declare class AllWindowsEventComponent extends ComponentEx {
      * Registers a DOM event for all documents (main window document and all existing/future popup window documents).
      *
      * @typeParam DocumentEventType - The type of the event.
-     * @param type - The type of the event.
-     * @param callback - The callback to execute.
-     * @param options - The options for the event.
+     * @param params - The parameters for registering the DOM event.
      */
-    registerAllDocumentsDomEvent<DocumentEventType extends keyof DocumentEventMap>(type: DocumentEventType, callback: (this: HTMLElement, evt: DocumentEventMap[DocumentEventType]) => unknown, options?: AddEventListenerOptions | boolean): void;
+    registerAllDocumentsDomEvent<DocumentEventType extends keyof DocumentEventMap>(params: AllWindowsEventComponentRegisterAllDocumentsDomEventParams<DocumentEventType>): void;
     /**
      * Registers a DOM event for all windows (main window and all existing/future popup windows).
      *
      * @typeParam WindowEventType - The type of the event.
-     * @param type - The type of the event.
-     * @param callback - The callback to execute.
-     * @param options - The options for the event.
+     * @param params - The parameters for registering the DOM event.
      */
-    registerAllWindowsDomEvent<WindowEventType extends keyof WindowEventMap>(type: WindowEventType, callback: (this: HTMLElement, evt: WindowEventMap[WindowEventType]) => unknown, options?: AddEventListenerOptions | boolean): void;
+    registerAllWindowsDomEvent<WindowEventType extends keyof WindowEventMap>(params: AllWindowsEventComponentRegisterAllWindowsDomEventParams<WindowEventType>): void;
     /**
      * Registers a handler for all windows (main window and all existing/future popup windows).
      *

package/dist/lib/esm/obsidian/components/all-windows-event-component.mjs

@@ -39,11 +39,15 @@ class AllWindowsEventComponent extends ComponentEx {
    * Registers a DOM event for all documents (main window document and all existing/future popup window documents).
    *
    * @typeParam DocumentEventType - The type of the event.
-   * @param type - The type of the event.
-   * @param callback - The callback to execute.
-   * @param options - The options for the event.
+   * @param params - The parameters for registering the DOM event.
    */
-  registerAllDocumentsDomEvent(type, callback, options) {
+  registerAllDocumentsDomEvent(params) {
+    const {
+      // eslint-disable-next-line @typescript-eslint/unbound-method -- The callback is a DOM event handler forwarded to registerDomEvent, which binds this to the element.
+      callback,
+      options,
+      type
+    } = params;
     this.ensureLoaded();
     this.registerAllWindowsHandler((win) => {
       this.registerDomEvent(win.document, type, callback, options);
@@ -53,11 +57,15 @@ class AllWindowsEventComponent extends ComponentEx {
    * Registers a DOM event for all windows (main window and all existing/future popup windows).
    *
    * @typeParam WindowEventType - The type of the event.
-   * @param type - The type of the event.
-   * @param callback - The callback to execute.
-   * @param options - The options for the event.
+   * @param params - The parameters for registering the DOM event.
    */
-  registerAllWindowsDomEvent(type, callback, options) {
+  registerAllWindowsDomEvent(params) {
+    const {
+      // eslint-disable-next-line @typescript-eslint/unbound-method -- The callback is a DOM event handler forwarded to registerDomEvent, which binds this to the element.
+      callback,
+      options,
+      type
+    } = params;
     this.ensureLoaded();
     this.registerAllWindowsHandler((win) => {
       this.registerDomEvent(win, type, callback, options);
@@ -90,4 +98,4 @@ class AllWindowsEventComponent extends ComponentEx {
 export {
   AllWindowsEventComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/components/plugin-notice-component.d.mts

@@ -4,6 +4,7 @@
  *
  * Component that manages displaying notices to the user.
  */
+import { Notice } from 'obsidian';
 import { ComponentEx } from './component-ex.mjs';
 /**
  * Options for {@link PluginNoticeComponent.showNotice}.
@@ -45,8 +46,9 @@ export declare class PluginNoticeComponent extends ComponentEx {
      *
      * @param message - The message to display.
      * @param options - The options for displaying the notice.
+     * @returns The notice object.
      */
-    showNotice(message: DocumentFragment | string, options?: PluginNoticeComponentShowNoticeOptions): void;
+    showNotice(message: DocumentFragment | string, options?: PluginNoticeComponentShowNoticeOptions): Notice;
     private getPermanentNotice;
     private getPermanentNotices;
     private setPermanentNotice;

package/dist/lib/esm/obsidian/components/plugin-notice-component.mjs

@@ -60,6 +60,7 @@ class PluginNoticeComponent extends ComponentEx {
    *
    * @param message - The message to display.
    * @param options - The options for displaying the notice.
+   * @returns The notice object.
    */
   showNotice(message, options) {
     this.notice?.hide();
@@ -72,6 +73,7 @@ class PluginNoticeComponent extends ComponentEx {
     } else {
       this.setPermanentNotice(null);
     }
+    return this.notice;
   }
   getPermanentNotice() {
     return this.getPermanentNotices().get(this.pluginName) ?? null;
@@ -98,4 +100,4 @@ function prependPrefix(prefix, message) {
 export {
   PluginNoticeComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/components/plugin-settings-component.d.mts

@@ -35,6 +35,25 @@ export interface PluginSettingsComponentBaseConstructorParams<PluginSettings> {
      */
     readonly pluginSettingsClass: Constructor<PluginSettings, []>;
 }
+/**
+ * Parameters for {@link PluginSettingsComponentBase.onSaveSettings}.
+ *
+ * @typeParam PluginSettings - The type of the plugin settings.
+ */
+export interface PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings extends object> {
+    /**
+     * The save context.
+     */
+    readonly context: unknown;
+    /**
+     * The new settings state.
+     */
+    readonly newState: ReadonlyPluginSettingsState<PluginSettings>;
+    /**
+     * The old settings state.
+     */
+    readonly oldState: ReadonlyPluginSettingsState<PluginSettings>;
+}
 /**
  * A snapshot of plugin settings state, including raw input values, effective (validated) values,
  * and per-property validation messages.
@@ -184,6 +203,8 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
      * @param callback - The callback to call when the event is triggered.
      * @param thisArg - The context passed as `this` to the `callback`.
      * @returns A reference to the event listener.
+     *
+     * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).
      */
     on<EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>, Args extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName] : unknown[]>(name: EventName, callback: (...args: Args) => Promisable<void>, thisArg?: unknown): AsyncEventRef;
     /**
@@ -197,6 +218,8 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
      * @param callback - The callback to call when the event is triggered.
      * @param thisArg - The context passed as `this` to the `callback`.
      * @returns A reference to the event listener.
+     *
+     * @remarks Not refactored to parameter-object pattern, to keep the parity with {@link obsidian#Events#on} (or once, correspondingly).
      */
     once<EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>, Args extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName] : unknown[]>(name: EventName, callback: (...args: Args) => Promisable<void>, thisArg?: unknown): AsyncEventRef;
     /**
@@ -276,11 +299,9 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
     /**
      * Called when settings are saved.
      *
-     * @param _newState - The new settings state.
-     * @param _oldState - The old settings state.
-     * @param _context - The save context.
+     * @param params - The parameters.
      */
-    protected onSaveSettings(_newState: ReadonlyPluginSettingsState<PluginSettings>, _oldState: ReadonlyPluginSettingsState<PluginSettings>, _context: unknown): Promise<void>;
+    protected onSaveSettings(params: PluginSettingsComponentBaseOnSaveSettingsParams<PluginSettings>): Promise<void>;
     /**
      * Called when the plugin settings record is about to be saved to disk.
      *