@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

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

@@ -0,0 +1,149 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Command handler for folder-specific commands (TFolder only, not TFile).
+ */
+import type { TAbstractFile, TFolder, WorkspaceLeaf } from 'obsidian';
+import type { Promisable } from 'type-fest';
+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.
+ *
+ * Filters abstract files to only accept {@link TFolder} instances.
+ * Subclasses override {@link canExecuteFolder} and {@link executeFolder}.
+ */
+export declare abstract class FolderCommandHandler extends AbstractFileCommandHandler {
+    /**
+     * Creates a new folder command handler.
+     *
+     * @param params - The parameters for the folder command handler.
+     */
+    constructor(params: AbstractFileCommandHandlerConstructorParams);
+    /**
+     * Filters to only accept TFolder instances, then delegates to {@link canExecuteFolder}.
+     *
+     * @param abstractFile - The file or folder.
+     * @returns Whether the command can execute.
+     */
+    protected canExecuteAbstractFile(abstractFile: TAbstractFile): boolean;
+    /**
+     * Filters to only accept TFolder arrays, then delegates to {@link canExecuteFolders}.
+     *
+     * @param abstractFiles - The files or folders.
+     * @returns Whether the command can execute.
+     */
+    protected canExecuteAbstractFiles(abstractFiles: TAbstractFile[]): boolean;
+    /**
+     * Checks whether the command can execute for a single folder.
+     *
+     * @param _folder - The folder.
+     * @returns Whether the command can execute.
+     */
+    protected canExecuteFolder(_folder: TFolder): boolean;
+    /**
+     * Checks whether the command can execute for multiple folders.
+     * Default implementation checks each folder individually.
+     *
+     * @param folders - The folders.
+     * @returns Whether the command can execute.
+     */
+    protected canExecuteFolders(folders: TFolder[]): boolean;
+    /**
+     * Delegates to {@link executeFolder}.
+     *
+     * @param abstractFile - The file or folder.
+     * @returns `Promisable<void>` that resolves when abstract file had been executed.
+     */
+    protected executeAbstractFile(abstractFile: TAbstractFile): Promisable<void>;
+    /**
+     * Delegates to {@link executeFolders}.
+     *
+     * @param abstractFiles - The files or folders.
+     * @returns `Promisable<void>` that resolves when all abstract files have been executed.
+     */
+    protected executeAbstractFiles(abstractFiles: TAbstractFile[]): Promisable<void>;
+    /**
+     * Executes the command for a single folder.
+     *
+     * @param folder - The folder.
+     */
+    protected abstract executeFolder(folder: TFolder): Promisable<void>;
+    /**
+     * Executes the command for multiple folders.
+     * Default implementation executes sequentially.
+     *
+     * @param folders - The folders.
+     * @returns `Promisable<void>` that resolves when all folders have been executed.
+     */
+    protected executeFolders(folders: TFolder[]): Promisable<void>;
+    /**
+     * Gets the active folder, if any, to use as the target when executing from the command palette.
+     *
+     * @returns The active folder or `null` if none is active.
+     */
+    protected getActiveFile(): null | TAbstractFile;
+    /**
+     * Filters to only show menu for TFolder instances.
+     *
+     * @param params - The parameters for the single-file menu check.
+     * @returns Whether to add to the file menu.
+     */
+    protected shouldAddToAbstractFileMenu(params: AbstractFileCommandHandlerShouldAddToAbstractFileMenuParams): boolean;
+    /**
+     * Filters to only show menu for TFolder arrays.
+     *
+     * @param params - The parameters for the multi-file menu check.
+     * @returns Whether to add to the files menu.
+     */
+    protected shouldAddToAbstractFilesMenu(params: AbstractFileCommandHandlerShouldAddToAbstractFilesMenuParams): boolean;
+    /**
+     * Checks whether the command should appear in the single-folder context menu.
+     *
+     * @param params - The parameters for the single-folder menu check.
+     * @returns Whether to add to the folder menu.
+     */
+    protected shouldAddToFolderMenu(params: FolderCommandHandlerShouldAddToFolderMenuParams): boolean;
+    /**
+     * Checks whether the command should appear in the multi-folder context menu.
+     *
+     * @param params - The parameters for the multi-folder menu check.
+     * @returns Whether to add to the folders menu.
+     */
+    protected shouldAddToFoldersMenu(params: FolderCommandHandlerShouldAddToFoldersMenuParams): boolean;
+}

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

