obsidian-dev-utils 22.1.1-beta.9 → 23.0.1

package/dist/lib/esm/obsidian/Plugin/PluginBase.d.mts

@@ -1,21 +1,25 @@
 /**
- * @packageDocumentation PluginBase
+ * @packageDocumentation
+ *
  * Base class for Obsidian plugins providing utility methods for settings management, error handling, and notifications.
  *
  * This class simplifies the process of managing plugin settings, displaying notifications, and handling errors.
  * Subclasses should implement methods to create default settings and settings tabs, and complete plugin-specific
  * loading tasks.
  */
-import type { PluginSettingTab } from 'obsidian';
-import type { Promisable, ReadonlyDeep } from 'type-fest';
-import { Plugin } from 'obsidian';
-import { PluginSettingsManagerBase } from './PluginSettingsManagerBase.mjs';
+import type { ReadonlyDeep } from 'type-fest';
+import { Plugin as ObsidianPlugin } from 'obsidian';
+import type { AsyncEventRef } from '../../AsyncEvents.mjs';
+import type { ExtractPluginSettings, ExtractPluginSettingsManager, ExtractPluginSettingsTab, PluginTypesBase } from './PluginTypesBase.mjs';
+import { AsyncEvents } from '../../AsyncEvents.mjs';
+type LifecycleEventName = 'layoutReady' | 'load' | 'unload';
 /**
  * Base class for creating Obsidian plugins with built-in support for settings management, error handling, and notifications.
  *
  * @typeParam PluginSettings - The type representing the plugin settings object.
  */
