obsidian-dev-utils 42.2.0 → 42.4.0

package/dist/lib/cjs/obsidian/Commands/FileCommandBase.cjs

@@ -30,17 +30,21 @@ __export(FileCommandBase_exports, {
 });
 module.exports = __toCommonJS(FileCommandBase_exports);
 var import_obsidian = require('obsidian');
-var import_CommandBase = require('./CommandBase.cjs');
-var import_NonEditorCommandBase = require('./NonEditorCommandBase.cjs');
-class FileCommandBase extends import_NonEditorCommandBase.NonEditorCommandBase {
-  menuItemName;
-  menuSection;
+var import_AbstractFileCommandBase = require('./AbstractFileCommandBase.cjs');
+class FileCommandBase extends import_AbstractFileCommandBase.AbstractFileCommandBase {
   /**
-   * Registers the command.
+   * Checks if the command should be added to the abstract file menu.
+   *
+   * @param abstractFile - The abstract file to check.
+   * @param _source - The source of the abstract file.
+   * @param _leaf - The leaf to check.
+   * @returns Whether the command should be added to the abstract file menu.
    */
-  register() {
-    super.register();
-    this.plugin.registerEvent(this.app.workspace.on("file-menu", this.handleFileMenu.bind(this)));
+  shouldAddToAbstractFileMenu(abstractFile, _source, _leaf) {
+    if (!(abstractFile instanceof import_obsidian.TFile)) {
+      return false;
+    }
+    return this.shouldAddToFileMenu(abstractFile, _source, _leaf);
   }
   /**
    * Checks if the command should be added to the file menu.
@@ -53,51 +57,23 @@ class FileCommandBase extends import_NonEditorCommandBase.NonEditorCommandBase {
   shouldAddToFileMenu(_file, _source, _leaf) {
     return false;
   }
-  handleFileMenu(menu, file, source, leaf) {
-    if (!(file instanceof import_obsidian.TFile)) {
-      return;
-    }
-    if (!this.createCommandInvocation().invoke(true)) {
-      return;
-    }
-    if (!this.shouldAddToFileMenu(file, source, leaf)) {
-      return;
-    }
-    menu.addItem((item) => {
-      item.setTitle(this.menuItemName ?? this.name).setIcon(this.icon).onClick(() => this.createCommandInvocation().invoke(false, file));
-      if (this.menuSection) {
-        item.setSection(this.menuSection);
-      }
-    });
-  }
 }
-class FileCommandInvocationBase extends import_CommandBase.CommandInvocationBase {
-  file;
+class FileCommandInvocationBase extends import_AbstractFileCommandBase.AbstractFileCommandInvocationBase {
   /**
-   * Invokes the command.
+   * Gets the file that the command invocation belongs to.
    *
-   * @param checking - Is checking mode only. If `true`, only the check if the command can execute is performed. If `false`, the command is executed.
-   * @param file - The file to invoke the command for.
-   * @returns Whether the command was executed.
+   * @returns The file that the command invocation belongs to.
    */
-  invoke(checking, file) {
-    if (file) {
-      this.file = file;
-    }
-    return super.invoke(checking);
+  get file() {
+    return this.abstractFile;
   }
   /**
-   * Checks if the command can execute.
+   * Sets the file that the command invocation belongs to.
    *
-   * @returns Whether the command can execute.
+   * @param file - The file that the command invocation belongs to.
    */
-  canExecute() {
-    const file = this.file ?? this.app.workspace.getActiveFile();
-    if (!file) {
-      return false;
-    }
-    this.file = file;
-    return true;
+  set file(file) {
+    this.abstractFile = file;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -105,4 +81,4 @@ class FileCommandInvocationBase extends import_CommandBase.CommandInvocationBase
   FileCommandBase,
   FileCommandInvocationBase
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/Commands/FileCommandBase.d.cts

@@ -3,28 +3,30 @@
  *
  * Base classes for file commands.
  */
-import type { Plugin, WorkspaceLeaf } from 'obsidian';
+import type { Plugin, TAbstractFile, WorkspaceLeaf } from 'obsidian';
 import { TFile } from 'obsidian';
-import { CommandInvocationBase } from './CommandBase.cjs';
-import { NonEditorCommandBase } from './NonEditorCommandBase.cjs';
+import { AbstractFileCommandBase, AbstractFileCommandInvocationBase } from './AbstractFileCommandBase.cjs';
 /**
  * Base class for file commands.
  *
  * @typeParam TPlugin - The type of the plugin that the command belongs to.
  */
-export declare abstract class FileCommandBase<TPlugin extends Plugin = Plugin> extends NonEditorCommandBase<TPlugin> {
-    protected readonly menuItemName?: string;
-    protected readonly menuSection?: string;
-    /**
-     * Registers the command.
-     */
-    register(): void;
+export declare abstract class FileCommandBase<TPlugin extends Plugin = Plugin> extends AbstractFileCommandBase<TPlugin> {
     /**
      * Creates a new file command invocation.
      *
      * @returns The command invocation.
      */
     protected abstract createCommandInvocation(): FileCommandInvocationBase<TPlugin>;
+    /**
+     * Checks if the command should be added to the abstract file menu.
+     *
+     * @param abstractFile - The abstract file to check.
+     * @param _source - The source of the abstract file.
+     * @param _leaf - The leaf to check.
+     * @returns Whether the command should be added to the abstract file menu.
+     */
+    protected shouldAddToAbstractFileMenu(abstractFile: TAbstractFile, _source: string, _leaf?: WorkspaceLeaf): boolean;
     /**
      * Checks if the command should be added to the file menu.
      *
@@ -34,27 +36,23 @@ export declare abstract class FileCommandBase<TPlugin extends Plugin = Plugin> e
      * @returns Whether the command should be added to the file menu.
      */
     protected shouldAddToFileMenu(_file: TFile, _source: string, _leaf?: WorkspaceLeaf): boolean;
-    private handleFileMenu;
 }
 /**
  * Base class for file command invocations.
  *
  * @typeParam TPlugin - The type of the plugin that the command belongs to.
  */
-export declare abstract class FileCommandInvocationBase<TPlugin extends Plugin> extends CommandInvocationBase<TPlugin> {
-    protected file: TFile;
+export declare abstract class FileCommandInvocationBase<TPlugin extends Plugin> extends AbstractFileCommandInvocationBase<TPlugin> {
     /**
-     * Invokes the command.
+     * Gets the file that the command invocation belongs to.
      *
-     * @param checking - Is checking mode only. If `true`, only the check if the command can execute is performed. If `false`, the command is executed.
-     * @param file - The file to invoke the command for.
-     * @returns Whether the command was executed.
+     * @returns The file that the command invocation belongs to.
      */
-    invoke(checking: boolean, file?: TFile): boolean;
+    protected get file(): TFile;
     /**
-     * Checks if the command can execute.
+     * Sets the file that the command invocation belongs to.
      *
-     * @returns Whether the command can execute.
+     * @param file - The file that the command invocation belongs to.
      */
-    protected canExecute(): boolean;
+    protected set file(file: TFile);
 }

package/dist/lib/cjs/obsidian/Commands/FolderCommandBase.cjs

@@ -0,0 +1,100 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs(){const globalThisRecord=globalThis;globalThisRecord["__name"]??=name;const originalRequire=require;if(originalRequire&&!originalRequire.__isPatched){require=Object.assign(id=>requirePatched(id),originalRequire,{__isPatched:true})}const newFuncs={__extractDefault(){return extractDefault},process(){const browserProcess={browser:true,cwd(){return"/"},env:{},platform:"android"};return browserProcess}};for(const key of Object.keys(newFuncs)){globalThisRecord[key]??=newFuncs[key]?.()}function name(obj){return obj}__name(name,"name");function extractDefault(module){return module&&module.__esModule&&"default"in module?module.default:module}__name(extractDefault,"extractDefault");function requirePatched(id){const module=originalRequire?.(id);if(module){return extractDefault(module)}if(id==="process"||id==="node:process"){console.error(`Module not found: ${id}. Fake process object is returned instead.`);return globalThis.process}console.error(`Module not found: ${id}. Empty object is returned instead.`);return{}}__name(requirePatched,"requirePatched")})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FolderCommandBase_exports = {};
+__export(FolderCommandBase_exports, {
+  FolderCommandBase: () => FolderCommandBase,
+  FolderCommandInvocationBase: () => FolderCommandInvocationBase
+});
+module.exports = __toCommonJS(FolderCommandBase_exports);
+var import_obsidian = require('obsidian');
+var import_AbstractFileCommandBase = require('./AbstractFileCommandBase.cjs');
+class FolderCommandBase extends import_AbstractFileCommandBase.AbstractFileCommandBase {
+  /**
+   * Checks if the command should be added to the abstract file menu.
+   *
+   * @param abstractFile - The abstract file to check.
+   * @param _source - The source of the abstract file.
+   * @param _leaf - The leaf to check.
+   * @returns Whether the command should be added to the abstract file menu.
+   */
+  shouldAddToAbstractFileMenu(abstractFile, _source, _leaf) {
+    if (!(abstractFile instanceof import_obsidian.TFolder)) {
+      return false;
+    }
+    return this.shouldAddToFolderMenu(abstractFile, _source, _leaf);
+  }
+  /**
+   * Checks if the command should be added to the folder menu.
+   *
+   * @param _folder - The folder to check.
+   * @param _source - The source of the folder.
+   * @param _leaf - The leaf to check.
+   * @returns Whether the command should be added to the folder menu.
+   */
+  shouldAddToFolderMenu(_folder, _source, _leaf) {
+    return false;
+  }
+}
+class FolderCommandInvocationBase extends import_AbstractFileCommandBase.AbstractFileCommandInvocationBase {
+  /**
+   * Gets the folder that the command invocation belongs to.
+   *
+   * @returns The folder that the command invocation belongs to.
+   */
+  get folder() {
+    return this.abstractFile;
+  }
+  /**
+   * Sets the folder that the command invocation belongs to.
+   *
+   * @param folder - The folder that the command invocation belongs to.
+   */
+  set folder(folder) {
+    this.abstractFile = folder;
+  }
+  /**
+   * Checks if the command can execute.
+   *
+   * @returns Whether the command can execute.
+   */
+  canExecute() {
+    if (!super.canExecute()) {
+      return false;
+    }
+    const folder = this.folder ?? this.app.workspace.getActiveFile()?.parent;
+    if (!folder) {
+      return false;
+    }
+    this.folder = folder;
+    return true;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FolderCommandBase,
+  FolderCommandInvocationBase
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL0NvbW1hbmRzL0ZvbGRlckNvbW1hbmRCYXNlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICpcbiAqIEJhc2UgY2xhc3NlcyBmb3IgZm9sZGVyIGNvbW1hbmRzLlxuICovXG5cbmltcG9ydCB0eXBlIHtcbiAgUGx1Z2luLFxuICBUQWJzdHJhY3RGaWxlLFxuICBXb3Jrc3BhY2VMZWFmXG59IGZyb20gJ29ic2lkaWFuJztcblxuaW1wb3J0IHsgVEZvbGRlciB9IGZyb20gJ29ic2lkaWFuJztcblxuaW1wb3J0IHtcbiAgQWJzdHJhY3RGaWxlQ29tbWFuZEJhc2UsXG4gIEFic3RyYWN0RmlsZUNvbW1hbmRJbnZvY2F0aW9uQmFzZVxufSBmcm9tICcuL0Fic3RyYWN0RmlsZUNvbW1hbmRCYXNlLnRzJztcblxuLyoqXG4gKiBCYXNlIGNsYXNzIGZvciBmb2xkZXIgY29tbWFuZHMuXG4gKlxuICogQHR5cGVQYXJhbSBUUGx1Z2luIC0gVGhlIHR5cGUgb2YgdGhlIHBsdWdpbiB0aGF0IHRoZSBjb21tYW5kIGJlbG9uZ3MgdG8uXG4gKi9cbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBGb2xkZXJDb21tYW5kQmFzZTxUUGx1Z2luIGV4dGVuZHMgUGx1Z2luID0gUGx1Z2luPiBleHRlbmRzIEFic3RyYWN0RmlsZUNvbW1hbmRCYXNlPFRQbHVnaW4+IHtcbiAgLyoqXG4gICAqIENyZWF0ZXMgYSBuZXcgZmlsZSBjb21tYW5kIGludm9jYXRpb24uXG4gICAqXG4gICAqIEByZXR1cm5zIFRoZSBjb21tYW5kIGludm9jYXRpb24uXG4gICAqL1xuICBwcm90ZWN0ZWQgYWJzdHJhY3Qgb3ZlcnJpZGUgY3JlYXRlQ29tbWFuZEludm9jYXRpb24oKTogRm9sZGVyQ29tbWFuZEludm9jYXRpb25CYXNlPFRQbHVnaW4+O1xuXG4gIC8qKlxuICAgKiBDaGVja3MgaWYgdGhlIGNvbW1hbmQgc2hvdWxkIGJlIGFkZGVkIHRvIHRoZSBhYnN0cmFjdCBmaWxlIG1lbnUuXG4gICAqXG4gICAqIEBwYXJhbSBhYnN0cmFjdEZpbGUgLSBUaGUgYWJzdHJhY3QgZmlsZSB0byBjaGVjay5cbiAgICogQHBhcmFtIF9zb3VyY2UgLSBUaGUgc291cmNlIG9mIHRoZSBhYnN0cmFjdCBmaWxlLlxuICAgKiBAcGFyYW0gX2xlYWYgLSBUaGUgbGVhZiB0byBjaGVjay5cbiAgICogQHJldHVybnMgV2hldGhlciB0aGUgY29tbWFuZCBzaG91bGQgYmUgYWRkZWQgdG8gdGhlIGFic3RyYWN0IGZpbGUgbWVudS5cbiAgICovXG4gIHByb3RlY3RlZCBvdmVycmlkZSBzaG91bGRBZGRUb0Fic3RyYWN0RmlsZU1lbnUoYWJzdHJhY3RGaWxlOiBUQWJzdHJhY3RGaWxlLCBfc291cmNlOiBzdHJpbmcsIF9sZWFmPzogV29ya3NwYWNlTGVhZik6IGJvb2xlYW4ge1xuICAgIGlmICghKGFic3RyYWN0RmlsZSBpbnN0YW5jZW9mIFRGb2xkZXIpKSB7XG4gICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuICAgIHJldHVybiB0aGlzLnNob3VsZEFkZFRvRm9sZGVyTWVudShhYnN0cmFjdEZpbGUsIF9zb3VyY2UsIF9sZWFmKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBDaGVja3MgaWYgdGhlIGNvbW1hbmQgc2hvdWxkIGJlIGFkZGVkIHRvIHRoZSBmb2xkZXIgbWVudS5cbiAgICpcbiAgICogQHBhcmFtIF9mb2xkZXIgLSBUaGUgZm9sZGVyIHRvIGNoZWNrLlxuICAgKiBAcGFyYW0gX3NvdXJjZSAtIFRoZSBzb3VyY2Ugb2YgdGhlIGZvbGRlci5cbiAgICogQHBhcmFtIF9sZWFmIC0gVGhlIGxlYWYgdG8gY2hlY2suXG4gICAqIEByZXR1cm5zIFdoZXRoZXIgdGhlIGNvbW1hbmQgc2hvdWxkIGJlIGFkZGVkIHRvIHRoZSBmb2xkZXIgbWVudS5cbiAgICovXG4gIHByb3RlY3RlZCBzaG91bGRBZGRUb0ZvbGRlck1lbnUoX2ZvbGRlcjogVEZvbGRlciwgX3NvdXJjZTogc3RyaW5nLCBfbGVhZj86IFdvcmtzcGFjZUxlYWYpOiBib29sZWFuIHtcbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cbn1cblxuLyoqXG4gKiBCYXNlIGNsYXNzIGZvciBmb2xkZXIgY29tbWFuZCBpbnZvY2F0aW9ucy5cbiAqXG4gKiBAdHlwZVBhcmFtIFRQbHVnaW4gLSBUaGUgdHlwZSBvZiB0aGUgcGx1Z2luIHRoYXQgdGhlIGNvbW1hbmQgYmVsb25ncyB0by5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEZvbGRlckNvbW1hbmRJbnZvY2F0aW9uQmFzZTxUUGx1Z2luIGV4dGVuZHMgUGx1Z2luPiBleHRlbmRzIEFic3RyYWN0RmlsZUNvbW1hbmRJbnZvY2F0aW9uQmFzZTxUUGx1Z2luPiB7XG4gIC8qKlxuICAgKiBHZXRzIHRoZSBmb2xkZXIgdGhhdCB0aGUgY29tbWFuZCBpbnZvY2F0aW9uIGJlbG9uZ3MgdG8uXG4gICAqXG4gICAqIEByZXR1cm5zIFRoZSBmb2xkZXIgdGhhdCB0aGUgY29tbWFuZCBpbnZvY2F0aW9uIGJlbG9uZ3MgdG8uXG4gICAqL1xuICBwcm90ZWN0ZWQgZ2V0IGZvbGRlcigpOiBURm9sZGVyIHtcbiAgICByZXR1cm4gdGhpcy5hYnN0cmFjdEZpbGUgYXMgVEZvbGRlcjtcbiAgfVxuXG4gIC8qKlxuICAgKiBTZXRzIHRoZSBmb2xkZXIgdGhhdCB0aGUgY29tbWFuZCBpbnZvY2F0aW9uIGJlbG9uZ3MgdG8uXG4gICAqXG4gICAqIEBwYXJhbSBmb2xkZXIgLSBUaGUgZm9sZGVyIHRoYXQgdGhlIGNvbW1hbmQgaW52b2NhdGlvbiBiZWxvbmdzIHRvLlxuICAgKi9cbiAgcHJvdGVjdGVkIHNldCBmb2xkZXIoZm9sZGVyOiBURm9sZGVyKSB7XG4gICAgdGhpcy5hYnN0cmFjdEZpbGUgPSBmb2xkZXI7XG4gIH1cblxuICAvKipcbiAgICogQ2hlY2tzIGlmIHRoZSBjb21tYW5kIGNhbiBleGVjdXRlLlxuICAgKlxuICAgKiBAcmV0dXJucyBXaGV0aGVyIHRoZSBjb21tYW5kIGNhbiBleGVjdXRlLlxuICAgKi9cbiAgcHJvdGVjdGVkIG92ZXJyaWRlIGNhbkV4ZWN1dGUoKTogYm9vbGVhbiB7XG4gICAgaWYgKCFzdXBlci5jYW5FeGVjdXRlKCkpIHtcbiAgICAgIHJldHVybiBmYWxzZTtcbiAgICB9XG4gICAgY29uc3QgZm9sZGVyID0gKHRoaXMuZm9sZGVyIGFzIFRGb2xkZXIgfCB1bmRlZmluZWQpID8/IHRoaXMuYXBwLndvcmtzcGFjZS5nZXRBY3RpdmVGaWxlKCk/LnBhcmVudDtcbiAgICBpZiAoIWZvbGRlcikge1xuICAgICAgcmV0dXJuIGZhbHNlO1xuICAgIH1cbiAgICB0aGlzLmZvbGRlciA9IGZvbGRlcjtcbiAgICByZXR1cm4gdHJ1ZTtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQVlBLHNCQUF3QjtBQUV4QixxQ0FHTztBQU9BLE1BQWUsMEJBQTJELHVEQUFpQztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQWdCN0YsNEJBQTRCLGNBQTZCLFNBQWlCLE9BQWdDO0FBQzNILFFBQUksRUFBRSx3QkFBd0IsMEJBQVU7QUFDdEMsYUFBTztBQUFBLElBQ1Q7QUFDQSxXQUFPLEtBQUssc0JBQXNCLGNBQWMsU0FBUyxLQUFLO0FBQUEsRUFDaEU7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFVVSxzQkFBc0IsU0FBa0IsU0FBaUIsT0FBZ0M7QUFDakcsV0FBTztBQUFBLEVBQ1Q7QUFDRjtBQU9PLE1BQWUsb0NBQTRELGlFQUEyQztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQU0zSCxJQUFjLFNBQWtCO0FBQzlCLFdBQU8sS0FBSztBQUFBLEVBQ2Q7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPQSxJQUFjLE9BQU8sUUFBaUI7QUFDcEMsU0FBSyxlQUFlO0FBQUEsRUFDdEI7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFPbUIsYUFBc0I7QUFDdkMsUUFBSSxDQUFDLE1BQU0sV0FBVyxHQUFHO0FBQ3ZCLGFBQU87QUFBQSxJQUNUO0FBQ0EsVUFBTSxTQUFVLEtBQUssVUFBa0MsS0FBSyxJQUFJLFVBQVUsY0FBYyxHQUFHO0FBQzNGLFFBQUksQ0FBQyxRQUFRO0FBQ1gsYUFBTztBQUFBLElBQ1Q7QUFDQSxTQUFLLFNBQVM7QUFDZCxXQUFPO0FBQUEsRUFDVDtBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/cjs/obsidian/Commands/FolderCommandBase.d.cts

@@ -0,0 +1,64 @@
+/**
+ * @packageDocumentation
+ *
+ * Base classes for folder commands.
+ */
+import type { Plugin, TAbstractFile, WorkspaceLeaf } from 'obsidian';
+import { TFolder } from 'obsidian';
+import { AbstractFileCommandBase, AbstractFileCommandInvocationBase } from './AbstractFileCommandBase.cjs';
+/**
+ * Base class for folder commands.
+ *
+ * @typeParam TPlugin - The type of the plugin that the command belongs to.
+ */
+export declare abstract class FolderCommandBase<TPlugin extends Plugin = Plugin> extends AbstractFileCommandBase<TPlugin> {
+    /**
+     * Creates a new file command invocation.
+     *
+     * @returns The command invocation.
+     */
+    protected abstract createCommandInvocation(): FolderCommandInvocationBase<TPlugin>;
+    /**
+     * Checks if the command should be added to the abstract file menu.
+     *
+     * @param abstractFile - The abstract file to check.
+     * @param _source - The source of the abstract file.
+     * @param _leaf - The leaf to check.
+     * @returns Whether the command should be added to the abstract file menu.
+     */
+    protected shouldAddToAbstractFileMenu(abstractFile: TAbstractFile, _source: string, _leaf?: WorkspaceLeaf): boolean;
+    /**
+     * Checks if the command should be added to the folder menu.
+     *
+     * @param _folder - The folder to check.
+     * @param _source - The source of the folder.
+     * @param _leaf - The leaf to check.
+     * @returns Whether the command should be added to the folder menu.
+     */
+    protected shouldAddToFolderMenu(_folder: TFolder, _source: string, _leaf?: WorkspaceLeaf): boolean;
+}
+/**
+ * Base class for folder command invocations.
+ *
+ * @typeParam TPlugin - The type of the plugin that the command belongs to.
+ */
+export declare abstract class FolderCommandInvocationBase<TPlugin extends Plugin> extends AbstractFileCommandInvocationBase<TPlugin> {
+    /**
+     * Gets the folder that the command invocation belongs to.
+     *
+     * @returns The folder that the command invocation belongs to.
+     */
+    protected get folder(): TFolder;
+    /**
+     * Sets the folder that the command invocation belongs to.
+     *
+     * @param folder - The folder that the command invocation belongs to.
+     */
+    protected set folder(folder: TFolder);
+    /**
+     * Checks if the command can execute.
+     *
+     * @returns Whether the command can execute.
+     */
+    protected canExecute(): boolean;
+}

package/dist/lib/cjs/obsidian/Commands/index.cjs

@@ -35,21 +35,27 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var Commands_exports = {};
 __export(Commands_exports, {
+  AbstractFileCommandBase: () => AbstractFileCommandBase,
   CommandBase: () => CommandBase,
   EditorCommandBase: () => EditorCommandBase,
   FileCommandBase: () => FileCommandBase,
+  FolderCommandBase: () => FolderCommandBase,
   NonEditorCommandBase: () => NonEditorCommandBase
 });
 module.exports = __toCommonJS(Commands_exports);
+var AbstractFileCommandBase = __toESM(__extractDefault(require('./AbstractFileCommandBase.cjs')), 1);
 var CommandBase = __toESM(__extractDefault(require('./CommandBase.cjs')), 1);
 var EditorCommandBase = __toESM(__extractDefault(require('./EditorCommandBase.cjs')), 1);
 var FileCommandBase = __toESM(__extractDefault(require('./FileCommandBase.cjs')), 1);
+var FolderCommandBase = __toESM(__extractDefault(require('./FolderCommandBase.cjs')), 1);
 var NonEditorCommandBase = __toESM(__extractDefault(require('./NonEditorCommandBase.cjs')), 1);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AbstractFileCommandBase,
   CommandBase,
   EditorCommandBase,
   FileCommandBase,
+  FolderCommandBase,
   NonEditorCommandBase
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL0NvbW1hbmRzL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgQ29tbWFuZEJhc2UgZnJvbSAnLi9Db21tYW5kQmFzZS50cyc7XG5leHBvcnQgKiBhcyBFZGl0b3JDb21tYW5kQmFzZSBmcm9tICcuL0VkaXRvckNvbW1hbmRCYXNlLnRzJztcbmV4cG9ydCAqIGFzIEZpbGVDb21tYW5kQmFzZSBmcm9tICcuL0ZpbGVDb21tYW5kQmFzZS50cyc7XG5leHBvcnQgKiBhcyBOb25FZGl0b3JDb21tYW5kQmFzZSBmcm9tICcuL05vbkVkaXRvckNvbW1hbmRCYXNlLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUVBLGtCQUE2QjtBQUM3Qix3QkFBbUM7QUFDbkMsc0JBQWlDO0FBQ2pDLDJCQUFzQzsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL0NvbW1hbmRzL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgQWJzdHJhY3RGaWxlQ29tbWFuZEJhc2UgZnJvbSAnLi9BYnN0cmFjdEZpbGVDb21tYW5kQmFzZS50cyc7XG5leHBvcnQgKiBhcyBDb21tYW5kQmFzZSBmcm9tICcuL0NvbW1hbmRCYXNlLnRzJztcbmV4cG9ydCAqIGFzIEVkaXRvckNvbW1hbmRCYXNlIGZyb20gJy4vRWRpdG9yQ29tbWFuZEJhc2UudHMnO1xuZXhwb3J0ICogYXMgRmlsZUNvbW1hbmRCYXNlIGZyb20gJy4vRmlsZUNvbW1hbmRCYXNlLnRzJztcbmV4cG9ydCAqIGFzIEZvbGRlckNvbW1hbmRCYXNlIGZyb20gJy4vRm9sZGVyQ29tbWFuZEJhc2UudHMnO1xuZXhwb3J0ICogYXMgTm9uRWRpdG9yQ29tbWFuZEJhc2UgZnJvbSAnLi9Ob25FZGl0b3JDb21tYW5kQmFzZS50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBRUEsOEJBQXlDO0FBQ3pDLGtCQUE2QjtBQUM3Qix3QkFBbUM7QUFDbkMsc0JBQWlDO0FBQ2pDLHdCQUFtQztBQUNuQywyQkFBc0M7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/cjs/obsidian/Commands/index.d.cts

@@ -1,4 +1,6 @@
+export * as AbstractFileCommandBase from './AbstractFileCommandBase.cjs';
 export * as CommandBase from './CommandBase.cjs';
 export * as EditorCommandBase from './EditorCommandBase.cjs';
 export * as FileCommandBase from './FileCommandBase.cjs';
+export * as FolderCommandBase from './FolderCommandBase.cjs';
 export * as NonEditorCommandBase from './NonEditorCommandBase.cjs';

package/dist/lib/cjs/obsidian/Components/SettingComponents/TypedTextComponent.cjs

@@ -44,6 +44,9 @@ class TypedTextComponent extends import_obsidian.ValueComponent {
   get validatorEl() {
     return this.inputEl;
   }
+  /**
+   * The inner text component.
+   */
   textComponent;
   /**
    * Creates a new typed text component.
@@ -118,4 +121,4 @@ class TypedTextComponent extends import_obsidian.ValueComponent {
 0 && (module.exports = {
   TypedTextComponent
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/Components/SettingComponents/TypedTextComponent.d.cts

@@ -25,6 +25,9 @@ export declare abstract class TypedTextComponent<T> extends ValueComponent<T> im
      * @returns The validator element.
      */
     get validatorEl(): ValidatorElement;
+    /**
+     * The inner text component.
+     */
     protected readonly textComponent: TextComponent;
     /**
      * Creates a new typed text component.

package/dist/lib/cjs/obsidian/Plugin/PluginBase.cjs

@@ -40,6 +40,9 @@ var import_translationsMap = require('../i18n/locales/translationsMap.cjs');
 var import_Workspace = require('../Workspace.cjs');
 var import_PluginContext = require('./PluginContext.cjs');
 class PluginBase extends import_obsidian.Plugin {
+  /**
+   * The events of the plugin.
+   */
   events = new import_AsyncEvents.AsyncEvents();
   /**
    * Gets the AbortSignal used for aborting long-running operations.
@@ -347,4 +350,4 @@ ${message}`);
 0 && (module.exports = {
   PluginBase
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Base class for Obsidian plugins providing utility methods for settings management, error handling, and notifications.\n *\n * This class simplifies the process of managing plugin settings, displaying notifications, and handling errors.\n * Subclasses should implement methods to create default settings and settings tabs, and complete plugin-specific\n * loading tasks.\n */\n\nimport type { ReadonlyDeep } from 'type-fest';\n\nimport {\n  Notice,\n  Plugin as ObsidianPlugin\n} from 'obsidian';\n\nimport type { TranslationsMap } from '../i18n/i18n.ts';\nimport type {\n  ExtractPluginSettings,\n  ExtractPluginSettingsManager,\n  ExtractPluginSettingsTab,\n  ExtractReadonlyPluginSettingsWrapper,\n  PluginTypesBase\n} from './PluginTypesBase.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely,\n  invokeAsyncSafelyAfterDelay\n} from '../../Async.ts';\nimport { AsyncEvents } from '../../AsyncEvents.ts';\nimport { getDebugger } from '../../Debug.ts';\nimport {\n  registerAsyncErrorEventHandler,\n  SilentError\n} from '../../Error.ts';\nimport { noopAsync } from '../../Function.ts';\nimport { registerAsyncEvent } from '../Components/AsyncEventsComponent.ts';\nimport {\n  initI18N,\n  t\n} from '../i18n/i18n.ts';\nimport { defaultTranslationsMap } from '../i18n/locales/translationsMap.ts';\nimport { getAllDomWindows } from '../Workspace.ts';\nimport {\n  initDebugController,\n  initPluginContext\n} from './PluginContext.ts';\n\ntype LifecycleEventName = 'layoutReady' | 'load' | 'unload';\n\n/**\n * Base class for creating Obsidian plugins with built-in support for settings management, error handling, and notifications.\n *\n * @typeParam PluginTypes - Plugin-specific types.\n */\nexport abstract class PluginBase<PluginTypes extends PluginTypesBase> extends ObsidianPlugin {\n  public readonly events = new AsyncEvents();\n\n  /**\n   * Gets the AbortSignal used for aborting long-running operations.\n   *\n   * @returns The abort signal.\n   */\n  public get abortSignal(): AbortSignal {\n    return this._abortSignal;\n  }\n\n  /**\n   * Gets the readonly plugin settings.\n   *\n   * @returns The readonly plugin settings.\n   */\n  public get settings(): ReadonlyDeep<ExtractPluginSettings<PluginTypes>> {\n    return this.settingsManager.settingsWrapper.safeSettings as ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n  }\n\n  /**\n   * Gets the plugin settings manager.\n   *\n   * @returns The plugin settings manager.\n   */\n  public get settingsManager(): ExtractPluginSettingsManager<PluginTypes> {\n    if (!this._settingsManager) {\n      throw new Error('Settings manager not defined');\n    }\n\n    return this._settingsManager;\n  }\n\n  /**\n   * Gets the plugin settings tab.\n   *\n   * @returns The plugin settings tab.\n   */\n  public get settingsTab(): ExtractPluginSettingsTab<PluginTypes> {\n    if (!this._settingsTab) {\n      throw new Error('Settings tab not defined');\n    }\n\n    return this._settingsTab;\n  }\n\n  private _abortSignal!: AbortSignal;\n  private _settingsManager: ExtractPluginSettingsManager<PluginTypes> | null = null;\n  private _settingsTab: ExtractPluginSettingsTab<PluginTypes> | null = null;\n  private readonly lifecycleEventNames = new Set<LifecycleEventName>();\n  private notice?: Notice;\n\n  /**\n   * Logs a message to the console.\n   *\n   * Use instead of `console.debug()`.\n   *\n   * Those messages are not shown by default, but they can be shown by enabling `your-plugin-id` debugger namespace.\n   *\n   * @see {@link https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md} for more information.\n   *\n   * @param message - The message to log.\n   * @param args - The arguments to log.\n   */\n  public consoleDebug(message: string, ...args: unknown[]): void {\n    // Skip the `consoleDebug()` call itself\n    const FRAMES_TO_SKIP = 1;\n    const pluginDebugger = getDebugger(this.manifest.id, FRAMES_TO_SKIP);\n    pluginDebugger(message, ...args);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * Usually, you don't need to override this method. Consider using {@link onLoadSettings} instead.\n   *\n   * If you still need to override this method, make sure to call `await super.onExternalSettingsChange()` first.\n   */\n  public override async onExternalSettingsChange(): Promise<void> {\n    await super.onExternalSettingsChange?.();\n    await this._settingsManager?.loadFromFile(false);\n  }\n\n  /**\n   * Called when the plugin is loaded\n   *\n   * Usually, you don't need to override this method. Consider using {@link onloadImpl} instead.\n   *\n   * If you still need to override this method, make sure to call `await super.onload()` first.\n   */\n  public override async onload(): Promise<void> {\n    await super.onload();\n    await this.onloadImpl();\n    invokeAsyncSafelyAfterDelay(this.afterLoad.bind(this));\n  }\n\n  /**\n   * Called when the plugin is unloaded.\n   *\n   * Usually, you don't need to override this method. Consider using {@link onunloadImpl} instead.\n   *\n   * If you still need to override this method, make sure to call `super.onunload()` first.\n   */\n  public override onunload(): void {\n    super.onunload();\n    invokeAsyncSafely(async () => {\n      try {\n        await this.onunloadImpl();\n      } finally {\n        await this.triggerLifecycleEvent('unload');\n      }\n    });\n  }\n\n  /**\n   * Registers a DOM window handler.\n   *\n   * @param domWindowHandler - The DOM window handler.\n   */\n  public registerDomWindowHandler(domWindowHandler: (win: Window) => void): void {\n    const mainWindow = window;\n    domWindowHandler(mainWindow);\n\n    this.app.workspace.onLayoutReady(() => {\n      for (const win of getAllDomWindows(this.app)) {\n        if (win === mainWindow) {\n          continue;\n        }\n\n        domWindowHandler(win);\n      }\n\n      this.registerEvent(this.app.workspace.on('window-open', (workspaceWindow) => {\n        domWindowHandler(workspaceWindow.win);\n      }));\n    });\n  }\n\n  /**\n   * Registers a callback to be executed when a lifecycle event is triggered.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback to execute.\n   */\n  public registerForLifecycleEvent(name: LifecycleEventName, callback: () => Promise<void>): void {\n    invokeAsyncSafely(async () => {\n      await this.waitForLifecycleEvent(name);\n      await callback();\n    });\n  }\n\n  /**\n   * Registers a DOM event for all popup window documents.\n   *\n   * @typeParam DocumentEventType - The type of the event.\n   * @param type - The type of the event.\n   * @param callback - The callback to execute.\n   * @param options - The options for the event.\n   */\n  public registerPopupDocumentDomEvent<DocumentEventType extends keyof DocumentEventMap>(\n    type: DocumentEventType,\n    callback: (this: HTMLElement, evt: DocumentEventMap[DocumentEventType]) => unknown,\n    options?: AddEventListenerOptions | boolean\n  ): void {\n    this.registerDomWindowHandler((win) => {\n      this.registerDomEvent(win.document, type, callback, options);\n    });\n  }\n\n  /**\n   * Registers a DOM event for all popup windows.\n   *\n   * @typeParam WindowEventType - The type of the event.\n   * @param type - The type of the event.\n   * @param callback - The callback to execute.\n   * @param options - The options for the event.\n   */\n  public registerPopupWindowDomEvent<WindowEventType extends keyof WindowEventMap>(\n    type: WindowEventType,\n    callback: (this: HTMLElement, evt: WindowEventMap[WindowEventType]) => unknown,\n    options?: AddEventListenerOptions | boolean\n  ): void {\n    this.registerDomWindowHandler((win) => {\n      this.registerDomEvent(win, type, callback, options);\n    });\n  }\n\n  /**\n   * Waits for a lifecycle event to be triggered.\n   *\n   * If you `await` this method during lifecycle event, it might cause a deadlock.\n   *\n   * Consider wrapping this call with {@link invokeAsyncSafely}.\n   *\n   * @param name - The name of the event.\n   * @returns A {@link Promise} that resolves when the event is triggered.\n   */\n  public async waitForLifecycleEvent(name: LifecycleEventName): Promise<void> {\n    if (this.lifecycleEventNames.has(name)) {\n      return;\n    }\n\n    await new Promise<void>((resolve) => {\n      this.events.once(name, () => {\n        resolve();\n      });\n    });\n  }\n\n  /**\n   * Creates the plugin settings manager. This method must be implemented by subclasses.\n   *\n   * @returns The plugin settings manager.\n   */\n  protected createSettingsManager(): ExtractPluginSettingsManager<PluginTypes> | null {\n    return null;\n  }\n\n  /**\n   * Creates a plugin settings tab.\n   *\n   * @returns The settings tab or null if not applicable.\n   */\n  protected createSettingsTab(): ExtractPluginSettingsTab<PluginTypes> | null {\n    return null;\n  }\n\n  /**\n   * Creates a translations map.\n   *\n   * @returns The translations map.\n   */\n  protected createTranslationsMap(): TranslationsMap<PluginTypes> {\n    return defaultTranslationsMap;\n  }\n\n  /**\n   * Called when an async error occurs.\n   *\n   * @param _asyncError - The async error.\n   */\n  protected handleAsyncError(_asyncError: unknown): void {\n    this.showNotice(t(($) => $.obsidianDevUtils.notices.unhandledError));\n  }\n\n  /**\n   * Called when the layout is ready.\n   */\n  protected async onLayoutReady(): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Executed when the plugin is loaded.\n   *\n   * If this method fails, the plugin will be automatically unloaded.\n   *\n   * @remarks It is important to call `super.onloadImpl()` in overridden method.\n   */\n  protected async onloadImpl(): Promise<void> {\n    initPluginContext(this.app, this.manifest.id);\n    this.registerDomWindowHandler((win) => {\n      initDebugController(win);\n    });\n    await initI18N<PluginTypes>(this.createTranslationsMap());\n\n    this.register(registerAsyncErrorEventHandler(this.handleAsyncError.bind(this)));\n\n    this._settingsManager = this.createSettingsManager();\n    if (this._settingsManager) {\n      registerAsyncEvent(this, this._settingsManager.on('loadSettings', this.onLoadSettings.bind(this)));\n      registerAsyncEvent(this, this._settingsManager.on('saveSettings', this.onSaveSettings.bind(this)));\n    }\n\n    await this._settingsManager?.loadFromFile(true);\n    this._settingsTab = this.createSettingsTab();\n    if (this._settingsTab) {\n      this.addSettingTab(this._settingsTab);\n    }\n\n    const abortController = new AbortController();\n    this._abortSignal = abortController.signal;\n    this.register(() => {\n      abortController.abort(new SilentError(`Plugin ${this.manifest.id} had been unloaded`));\n    });\n  }\n\n  /**\n   * Called when the plugin settings are loaded or reloaded.\n   *\n   * @param _loadedSettings - The loaded settings wrapper.\n   * @param _isInitialLoad - Whether the settings are being loaded for the first time.\n   */\n  protected async onLoadSettings(_loadedSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>, _isInitialLoad: boolean): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings are saved.\n   *\n   * @param _newSettings - The new settings.\n   * @param _oldSettings - The old settings.\n   * @param _context - The context.\n   */\n  protected async onSaveSettings(\n    _newSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>,\n    _oldSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>,\n    _context: unknown\n  ): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin is unloaded.\n   */\n  protected async onunloadImpl(): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Displays a notice message to the user.\n   *\n   * @param message - The message to display.\n   */\n  protected showNotice(message: string): void {\n    if (this.notice) {\n      this.notice.hide();\n    }\n\n    this.notice = new Notice(`${this.manifest.name}\\n${message}`);\n  }\n\n  private async afterLoad(): Promise<void> {\n    if (this._abortSignal.aborted) {\n      return;\n    }\n    await this.triggerLifecycleEvent('load');\n    this.app.workspace.onLayoutReady(convertAsyncToSync(this.onLayoutReadyBase.bind(this)));\n  }\n\n  private async onLayoutReadyBase(): Promise<void> {\n    try {\n      await this.onLayoutReady();\n    } finally {\n      await this.triggerLifecycleEvent('layoutReady');\n    }\n  }\n\n  private async triggerLifecycleEvent(name: LifecycleEventName): Promise<void> {\n    this.lifecycleEventNames.add(name);\n    await this.events.triggerAsync(name);\n  }\n}\n"],
  "mappings": "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",
  "names": ["ObsidianPlugin"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Base class for Obsidian plugins providing utility methods for settings management, error handling, and notifications.\n *\n * This class simplifies the process of managing plugin settings, displaying notifications, and handling errors.\n * Subclasses should implement methods to create default settings and settings tabs, and complete plugin-specific\n * loading tasks.\n */\n\nimport type { ReadonlyDeep } from 'type-fest';\n\nimport {\n  Notice,\n  Plugin as ObsidianPlugin\n} from 'obsidian';\n\nimport type { TranslationsMap } from '../i18n/i18n.ts';\nimport type {\n  ExtractPluginSettings,\n  ExtractPluginSettingsManager,\n  ExtractPluginSettingsTab,\n  ExtractReadonlyPluginSettingsWrapper,\n  PluginTypesBase\n} from './PluginTypesBase.ts';\n\nimport {\n  convertAsyncToSync,\n  invokeAsyncSafely,\n  invokeAsyncSafelyAfterDelay\n} from '../../Async.ts';\nimport { AsyncEvents } from '../../AsyncEvents.ts';\nimport { getDebugger } from '../../Debug.ts';\nimport {\n  registerAsyncErrorEventHandler,\n  SilentError\n} from '../../Error.ts';\nimport { noopAsync } from '../../Function.ts';\nimport { registerAsyncEvent } from '../Components/AsyncEventsComponent.ts';\nimport {\n  initI18N,\n  t\n} from '../i18n/i18n.ts';\nimport { defaultTranslationsMap } from '../i18n/locales/translationsMap.ts';\nimport { getAllDomWindows } from '../Workspace.ts';\nimport {\n  initDebugController,\n  initPluginContext\n} from './PluginContext.ts';\n\ntype LifecycleEventName = 'layoutReady' | 'load' | 'unload';\n\n/**\n * Base class for creating Obsidian plugins with built-in support for settings management, error handling, and notifications.\n *\n * @typeParam PluginTypes - Plugin-specific types.\n */\nexport abstract class PluginBase<PluginTypes extends PluginTypesBase> extends ObsidianPlugin {\n  /**\n   * The events of the plugin.\n   */\n  public readonly events = new AsyncEvents();\n\n  /**\n   * Gets the AbortSignal used for aborting long-running operations.\n   *\n   * @returns The abort signal.\n   */\n  public get abortSignal(): AbortSignal {\n    return this._abortSignal;\n  }\n\n  /**\n   * Gets the readonly plugin settings.\n   *\n   * @returns The readonly plugin settings.\n   */\n  public get settings(): ReadonlyDeep<ExtractPluginSettings<PluginTypes>> {\n    return this.settingsManager.settingsWrapper.safeSettings as ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n  }\n\n  /**\n   * Gets the plugin settings manager.\n   *\n   * @returns The plugin settings manager.\n   */\n  public get settingsManager(): ExtractPluginSettingsManager<PluginTypes> {\n    if (!this._settingsManager) {\n      throw new Error('Settings manager not defined');\n    }\n\n    return this._settingsManager;\n  }\n\n  /**\n   * Gets the plugin settings tab.\n   *\n   * @returns The plugin settings tab.\n   */\n  public get settingsTab(): ExtractPluginSettingsTab<PluginTypes> {\n    if (!this._settingsTab) {\n      throw new Error('Settings tab not defined');\n    }\n\n    return this._settingsTab;\n  }\n\n  private _abortSignal!: AbortSignal;\n  private _settingsManager: ExtractPluginSettingsManager<PluginTypes> | null = null;\n  private _settingsTab: ExtractPluginSettingsTab<PluginTypes> | null = null;\n  private readonly lifecycleEventNames = new Set<LifecycleEventName>();\n  private notice?: Notice;\n\n  /**\n   * Logs a message to the console.\n   *\n   * Use instead of `console.debug()`.\n   *\n   * Those messages are not shown by default, but they can be shown by enabling `your-plugin-id` debugger namespace.\n   *\n   * @see {@link https://github.com/mnaoumov/obsidian-dev-utils/blob/main/docs/debugging.md} for more information.\n   *\n   * @param message - The message to log.\n   * @param args - The arguments to log.\n   */\n  public consoleDebug(message: string, ...args: unknown[]): void {\n    // Skip the `consoleDebug()` call itself\n    const FRAMES_TO_SKIP = 1;\n    const pluginDebugger = getDebugger(this.manifest.id, FRAMES_TO_SKIP);\n    pluginDebugger(message, ...args);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * Usually, you don't need to override this method. Consider using {@link onLoadSettings} instead.\n   *\n   * If you still need to override this method, make sure to call `await super.onExternalSettingsChange()` first.\n   */\n  public override async onExternalSettingsChange(): Promise<void> {\n    await super.onExternalSettingsChange?.();\n    await this._settingsManager?.loadFromFile(false);\n  }\n\n  /**\n   * Called when the plugin is loaded\n   *\n   * Usually, you don't need to override this method. Consider using {@link onloadImpl} instead.\n   *\n   * If you still need to override this method, make sure to call `await super.onload()` first.\n   */\n  public override async onload(): Promise<void> {\n    await super.onload();\n    await this.onloadImpl();\n    invokeAsyncSafelyAfterDelay(this.afterLoad.bind(this));\n  }\n\n  /**\n   * Called when the plugin is unloaded.\n   *\n   * Usually, you don't need to override this method. Consider using {@link onunloadImpl} instead.\n   *\n   * If you still need to override this method, make sure to call `super.onunload()` first.\n   */\n  public override onunload(): void {\n    super.onunload();\n    invokeAsyncSafely(async () => {\n      try {\n        await this.onunloadImpl();\n      } finally {\n        await this.triggerLifecycleEvent('unload');\n      }\n    });\n  }\n\n  /**\n   * Registers a DOM window handler.\n   *\n   * @param domWindowHandler - The DOM window handler.\n   */\n  public registerDomWindowHandler(domWindowHandler: (win: Window) => void): void {\n    const mainWindow = window;\n    domWindowHandler(mainWindow);\n\n    this.app.workspace.onLayoutReady(() => {\n      for (const win of getAllDomWindows(this.app)) {\n        if (win === mainWindow) {\n          continue;\n        }\n\n        domWindowHandler(win);\n      }\n\n      this.registerEvent(this.app.workspace.on('window-open', (workspaceWindow) => {\n        domWindowHandler(workspaceWindow.win);\n      }));\n    });\n  }\n\n  /**\n   * Registers a callback to be executed when a lifecycle event is triggered.\n   *\n   * @param name - The name of the event.\n   * @param callback - The callback to execute.\n   */\n  public registerForLifecycleEvent(name: LifecycleEventName, callback: () => Promise<void>): void {\n    invokeAsyncSafely(async () => {\n      await this.waitForLifecycleEvent(name);\n      await callback();\n    });\n  }\n\n  /**\n   * Registers a DOM event for all popup window documents.\n   *\n   * @typeParam DocumentEventType - The type of the event.\n   * @param type - The type of the event.\n   * @param callback - The callback to execute.\n   * @param options - The options for the event.\n   */\n  public registerPopupDocumentDomEvent<DocumentEventType extends keyof DocumentEventMap>(\n    type: DocumentEventType,\n    callback: (this: HTMLElement, evt: DocumentEventMap[DocumentEventType]) => unknown,\n    options?: AddEventListenerOptions | boolean\n  ): void {\n    this.registerDomWindowHandler((win) => {\n      this.registerDomEvent(win.document, type, callback, options);\n    });\n  }\n\n  /**\n   * Registers a DOM event for all popup windows.\n   *\n   * @typeParam WindowEventType - The type of the event.\n   * @param type - The type of the event.\n   * @param callback - The callback to execute.\n   * @param options - The options for the event.\n   */\n  public registerPopupWindowDomEvent<WindowEventType extends keyof WindowEventMap>(\n    type: WindowEventType,\n    callback: (this: HTMLElement, evt: WindowEventMap[WindowEventType]) => unknown,\n    options?: AddEventListenerOptions | boolean\n  ): void {\n    this.registerDomWindowHandler((win) => {\n      this.registerDomEvent(win, type, callback, options);\n    });\n  }\n\n  /**\n   * Waits for a lifecycle event to be triggered.\n   *\n   * If you `await` this method during lifecycle event, it might cause a deadlock.\n   *\n   * Consider wrapping this call with {@link invokeAsyncSafely}.\n   *\n   * @param name - The name of the event.\n   * @returns A {@link Promise} that resolves when the event is triggered.\n   */\n  public async waitForLifecycleEvent(name: LifecycleEventName): Promise<void> {\n    if (this.lifecycleEventNames.has(name)) {\n      return;\n    }\n\n    await new Promise<void>((resolve) => {\n      this.events.once(name, () => {\n        resolve();\n      });\n    });\n  }\n\n  /**\n   * Creates the plugin settings manager. This method must be implemented by subclasses.\n   *\n   * @returns The plugin settings manager.\n   */\n  protected createSettingsManager(): ExtractPluginSettingsManager<PluginTypes> | null {\n    return null;\n  }\n\n  /**\n   * Creates a plugin settings tab.\n   *\n   * @returns The settings tab or null if not applicable.\n   */\n  protected createSettingsTab(): ExtractPluginSettingsTab<PluginTypes> | null {\n    return null;\n  }\n\n  /**\n   * Creates a translations map.\n   *\n   * @returns The translations map.\n   */\n  protected createTranslationsMap(): TranslationsMap<PluginTypes> {\n    return defaultTranslationsMap;\n  }\n\n  /**\n   * Called when an async error occurs.\n   *\n   * @param _asyncError - The async error.\n   */\n  protected handleAsyncError(_asyncError: unknown): void {\n    this.showNotice(t(($) => $.obsidianDevUtils.notices.unhandledError));\n  }\n\n  /**\n   * Called when the layout is ready.\n   */\n  protected async onLayoutReady(): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Executed when the plugin is loaded.\n   *\n   * If this method fails, the plugin will be automatically unloaded.\n   *\n   * @remarks It is important to call `super.onloadImpl()` in overridden method.\n   */\n  protected async onloadImpl(): Promise<void> {\n    initPluginContext(this.app, this.manifest.id);\n    this.registerDomWindowHandler((win) => {\n      initDebugController(win);\n    });\n    await initI18N<PluginTypes>(this.createTranslationsMap());\n\n    this.register(registerAsyncErrorEventHandler(this.handleAsyncError.bind(this)));\n\n    this._settingsManager = this.createSettingsManager();\n    if (this._settingsManager) {\n      registerAsyncEvent(this, this._settingsManager.on('loadSettings', this.onLoadSettings.bind(this)));\n      registerAsyncEvent(this, this._settingsManager.on('saveSettings', this.onSaveSettings.bind(this)));\n    }\n\n    await this._settingsManager?.loadFromFile(true);\n    this._settingsTab = this.createSettingsTab();\n    if (this._settingsTab) {\n      this.addSettingTab(this._settingsTab);\n    }\n\n    const abortController = new AbortController();\n    this._abortSignal = abortController.signal;\n    this.register(() => {\n      abortController.abort(new SilentError(`Plugin ${this.manifest.id} had been unloaded`));\n    });\n  }\n\n  /**\n   * Called when the plugin settings are loaded or reloaded.\n   *\n   * @param _loadedSettings - The loaded settings wrapper.\n   * @param _isInitialLoad - Whether the settings are being loaded for the first time.\n   */\n  protected async onLoadSettings(_loadedSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>, _isInitialLoad: boolean): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin settings are saved.\n   *\n   * @param _newSettings - The new settings.\n   * @param _oldSettings - The old settings.\n   * @param _context - The context.\n   */\n  protected async onSaveSettings(\n    _newSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>,\n    _oldSettings: ExtractReadonlyPluginSettingsWrapper<PluginTypes>,\n    _context: unknown\n  ): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Called when the plugin is unloaded.\n   */\n  protected async onunloadImpl(): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Displays a notice message to the user.\n   *\n   * @param message - The message to display.\n   */\n  protected showNotice(message: string): void {\n    if (this.notice) {\n      this.notice.hide();\n    }\n\n    this.notice = new Notice(`${this.manifest.name}\\n${message}`);\n  }\n\n  private async afterLoad(): Promise<void> {\n    if (this._abortSignal.aborted) {\n      return;\n    }\n    await this.triggerLifecycleEvent('load');\n    this.app.workspace.onLayoutReady(convertAsyncToSync(this.onLayoutReadyBase.bind(this)));\n  }\n\n  private async onLayoutReadyBase(): Promise<void> {\n    try {\n      await this.onLayoutReady();\n    } finally {\n      await this.triggerLifecycleEvent('layoutReady');\n    }\n  }\n\n  private async triggerLifecycleEvent(name: LifecycleEventName): Promise<void> {\n    this.lifecycleEventNames.add(name);\n    await this.events.triggerAsync(name);\n  }\n}\n"],
  "mappings": "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",
  "names": ["ObsidianPlugin"]
}


package/dist/lib/cjs/obsidian/Plugin/PluginBase.d.cts

@@ -19,6 +19,9 @@ type LifecycleEventName = 'layoutReady' | 'load' | 'unload';
  * @typeParam PluginTypes - Plugin-specific types.
  */
 export declare abstract class PluginBase<PluginTypes extends PluginTypesBase> extends ObsidianPlugin {
+    /**
+     * The events of the plugin.
+     */
     readonly events: AsyncEvents;
     /**
      * Gets the AbortSignal used for aborting long-running operations.