@@ -0,0 +1,208 @@
+/*
+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 } from "@mnaoumov/typescript-lib/async";
+import {
+  asArrayOfFolders,
+  asFolder,
+  isFolder
+} from "../file-system.mjs";
+import { AbstractFileCommandHandler } from "./abstract-file-command-handler.mjs";
+class FolderCommandHandler extends AbstractFileCommandHandler {
+  /**
+   * Creates a new folder command handler.
+   *
+   * @param params - The parameters for the folder command handler.
+   */
+  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Inherits parent's params type.
+  constructor(params) {
+    super(params);
+  }
+  /**
+   * Filters to only accept TFolder instances, then delegates to {@link canExecuteFolder}.
+   *
+   * @param abstractFile - The file or folder.
+   * @returns Whether the command can execute.
+   */
+  canExecuteAbstractFile(abstractFile) {
+    return isFolder(abstractFile) && this.canExecuteFolder(abstractFile);
+  }
+  /**
+   * Filters to only accept TFolder arrays, then delegates to {@link canExecuteFolders}.
+   *
+   * @param abstractFiles - The files or folders.
+   * @returns Whether the command can execute.
+   */
+  canExecuteAbstractFiles(abstractFiles) {
+    return abstractFiles.every((f) => isFolder(f)) && this.canExecuteFolders(asArrayOfFolders(abstractFiles));
+  }
+  /**
+   * Checks whether the command can execute for a single folder.
+   *
+   * @param _folder - The folder.
+   * @returns Whether the command can execute.
+   */
+  canExecuteFolder(_folder) {
+    return true;
+  }
+  /**
+   * Checks whether the command can execute for multiple folders.
+   * Default implementation checks each folder individually.
+   *
+   * @param folders - The folders.
+   * @returns Whether the command can execute.
+   */
+  canExecuteFolders(folders) {
+    return folders.length > 0 && folders.every((f) => this.canExecuteFolder(f));
+  }
+  /**
+   * Delegates to {@link executeFolder}.
+   *
+   * @param abstractFile - The file or folder.
+   * @returns `Promisable<void>` that resolves when abstract file had been executed.
+   */
+  executeAbstractFile(abstractFile) {
+    return this.executeFolder(asFolder(abstractFile));
+  }
+  /**
+   * Delegates to {@link executeFolders}.
+   *
+   * @param abstractFiles - The files or folders.
+   * @returns `Promisable<void>` that resolves when all abstract files have been executed.
+   */
+  executeAbstractFiles(abstractFiles) {
+    return this.executeFolders(asArrayOfFolders(abstractFiles));
+  }
+  /**
+   * Executes the command for multiple folders.
+   * Default implementation executes sequentially.
+   *
+   * @param folders - The folders.
+   * @returns `Promisable<void>` that resolves when all folders have been executed.
+   */
+  executeFolders(folders) {
+    let promise = null;
+    for (const folder of folders) {
+      promise = chain(promise, () => this.executeFolder(folder));
+    }
+    if (promise) {
+      return promise;
+    }
+  }
+  /**
+   * Gets the active folder, if any, to use as the target when executing from the command palette.
+   *
+   * @returns The active folder or `null` if none is active.
+   */
+  getActiveFile() {
+    return this.activeFileProvider.getActiveFile()?.parent ?? null;
+  }
+  /**
+   * Filters to only show menu for TFolder instances.
+   *
+   * @param params - The parameters for the single-file menu check.
+   * @returns Whether to add to the file menu.
+   */
+  // 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;
+    return isFolder(abstractFile) && this.shouldAddToFolderMenu({
+      folder: abstractFile,
+      leaf,
+      source
+    });
+  }
+  /**
+   * Filters to only show menu for TFolder arrays.
+   *
+   * @param params - The parameters for the multi-file menu check.
+   * @returns Whether to add to the files menu.
+   */
+  // 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;
+    return abstractFiles.every((f) => isFolder(f)) && this.shouldAddToFoldersMenu({
+      folders: asArrayOfFolders(abstractFiles),
+      leaf,
+      source
+    });
+  }
+  /**
+   * Checks whether the command should appear in the single-folder context menu.
+   *
+   * @param params - The parameters for the single-folder menu check.
+   * @returns Whether to add to the folder menu.
+   */
+  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 params - The parameters for the multi-folder menu check.
+   * @returns Whether to add to the folders menu.
+   */
+  shouldAddToFoldersMenu(params) {
+    const { folders: _folders, leaf: _leaf, source: _source } = params;
+    return false;
+  }
+}
+export {
+  FolderCommandHandler
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/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 { chain } from '@mnaoumov/typescript-lib/async';\n\nimport type {\n  AbstractFileCommandHandlerConstructorParams,\n  AbstractFileCommandHandlerShouldAddToAbstractFileMenuParams,\n  AbstractFileCommandHandlerShouldAddToAbstractFilesMenuParams\n} from './abstract-file-command-handler.ts';\n\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    return isFolder(abstractFile) && 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    return abstractFiles.every((f) => isFolder(f)) && 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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaA,SAAS,aAAa;AAQtB;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,WAAO,SAAS,YAAY,KAAK,KAAK,sBAAsB;AAAA,MAC1D,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,WAAO,cAAc,MAAM,CAAC,MAAM,SAAS,CAAC,CAAC,KAAK,KAAK,uBAAuB;AAAA,MAC5E,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/command-handlers/global-command-handler.d.mts

@@ -0,0 +1,40 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Command handler for global (non-editor, non-file) commands.
+ */
+import type { Command } from 'obsidian';
+import type { Promisable } from 'type-fest';
+import type { CommandHandlerConstructorParams } from './command-handler.mjs';
+import { CommandHandler } from './command-handler.mjs';
+/**
+ * Command handler for global commands invoked from the command palette.
+ *
+ * Subclasses override {@link canExecute} and {@link execute} to provide behavior.
+ */
+export declare abstract class GlobalCommandHandler extends CommandHandler {
+    /**
+     * Creates a new global command handler.
+     *
+     * @param params - The parameters for the command handler.
+     */
+    constructor(params: CommandHandlerConstructorParams);
+    /**
+     * Builds a plain Obsidian {@link Command} object with a `checkCallback`.
+     *
+     * @returns A new {@link Command} object.
+     */
+    buildCommand(): Command;
+    /**
+     * Checks whether the command can currently execute.
+     *
+     * @returns Whether the command can execute.
+     */
+    protected canExecute(): boolean;
+    /**
+     * Executes the command.
+     */
+    protected abstract execute(): Promisable<void>;
+    private checkCallback;
+}

package/dist/lib/esm/command-handlers/global-command-handler.mjs

@@ -0,0 +1,96 @@
+/*
+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 { invokeAsyncSafely } from "@mnaoumov/typescript-lib/async";
+import { CommandHandler } from "./command-handler.mjs";
+class GlobalCommandHandler extends CommandHandler {
+  /**
+   * Creates a new global command handler.
+   *
+   * @param params - The parameters for the command handler.
+   */
+  // eslint-disable-next-line obsidian-dev-utils/params-options-name-match -- Inherits parent's params type.
+  constructor(params) {
+    super(params);
+  }
+  /**
+   * Builds a plain Obsidian {@link Command} object with a `checkCallback`.
+   *
+   * @returns A new {@link Command} object.
+   */
+  buildCommand() {
+    return {
+      checkCallback: (checking) => this.checkCallback(checking),
+      icon: this.icon,
+      id: this.id,
+      name: this.name
+    };
+  }
+  /**
+   * Checks whether the command can currently execute.
+   *
+   * @returns Whether the command can execute.
+   */
+  canExecute() {
+    return true;
+  }
+  checkCallback(isChecking) {
+    if (!this.canExecute()) {
+      return false;
+    }
+    if (!isChecking) {
+      invokeAsyncSafely(() => this.execute());
+    }
+    return true;
+  }
+}
+export {
+  GlobalCommandHandler
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/command-handlers/index.d.mts

@@ -0,0 +1,11 @@
+/// <reference path="../library.d.mts" />
+export * as 'abstract-file-command-handler' from './abstract-file-command-handler.mjs';
+export * as 'command-handler-component' from './command-handler-component.mjs';
+export * as 'command-handler' from './command-handler.mjs';
+export * as 'editor-command-handler' from './editor-command-handler.mjs';
+export * as 'file-command-handler' from './file-command-handler.mjs';
+export * as 'folder-command-handler' from './folder-command-handler.mjs';
+export * as 'global-command-handler' from './global-command-handler.mjs';
+export * as 'open-demo-vault-command-handler' from './open-demo-vault-command-handler.mjs';
+export * as 'open-settings-command-handler' from './open-settings-command-handler.mjs';
+export * as 'unlock-active-note-command-handler' from './unlock-active-note-command-handler.mjs';

package/dist/lib/esm/command-handlers/index.mjs

@@ -0,0 +1,72 @@
+/*
+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 * as abstract_file_command_handler from "./abstract-file-command-handler.mjs";
+import * as command_handler_component from "./command-handler-component.mjs";
+import * as command_handler from "./command-handler.mjs";
+import * as editor_command_handler from "./editor-command-handler.mjs";
+import * as file_command_handler from "./file-command-handler.mjs";
+import * as folder_command_handler from "./folder-command-handler.mjs";
+import * as global_command_handler from "./global-command-handler.mjs";
+import * as open_demo_vault_command_handler from "./open-demo-vault-command-handler.mjs";
+import * as open_settings_command_handler from "./open-settings-command-handler.mjs";
+import * as unlock_active_note_command_handler from "./unlock-active-note-command-handler.mjs";
+export {
+  abstract_file_command_handler as "abstract-file-command-handler",
+  command_handler as "command-handler",
+  command_handler_component as "command-handler-component",
+  editor_command_handler as "editor-command-handler",
+  file_command_handler as "file-command-handler",
+  folder_command_handler as "folder-command-handler",
+  global_command_handler as "global-command-handler",
+  open_demo_vault_command_handler as "open-demo-vault-command-handler",
+  open_settings_command_handler as "open-settings-command-handler",
+  unlock_active_note_command_handler as "unlock-active-note-command-handler"
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2NvbW1hbmQtaGFuZGxlcnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnYWJzdHJhY3QtZmlsZS1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vYWJzdHJhY3QtZmlsZS1jb21tYW5kLWhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgJ2NvbW1hbmQtaGFuZGxlci1jb21wb25lbnQnIGZyb20gJy4vY29tbWFuZC1oYW5kbGVyLWNvbXBvbmVudC50cyc7XG5leHBvcnQgKiBhcyAnY29tbWFuZC1oYW5kbGVyJyBmcm9tICcuL2NvbW1hbmQtaGFuZGxlci50cyc7XG5leHBvcnQgKiBhcyAnZWRpdG9yLWNvbW1hbmQtaGFuZGxlcicgZnJvbSAnLi9lZGl0b3ItY29tbWFuZC1oYW5kbGVyLnRzJztcbmV4cG9ydCAqIGFzICdmaWxlLWNvbW1hbmQtaGFuZGxlcicgZnJvbSAnLi9maWxlLWNvbW1hbmQtaGFuZGxlci50cyc7XG5leHBvcnQgKiBhcyAnZm9sZGVyLWNvbW1hbmQtaGFuZGxlcicgZnJvbSAnLi9mb2xkZXItY29tbWFuZC1oYW5kbGVyLnRzJztcbmV4cG9ydCAqIGFzICdnbG9iYWwtY29tbWFuZC1oYW5kbGVyJyBmcm9tICcuL2dsb2JhbC1jb21tYW5kLWhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgJ29wZW4tZGVtby12YXVsdC1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vb3Blbi1kZW1vLXZhdWx0LWNvbW1hbmQtaGFuZGxlci50cyc7XG5leHBvcnQgKiBhcyAnb3Blbi1zZXR0aW5ncy1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vb3Blbi1zZXR0aW5ncy1jb21tYW5kLWhhbmRsZXIudHMnO1xuZXhwb3J0ICogYXMgJ3VubG9jay1hY3RpdmUtbm90ZS1jb21tYW5kLWhhbmRsZXInIGZyb20gJy4vdW5sb2NrLWFjdGl2ZS1ub3RlLWNvbW1hbmQtaGFuZGxlci50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBRUEsWUFBWUEsbUNBQXFDO0FBQ2pELFlBQVlDLCtCQUFpQztBQUM3QyxZQUFZQyxxQkFBdUI7QUFDbkMsWUFBWUMsNEJBQThCO0FBQzFDLFlBQVlDLDBCQUE0QjtBQUN4QyxZQUFZQyw0QkFBOEI7QUFDMUMsWUFBWUMsNEJBQThCO0FBQzFDLFlBQVlDLHFDQUF1QztBQUNuRCxZQUFZQyxtQ0FBcUM7QUFDakQsWUFBWUMsd0NBQTBDOyIsCiAgIm5hbWVzIjogWyJhYnN0cmFjdC1maWxlLWNvbW1hbmQtaGFuZGxlciIsICJjb21tYW5kLWhhbmRsZXItY29tcG9uZW50IiwgImNvbW1hbmQtaGFuZGxlciIsICJlZGl0b3ItY29tbWFuZC1oYW5kbGVyIiwgImZpbGUtY29tbWFuZC1oYW5kbGVyIiwgImZvbGRlci1jb21tYW5kLWhhbmRsZXIiLCAiZ2xvYmFsLWNvbW1hbmQtaGFuZGxlciIsICJvcGVuLWRlbW8tdmF1bHQtY29tbWFuZC1oYW5kbGVyIiwgIm9wZW4tc2V0dGluZ3MtY29tbWFuZC1oYW5kbGVyIiwgInVubG9jay1hY3RpdmUtbm90ZS1jb21tYW5kLWhhbmRsZXIiXQp9Cg==