-export declare abstract class PluginBase<PluginSettings extends object = object> extends Plugin {
+export declare abstract class PluginBase<PluginTypes extends PluginTypesBase> extends ObsidianPlugin {
+    readonly events: AsyncEvents;
     /**
      * Gets the AbortSignal used for aborting long-running operations.
      *
@@ -27,10 +31,13 @@ export declare abstract class PluginBase<PluginSettings extends object = object>
      *
      * @returns The readonly plugin settings.
      */
-    get settings(): ReadonlyDeep<PluginSettings>;
-    get settingsManager(): PluginSettingsManagerBase<PluginSettings>;
+    get settings(): ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;
+    get settingsManager(): ExtractPluginSettingsManager<PluginTypes>;
+    get settingsTab(): ExtractPluginSettingsTab<PluginTypes>;
     private _abortSignal;
     private _settingsManager;
+    private _settingsTab;
+    private lifecycleEventNames;
     private notice?;
     /**
      * Logs a message to the console.
@@ -53,44 +60,68 @@ export declare abstract class PluginBase<PluginSettings extends object = object>
      * Called when the plugin is loaded
      */
     onload(): Promise<void>;
+    /**
+     * Called when the plugin settings are loaded or reloaded.
+     *
+     * @param _settings - The settings.
+     */
+    onLoadSettings(_settings: ExtractPluginSettings<PluginTypes>): Promise<void>;
     /**
      * Called when the plugin settings are saved.
      *
      * @param _newSettings - The new settings.
      * @param _oldSettings - The old settings.
-     * @returns A promise or void indicating the completion of the save process.
      */
-    onSaveSettings(_newSettings: Partial<PluginSettings>, _oldSettings: Partial<PluginSettings>): Promise<void>;
+    onSaveSettings(_newSettings: ExtractPluginSettings<PluginTypes>, _oldSettings: ExtractPluginSettings<PluginTypes>): Promise<void>;
+    onunload(): void;
+    /**
+     * Registers an async event.
+     * Unregisters the event when the plugin is unloaded.
+     *
+     * @param eventRef - The event reference.
+     */
+    registerAsyncEvent(eventRef: AsyncEventRef): void;
     /**
-     * Creates a plugin settings tab. This method must be implemented by subclasses.
+     * Waits for a lifecycle event to be triggered.
+     *
+     * If you `await` this method during lifecycle event, it might cause a deadlock.
+     *
+     * Consider wrapping this call with {@link invokeAsyncSafely}.
+     *
+     * @param name - The name of the event.
+     * @returns A {@link Promise} that resolves when the event is triggered.
+     */
+    waitForLifecycleEvent(name: LifecycleEventName): Promise<void>;
+    /**
+     * Creates a plugin settings tab.
      *
      * @returns The settings tab or null if not applicable.
      */
-    protected abstract createPluginSettingsTab(): null | PluginSettingTab;
+    protected createPluginSettingsTab(): ExtractPluginSettingsTab<PluginTypes> | null;
     /**
      * Creates the plugin settings manager. This method must be implemented by subclasses.
      *
      * @returns The plugin settings manager.
      */
-    protected abstract createSettingsManager(): PluginSettingsManagerBase<PluginSettings>;
+    protected createSettingsManager(): ExtractPluginSettingsManager<PluginTypes> | null;
     /**
      * Called when the layout is ready. This method can be overridden by subclasses to perform actions once
      * the layout is ready.
-     *
-     * @returns A promise or void indicating the completion of the layout setup.
      */
-    protected onLayoutReady(): Promisable<void>;
+    protected onLayoutReady(): Promise<void>;
+    protected onloadImpl(): Promise<void>;
     /**
-     * Called when the plugin loading is complete. This method must be implemented by subclasses to perform
-     * any additional setup required after loading is complete.
-     *
-     * @returns A promise or void indicating the completion of the load process.
+     * Called when the plugin is unloaded.
      */
-    protected onloadComplete(): Promisable<void>;
+    protected onunloadImpl(): Promise<void>;
     /**
      * Displays a notice message to the user.
      *
      * @param message - The message to display.
      */
     protected showNotice(message: string): void;
+    private afterLoad;
+    private onLayoutReadyBase;
+    private triggerLifecycleEvent;
 }
+export {};

package/dist/lib/esm/obsidian/Plugin/PluginBase.mjs

@@ -7,17 +7,20 @@ if you want to view the source, please visit the github repository of this plugi
 
 import {
   Notice,
-  Plugin
+  Plugin as ObsidianPlugin
 } from "obsidian";
+import {
+  convertAsyncToSync,
+  invokeAsyncSafely,
+  invokeAsyncSafelyAfterDelay
+} from "../../Async.mjs";
+import { AsyncEvents } from "../../AsyncEvents.mjs";
 import { getDebugger } from "../../Debug.mjs";
 import { registerAsyncErrorEventHandler } from "../../Error.mjs";
-import {
-  noop,
-  noopAsync
-} from "../../Function.mjs";
+import { noopAsync } from "../../Function.mjs";
 import { initPluginContext } from "./PluginContext.mjs";
-import { PluginSettingsManagerBase } from "./PluginSettingsManagerBase.mjs";
-class PluginBase extends Plugin {
+class PluginBase extends ObsidianPlugin {
+  events = new AsyncEvents();
   /**
    * Gets the AbortSignal used for aborting long-running operations.
    *
@@ -35,10 +38,21 @@ class PluginBase extends Plugin {
     return this.settingsManager.safeSettings;
   }
   get settingsManager() {
+    if (!this._settingsManager) {
+      throw new Error("Settings manager not defined");
+    }
     return this._settingsManager;
   }
+  get settingsTab() {
+    if (!this._settingsTab) {
+      throw new Error("Settings tab not defined");
+    }
+    return this._settingsTab;
+  }
   _abortSignal;
-  _settingsManager;
+  _settingsManager = null;
+  _settingsTab = null;
+  lifecycleEventNames = /* @__PURE__ */ new Set();
   notice;
   /**
    * Logs a message to the console.
@@ -61,12 +75,99 @@ class PluginBase extends Plugin {
    * Called when the external settings change.
    */
   async onExternalSettingsChange() {
-    await this.settingsManager.loadFromFile();
+    await super.onExternalSettingsChange?.();
+    await this._settingsManager?.loadFromFile();
   }
   /**
    * Called when the plugin is loaded
    */
   async onload() {
+    await super.onload();
+    await this.onloadImpl();
+    invokeAsyncSafelyAfterDelay(this.afterLoad.bind(this));
+  }
+  /**
+   * Called when the plugin settings are loaded or reloaded.
+   *
+   * @param _settings - The settings.
+   */
+  async onLoadSettings(_settings) {
+    await noopAsync();
+  }
+  /**
+   * Called when the plugin settings are saved.
+   *
+   * @param _newSettings - The new settings.
+   * @param _oldSettings - The old settings.
+   */
+  async onSaveSettings(_newSettings, _oldSettings) {
+    await noopAsync();
+  }
+  onunload() {
+    super.onunload();
+    invokeAsyncSafely(async () => {
+      try {
+        await this.onunloadImpl();
+      } finally {
+        await this.triggerLifecycleEvent("unload");
+      }
+    });
+  }
+  /**
+   * Registers an async event.
+   * Unregisters the event when the plugin is unloaded.
+   *
+   * @param eventRef - The event reference.
+   */
+  registerAsyncEvent(eventRef) {
+    this.register(() => {
+      eventRef.asyncEvents.offref(eventRef);
+    });
+  }
+  /**
+   * Waits for a lifecycle event to be triggered.
+   *
+   * If you `await` this method during lifecycle event, it might cause a deadlock.
+   *
+   * Consider wrapping this call with {@link invokeAsyncSafely}.
+   *
+   * @param name - The name of the event.
+   * @returns A {@link Promise} that resolves when the event is triggered.
+   */
+  async waitForLifecycleEvent(name) {
+    if (this.lifecycleEventNames.has(name)) {
+      return;
+    }
+    await new Promise((resolve) => {
+      this.events.once(name, () => {
+        resolve();
+      });
+    });
+  }
+  /**
+   * Creates a plugin settings tab.
+   *
+   * @returns The settings tab or null if not applicable.
+   */
+  createPluginSettingsTab() {
+    return null;
+  }
+  /**
+   * Creates the plugin settings manager. This method must be implemented by subclasses.
+   *
+   * @returns The plugin settings manager.
+   */
+  createSettingsManager() {
+    return null;
+  }
+  /**
+   * Called when the layout is ready. This method can be overridden by subclasses to perform actions once
+   * the layout is ready.
+   */
+  async onLayoutReady() {
+    await noopAsync();
+  }
+  async onloadImpl() {
     initPluginContext(this.app, this.manifest.id);
     this.register(registerAsyncErrorEventHandler(() => {
       this.showNotice("An unhandled error occurred. Please check the console for more information.");
@@ -82,39 +183,13 @@ class PluginBase extends Plugin {
     this.register(() => {
       abortController.abort();
     });
-    await this.onloadComplete();
-    setTimeout(() => {
-      this.app.workspace.onLayoutReady(this.onLayoutReady.bind(this));
-    }, 0);
   }
   /**
-   * Called when the plugin settings are saved.
-   *
-   * @param _newSettings - The new settings.
-   * @param _oldSettings - The old settings.
-   * @returns A promise or void indicating the completion of the save process.
+   * Called when the plugin is unloaded.
    */
-  async onSaveSettings(_newSettings, _oldSettings) {
+  async onunloadImpl() {
     await noopAsync();
   }
-  /**
-   * Called when the layout is ready. This method can be overridden by subclasses to perform actions once
-   * the layout is ready.
-   *
-   * @returns A promise or void indicating the completion of the layout setup.
-   */
-  onLayoutReady() {
-    noop();
-  }
-  /**
-   * Called when the plugin loading is complete. This method must be implemented by subclasses to perform
-   * any additional setup required after loading is complete.
-   *
-   * @returns A promise or void indicating the completion of the load process.
-   */
-  onloadComplete() {
-    noop();
-  }
   /**
    * Displays a notice message to the user.
    *
@@ -127,8 +202,23 @@ class PluginBase extends Plugin {
     this.notice = new Notice(`${this.manifest.name}
 ${message}`);
   }
+  async afterLoad() {
+    await this.triggerLifecycleEvent("load");
+    this.app.workspace.onLayoutReady(convertAsyncToSync(this.onLayoutReadyBase.bind(this)));
+  }
+  async onLayoutReadyBase() {
+    try {
+      await this.onLayoutReady();
+    } finally {
+      await this.triggerLifecycleEvent("layoutReady");
+    }
+  }
+  async triggerLifecycleEvent(name) {
+    this.lifecycleEventNames.add(name);
+    await this.events.triggerAsync(name);
+  }
 }
 export {
   PluginBase
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/Plugin/PluginBase.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation PluginBase\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 { PluginSettingTab } from 'obsidian';\nimport type {\n  Promisable,\n  ReadonlyDeep\n} from 'type-fest';\n\nimport {\n  Notice,\n  Plugin\n} from 'obsidian';\n\nimport { getDebugger } from '../../Debug.ts';\nimport { registerAsyncErrorEventHandler } from '../../Error.ts';\nimport {\n  noop,\n  noopAsync\n} from '../../Function.ts';\nimport { initPluginContext } from './PluginContext.ts';\nimport { PluginSettingsManagerBase } from './PluginSettingsManagerBase.ts';\n\n/**\n * Base class for creating Obsidian plugins with built-in support for settings management, error handling, and notifications.\n *\n * @typeParam PluginSettings - The type representing the plugin settings object.\n */\nexport abstract class PluginBase<PluginSettings extends object = object> extends Plugin {\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<PluginSettings> {\n    return this.settingsManager.safeSettings;\n  }\n\n  public get settingsManager(): PluginSettingsManagerBase<PluginSettings> {\n    return this._settingsManager;\n  }\n\n  private _abortSignal!: AbortSignal;\n\n  private _settingsManager!: PluginSettingsManagerBase<PluginSettings>;\n\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/?tab=readme-ov-file#debugging} 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 _debugger = getDebugger(this.manifest.id, FRAMES_TO_SKIP);\n    _debugger(message, ...args);\n  }\n\n  /**\n   * Called when the external settings change.\n   */\n  public override async onExternalSettingsChange(): Promise<void> {\n    await this.settingsManager.loadFromFile();\n  }\n\n  /**\n   * Called when the plugin is loaded\n   */\n  public override async onload(): Promise<void> {\n    initPluginContext(this.app, this.manifest.id);\n\n    this.register(registerAsyncErrorEventHandler(() => {\n      this.showNotice('An unhandled error occurred. Please check the console for more information.');\n    }));\n\n    this._settingsManager = this.createSettingsManager();\n\n    await this.onExternalSettingsChange();\n    const pluginSettingsTab = this.createPluginSettingsTab();\n    if (pluginSettingsTab) {\n      this.addSettingTab(pluginSettingsTab);\n    }\n\n    const abortController = new AbortController();\n    this._abortSignal = abortController.signal;\n    this.register(() => {\n      abortController.abort();\n    });\n    await this.onloadComplete();\n    setTimeout(() => {\n      this.app.workspace.onLayoutReady(this.onLayoutReady.bind(this));\n    }, 0);\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   * @returns A promise or void indicating the completion of the save process.\n   */\n  public async onSaveSettings(_newSettings: Partial<PluginSettings>, _oldSettings: Partial<PluginSettings>): Promise<void> {\n    await noopAsync();\n  }\n\n  /**\n   * Creates a plugin settings tab. This method must be implemented by subclasses.\n   *\n   * @returns The settings tab or null if not applicable.\n   */\n  protected abstract createPluginSettingsTab(): null | PluginSettingTab;\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 abstract createSettingsManager(): PluginSettingsManagerBase<PluginSettings>;\n\n  /**\n   * Called when the layout is ready. This method can be overridden by subclasses to perform actions once\n   * the layout is ready.\n   *\n   * @returns A promise or void indicating the completion of the layout setup.\n   */\n  protected onLayoutReady(): Promisable<void> {\n    noop();\n  }\n\n  /**\n   * Called when the plugin loading is complete. This method must be implemented by subclasses to perform\n   * any additional setup required after loading is complete.\n   *\n   * @returns A promise or void indicating the completion of the load process.\n   */\n  protected onloadComplete(): Promisable<void> {\n    noop();\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"],
  "mappings": ";;;;;;;AAeA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,SAAS,mBAAmB;AAC5B,SAAS,sCAAsC;AAC/C;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,yBAAyB;AAClC,SAAS,iCAAiC;AAOnC,MAAe,mBAA2D,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMtF,IAAW,cAA2B;AACpC,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,IAAW,WAAyC;AAClD,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,IAAW,kBAA6D;AACtE,WAAO,KAAK;AAAA,EACd;AAAA,EAEQ;AAAA,EAEA;AAAA,EAEA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcD,aAAa,YAAoB,MAAuB;AAE7D,UAAM,iBAAiB;AACvB,UAAM,YAAY,YAAY,KAAK,SAAS,IAAI,cAAc;AAC9D,cAAU,SAAS,GAAG,IAAI;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA,EAKA,MAAsB,2BAA0C;AAC9D,UAAM,KAAK,gBAAgB,aAAa;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA,EAKA,MAAsB,SAAwB;AAC5C,sBAAkB,KAAK,KAAK,KAAK,SAAS,EAAE;AAE5C,SAAK,SAAS,+BAA+B,MAAM;AACjD,WAAK,WAAW,6EAA6E;AAAA,IAC/F,CAAC,CAAC;AAEF,SAAK,mBAAmB,KAAK,sBAAsB;AAEnD,UAAM,KAAK,yBAAyB;AACpC,UAAM,oBAAoB,KAAK,wBAAwB;AACvD,QAAI,mBAAmB;AACrB,WAAK,cAAc,iBAAiB;AAAA,IACtC;AAEA,UAAM,kBAAkB,IAAI,gBAAgB;AAC5C,SAAK,eAAe,gBAAgB;AACpC,SAAK,SAAS,MAAM;AAClB,sBAAgB,MAAM;AAAA,IACxB,CAAC;AACD,UAAM,KAAK,eAAe;AAC1B,eAAW,MAAM;AACf,WAAK,IAAI,UAAU,cAAc,KAAK,cAAc,KAAK,IAAI,CAAC;AAAA,IAChE,GAAG,CAAC;AAAA,EACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAa,eAAe,cAAuC,cAAsD;AACvH,UAAM,UAAU;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBU,gBAAkC;AAC1C,SAAK;AAAA,EACP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,iBAAmC;AAC3C,SAAK;AAAA,EACP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOU,WAAW,SAAuB;AAC1C,QAAI,KAAK,QAAQ;AACf,WAAK,OAAO,KAAK;AAAA,IACnB;AAEA,SAAK,SAAS,IAAI,OAAO,GAAG,KAAK,SAAS,IAAI;AAAA,EAAK,OAAO,EAAE;AAAA,EAC9D;AACF;",
  "names": []
}

+//# 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 { AsyncEventRef } from '../../AsyncEvents.ts';\nimport type {\n  ExtractPluginSettings,\n  ExtractPluginSettingsManager,\n  ExtractPluginSettingsTab,\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 { registerAsyncErrorEventHandler } from '../../Error.ts';\nimport { noopAsync } from '../../Function.ts';\nimport { initPluginContext } 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 PluginSettings - The type representing the plugin settings object.\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.safeSettings as ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;\n  }\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  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 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/?tab=readme-ov-file#debugging} 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 _debugger = getDebugger(this.manifest.id, FRAMES_TO_SKIP);\n    _debugger(message, ...args);\n  }\n\n  /**\n   * Called when the external settings change.\n   */\n  public override async onExternalSettingsChange(): Promise<void> {\n    await super.onExternalSettingsChange?.();\n    await this._settingsManager?.loadFromFile();\n  }\n\n  /**\n   * Called when the plugin is loaded\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 settings are loaded or reloaded.\n   *\n   * @param _settings - The settings.\n   */\n  public async onLoadSettings(_settings: ExtractPluginSettings<PluginTypes>): 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   */\n  public async onSaveSettings(_newSettings: ExtractPluginSettings<PluginTypes>, _oldSettings: ExtractPluginSettings<PluginTypes>): Promise<void> {\n    await noopAsync();\n  }\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 an async event.\n   * Unregisters the event when the plugin is unloaded.\n   *\n   * @param eventRef - The event reference.\n   */\n  public registerAsyncEvent(eventRef: AsyncEventRef): void {\n    this.register(() => {\n      eventRef.asyncEvents.offref(eventRef);\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 a plugin settings tab.\n   *\n   * @returns The settings tab or null if not applicable.\n   */\n  protected createPluginSettingsTab(): ExtractPluginSettingsTab<PluginTypes> | null {\n    return null;\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   * Called when the layout is ready. This method can be overridden by subclasses to perform actions once\n   * the layout is ready.\n   */\n  protected async onLayoutReady(): Promise<void> {\n    await noopAsync();\n  }\n\n  protected async onloadImpl(): Promise<void> {\n    initPluginContext(this.app, this.manifest.id);\n\n    this.register(registerAsyncErrorEventHandler(() => {\n      this.showNotice('An unhandled error occurred. Please check the console for more information.');\n    }));\n\n    this._settingsManager = this.createSettingsManager();\n\n    await this.onExternalSettingsChange();\n    const pluginSettingsTab = this.createPluginSettingsTab();\n    if (pluginSettingsTab) {\n      this.addSettingTab(pluginSettingsTab);\n    }\n\n    const abortController = new AbortController();\n    this._abortSignal = abortController.signal;\n    this.register(() => {\n      abortController.abort();\n    });\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    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": []
}


package/dist/lib/esm/obsidian/Plugin/PluginContext.d.mts

@@ -1,5 +1,6 @@
 /**
- * @packageDocumentation PluginContext
+ * @packageDocumentation
+ *
  * Initializes the plugin context and sets up the plugin ID.
  */
 import type { App } from 'obsidian';

package/dist/lib/esm/obsidian/Plugin/PluginContext.mjs

@@ -42,4 +42,4 @@ function getPluginContextWindow() {
 export {
   initPluginContext
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL1BsdWdpbi9QbHVnaW5Db250ZXh0LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICpcbiAqIEluaXRpYWxpemVzIHRoZSBwbHVnaW4gY29udGV4dCBhbmQgc2V0cyB1cCB0aGUgcGx1Z2luIElELlxuICovXG5cbmltcG9ydCB0eXBlIHsgQXBwIH0gZnJvbSAnb2JzaWRpYW4nO1xuXG5pbXBvcnQgeyBjb21wYXJlVmVyc2lvbnMgfSBmcm9tICdjb21wYXJlLXZlcnNpb25zJztcblxuaW1wb3J0IHR5cGUgeyBEZWJ1Z0NvbnRyb2xsZXIgfSBmcm9tICcuLi8uLi9EZWJ1Z0NvbnRyb2xsZXIudHMnO1xuXG5pbXBvcnQge1xuICBnZXREZWJ1Z0NvbnRyb2xsZXIsXG4gIHNob3dJbml0aWFsRGVidWdNZXNzYWdlXG59IGZyb20gJy4uLy4uL0RlYnVnLnRzJztcbmltcG9ydCB7XG4gIExJQlJBUllfTkFNRSxcbiAgTElCUkFSWV9TVFlMRVMsXG4gIExJQlJBUllfVkVSU0lPTlxufSBmcm9tICcuLi8uLi9MaWJyYXJ5LnRzJztcbmltcG9ydCB7IGdldE9ic2lkaWFuRGV2VXRpbHNTdGF0ZSB9IGZyb20gJy4uL0FwcC50cyc7XG5pbXBvcnQgeyBzZXRQbHVnaW5JZCB9IGZyb20gJy4vUGx1Z2luSWQudHMnO1xuXG5pbnRlcmZhY2UgUGx1Z2luQ29udGV4dFdpbmRvdyB7XG4gIERFQlVHOiBEZWJ1Z0NvbnRyb2xsZXI7XG59XG5cbmNvbnN0IFNUWUxFU19JRCA9IGAke0xJQlJBUllfTkFNRX0tc3R5bGVzYDtcblxuLyoqXG4gKiBJbml0aWFsaXplcyB0aGUgcGx1Z2luIGNvbnRleHQuXG4gKlxuICogQHBhcmFtIGFwcCAtIFRoZSBPYnNpZGlhbiBhcHAgaW5zdGFuY2UuXG4gKiBAcGFyYW0gcGx1Z2luSWQgLSBUaGUgcGx1Z2luIElELlxuICovXG5leHBvcnQgZnVuY3Rpb24gaW5pdFBsdWdpbkNvbnRleHQoYXBwOiBBcHAsIHBsdWdpbklkOiBzdHJpbmcpOiB2b2lkIHtcbiAgc2V0UGx1Z2luSWQocGx1Z2luSWQpO1xuICBzaG93SW5pdGlhbERlYnVnTWVzc2FnZShwbHVnaW5JZCk7XG5cbiAgY29uc3QgbGFzdExpYnJhcnlWZXJzaW9uV3JhcHBlciA9IGdldE9ic2lkaWFuRGV2VXRpbHNTdGF0ZShhcHAsICdsYXN0TGlicmFyeVZlcnNpb24nLCAnMC4wLjAnKTtcbiAgaWYgKGNvbXBhcmVWZXJzaW9ucyhMSUJSQVJZX1ZFUlNJT04sIGxhc3RMaWJyYXJ5VmVyc2lvbldyYXBwZXIudmFsdWUpIDw9IDApIHtcbiAgICByZXR1cm47XG4gIH1cblxuICBsYXN0TGlicmFyeVZlcnNpb25XcmFwcGVyLnZhbHVlID0gTElCUkFSWV9WRVJTSU9OO1xuXG4gIGNvbnN0IHBsdWdpbkNvbnRleHRXaW5kb3cgPSBnZXRQbHVnaW5Db250ZXh0V2luZG93KCk7XG4gIHBsdWdpbkNvbnRleHRXaW5kb3cuREVCVUcgPSBnZXREZWJ1Z0NvbnRyb2xsZXIoKTtcblxuICBkb2N1bWVudC5oZWFkLnF1ZXJ5U2VsZWN0b3IoYCMke1NUWUxFU19JRH1gKT8ucmVtb3ZlKCk7XG4gIGRvY3VtZW50LmhlYWQuY3JlYXRlRWwoJ3N0eWxlJywge1xuICAgIGF0dHI6IHtcbiAgICAgIGlkOiBTVFlMRVNfSURcbiAgICB9LFxuICAgIHRleHQ6IExJQlJBUllfU1RZTEVTXG4gIH0pO1xufVxuXG5mdW5jdGlvbiBnZXRQbHVnaW5Db250ZXh0V2luZG93KCk6IFBhcnRpYWw8UGx1Z2luQ29udGV4dFdpbmRvdz4ge1xuICByZXR1cm4gd2luZG93IGFzIFBhcnRpYWw8UGx1Z2luQ29udGV4dFdpbmRvdz47XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7O0FBUUEsU0FBUyx1QkFBdUI7QUFJaEM7QUFBQSxFQUNFO0FBQUEsRUFDQTtBQUFBLE9BQ0s7QUFDUDtBQUFBLEVBQ0U7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLE9BQ0s7QUFDUCxTQUFTLGdDQUFnQztBQUN6QyxTQUFTLG1CQUFtQjtBQU01QixNQUFNLFlBQVksR0FBRyxZQUFZO0FBUTFCLFNBQVMsa0JBQWtCLEtBQVUsVUFBd0I7QUFDbEUsY0FBWSxRQUFRO0FBQ3BCLDBCQUF3QixRQUFRO0FBRWhDLFFBQU0sNEJBQTRCLHlCQUF5QixLQUFLLHNCQUFzQixPQUFPO0FBQzdGLE1BQUksZ0JBQWdCLGlCQUFpQiwwQkFBMEIsS0FBSyxLQUFLLEdBQUc7QUFDMUU7QUFBQSxFQUNGO0FBRUEsNEJBQTBCLFFBQVE7QUFFbEMsUUFBTSxzQkFBc0IsdUJBQXVCO0FBQ25ELHNCQUFvQixRQUFRLG1CQUFtQjtBQUUvQyxXQUFTLEtBQUssY0FBYyxJQUFJLFNBQVMsRUFBRSxHQUFHLE9BQU87QUFDckQsV0FBUyxLQUFLLFNBQVMsU0FBUztBQUFBLElBQzlCLE1BQU07QUFBQSxNQUNKLElBQUk7QUFBQSxJQUNOO0FBQUEsSUFDQSxNQUFNO0FBQUEsRUFDUixDQUFDO0FBQ0g7QUFFQSxTQUFTLHlCQUF1RDtBQUM5RCxTQUFPO0FBQ1Q7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/obsidian/Plugin/PluginId.d.mts

@@ -1,5 +1,6 @@
 /**
- * @packageDocumentation PluginId
+ * @packageDocumentation
+ *
  * Holder for the plugin ID.
  */
 /**

package/dist/lib/esm/obsidian/Plugin/PluginId.mjs

@@ -20,4 +20,4 @@ export {
   getPluginId,
   setPluginId
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL1BsdWdpbi9QbHVnaW5JZC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb24gUGx1Z2luSWRcbiAqIEhvbGRlciBmb3IgdGhlIHBsdWdpbiBJRC5cbiAqL1xuXG4vKipcbiAqIFRoZSBwbHVnaW4gSUQgZm9yIG5vIHBsdWdpbi5cbiAqL1xuZXhwb3J0IGNvbnN0IE5PX1BMVUdJTl9JRF9JTklUSUFMSVpFRCA9ICdfX25vLXBsdWdpbi1pZC1pbml0aWFsaXplZF9fJztcblxubGV0IHBsdWdpbklkID0gTk9fUExVR0lOX0lEX0lOSVRJQUxJWkVEO1xuXG4vKipcbiAqIFJldHVybnMgdGhlIHBsdWdpbiBJRC5cbiAqXG4gKiBAcmV0dXJucyBUaGUgcGx1Z2luIElELlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0UGx1Z2luSWQoKTogc3RyaW5nIHtcbiAgcmV0dXJuIHBsdWdpbklkO1xufVxuXG4vKipcbiAqIFNldHMgdGhlIHBsdWdpbiBJRC5cbiAqXG4gKiBAcGFyYW0gbmV3UGx1Z2luSWQgLSBUaGUgbmV3IHBsdWdpbiBJRC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNldFBsdWdpbklkKG5ld1BsdWdpbklkOiBzdHJpbmcpOiB2b2lkIHtcbiAgaWYgKG5ld1BsdWdpbklkKSB7XG4gICAgcGx1Z2luSWQgPSBuZXdQbHVnaW5JZDtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7OztBQVFPLE1BQU0sMkJBQTJCO0FBRXhDLElBQUksV0FBVztBQU9SLFNBQVMsY0FBc0I7QUFDcEMsU0FBTztBQUNUO0FBT08sU0FBUyxZQUFZLGFBQTJCO0FBQ3JELE1BQUksYUFBYTtBQUNmLGVBQVc7QUFBQSxFQUNiO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL1BsdWdpbi9QbHVnaW5JZC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAcGFja2FnZURvY3VtZW50YXRpb25cbiAqXG4gKiBIb2xkZXIgZm9yIHRoZSBwbHVnaW4gSUQuXG4gKi9cblxuLyoqXG4gKiBUaGUgcGx1Z2luIElEIGZvciBubyBwbHVnaW4uXG4gKi9cbmV4cG9ydCBjb25zdCBOT19QTFVHSU5fSURfSU5JVElBTElaRUQgPSAnX19uby1wbHVnaW4taWQtaW5pdGlhbGl6ZWRfXyc7XG5cbmxldCBwbHVnaW5JZCA9IE5PX1BMVUdJTl9JRF9JTklUSUFMSVpFRDtcblxuLyoqXG4gKiBSZXR1cm5zIHRoZSBwbHVnaW4gSUQuXG4gKlxuICogQHJldHVybnMgVGhlIHBsdWdpbiBJRC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFBsdWdpbklkKCk6IHN0cmluZyB7XG4gIHJldHVybiBwbHVnaW5JZDtcbn1cblxuLyoqXG4gKiBTZXRzIHRoZSBwbHVnaW4gSUQuXG4gKlxuICogQHBhcmFtIG5ld1BsdWdpbklkIC0gVGhlIG5ldyBwbHVnaW4gSUQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzZXRQbHVnaW5JZChuZXdQbHVnaW5JZDogc3RyaW5nKTogdm9pZCB7XG4gIGlmIChuZXdQbHVnaW5JZCkge1xuICAgIHBsdWdpbklkID0gbmV3UGx1Z2luSWQ7XG4gIH1cbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7QUFTTyxNQUFNLDJCQUEyQjtBQUV4QyxJQUFJLFdBQVc7QUFPUixTQUFTLGNBQXNCO0FBQ3BDLFNBQU87QUFDVDtBQU9PLFNBQVMsWUFBWSxhQUEyQjtBQUNyRCxNQUFJLGFBQWE7QUFDZixlQUFXO0FBQUEsRUFDYjtBQUNGOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/obsidian/Plugin/PluginSettingsManagerBase.d.mts

@@ -1,36 +1,55 @@
+/**
+ * @packageDocumentation
+ *
+ * Plugin settings manager base class.
+ */
+import type { App } from 'obsidian';
 import type { Promisable, ReadonlyDeep } from 'type-fest';
-import type { MaybeReturn, StringKeys } from '../../Object.mjs';
 import type { Transformer } from '../../Transformers/Transformer.mjs';
-import type { PluginBase } from './PluginBase.mjs';
+import type { MaybeReturn, StringKeys } from '../../Type.mjs';
+import type { ExtractPlugin, ExtractPluginSettings, PluginTypesBase } from './PluginTypesBase.mjs';
 type Validator<T> = (value: T) => Promisable<MaybeReturn<string>>;
 /**
  * Base class for managing plugin settings.
  *
  * @typeParam PluginSettings - The type representing the plugin settings object.
  */
-export declare abstract class PluginSettingsManagerBase<PluginSettings extends object> {
-    private plugin;
-    readonly safeSettings: ReadonlyDeep<PluginSettings>;
+export declare abstract class PluginSettingsManagerBase<PluginTypes extends PluginTypesBase> {
+    readonly plugin: ExtractPlugin<PluginTypes>;
+    readonly app: App;
+    readonly safeSettings: ReadonlyDeep<ExtractPluginSettings<PluginTypes>>;
     private defaultSettings;
     private properties;
     private validators;
-    constructor(plugin: PluginBase<PluginSettings>);
-    editAndSave(editor: (settings: PluginSettings) => Promisable<void>): Promise<void>;
-    getProperty<PropertyName extends StringKeys<PluginSettings>>(propertyName: PropertyName): PluginSettingsProperty<PluginSettings[PropertyName]>;
+    constructor(plugin: ExtractPlugin<PluginTypes>);
+    editAndSave(editor: (settings: ExtractPluginSettings<PluginTypes>) => Promisable<void>): Promise<void>;
+    getProperty<PropertyName extends StringKeys<ExtractPluginSettings<PluginTypes>>>(propertyName: PropertyName): PluginSettingsProperty<ExtractPluginSettings<PluginTypes>[PropertyName]>;
     loadFromFile(): Promise<void>;
     /**
      * Saves the new plugin settings.
      *
-     * @returns A promise that resolves when the settings are saved.
+     * @returns A {@link Promise} that resolves when the settings are saved.
      */
     saveToFile(): Promise<void>;
-    protected addValidator<PropertyName extends StringKeys<PluginSettings>>(propertyName: PropertyName, validator: Validator<PluginSettings[PropertyName]>): void;
-    protected addValidators(): void;
-    protected abstract createDefaultSettings(): PluginSettings;
+    protected abstract createDefaultSettings(): ExtractPluginSettings<PluginTypes>;
     protected getTransformer(): Transformer;
-    protected prepareRecord(_record: Record<string, unknown>): Promisable<void>;
+    /**
+     * Called when the plugin settings are loaded.
+     *
+     * @param _record - The record.
+     */
+    protected onLoadRecord(_record: Record<string, unknown>): Promise<void>;
+    /**
+     * Called when the plugin settings are saving.
+     *
+     * @param _record - The record.
+     */
+    protected onSavingRecord(_record: Record<string, unknown>): Promise<void>;
+    protected registerValidator<PropertyName extends StringKeys<ExtractPluginSettings<PluginTypes>>>(propertyName: PropertyName, validator: Validator<ExtractPluginSettings<PluginTypes>[PropertyName]>): void;
+    protected registerValidators(): void;
     private getSavedSettings;
     private prepareRecordToSave;
+    private saveToFileImpl;
 }
 /**
  * A property of a plugin settings.
@@ -41,19 +60,18 @@ export declare class PluginSettingsProperty<T> {
     private readonly propertyName;
     readonly defaultValue: T;
     private readonly validator;
+    get currentValue(): T;
+    get lastSavedValue(): T;
+    get safeValue(): T;
     get validationMessage(): string;
+    private _currentValue;
+    private _lastSavedValue;
     private _validationMessage;
-    private lastSavedValue;
-    private modifiedValue;
     constructor(propertyName: string, defaultValue: T, validator: Validator<T>);
-    clear(): void;
-    getLastSavedValue(): T | undefined;
-    getModifiedOrDefaultValue(): T;
-    getModifiedValue(): T | undefined;
-    getSafeValue(): T;
+    reset(): void;
     save(): boolean;
     setValidationMessage(validationMessage: string): void;
-    setValue(value: T | undefined): void;
+    setValue(value: T): void;
     setValueAndValidate(value: T): Promise<void>;
     private showWarning;
 }