obsidian-dev-utils 69.2.4 → 70.0.0

package/dist/lib/cjs/obsidian/components/component-ex.cjs

@@ -129,14 +129,19 @@ __export(component_ex_exports, {
 });
 module.exports = __toCommonJS(component_ex_exports);
 var import_obsidian = require('obsidian');
-var import_async = require('../../async.cjs');
+var import_error = require('../../error.cjs');
 var import_function = require('../../function.cjs');
 class ComponentEx extends import_obsidian.Component {
   childrenSet = /* @__PURE__ */ new Set();
+  loadErrors = [];
   loadPromise = null;
   /**
    * Adds a child component.
    *
+   * Mirrors the native `Component.addChild` contract: if this component is already loaded, the child is loaded
+   * immediately, so `child._loaded` is set before this method returns even when this component has async load logic.
+   * The child's async tail (if any) is sequenced into the load promise so a later {@link loadWithPromises} call awaits it.
+   *
    * @typeParam TComponent - The type of component to add.
    * @param component - The component instance to add.
    * @returns The added component.
@@ -145,27 +150,28 @@ class ComponentEx extends import_obsidian.Component {
     this._children.push(component);
     this.childrenSet.add(component);
     if (this._loaded) {
-      this.loadPromise = (0, import_async.chain)(this.loadPromise, () => this.extractLoadPromisable(component));
+      this.appendEagerLoadStep(this.extractLoadPromisable(component));
     }
     return component;
   }
   /**
    * Loads the component.
    *
-   * @returns Despite the declared `void` return type, this method returns a {@link Promise} that resolves when the component is loaded or `null` if the component if fully synchronous.
+   * @returns Despite the declared `void` return type, this method returns a {@link Promise} that resolves when the component is loaded or `null` if the component is fully synchronous.
    */
   load() {
     if (this._loaded) {
       return;
     }
     this._loaded = true;
+    this.resetLoadState();
     this.onload();
     const onloadAsyncPromise = this.onloadAsync();
     if (onloadAsyncPromise !== import_function.noopAsyncSingletonPromise) {
-      this.loadPromise = (0, import_async.chain)(this.loadPromise, () => onloadAsyncPromise);
+      this.appendEagerLoadStep(onloadAsyncPromise);
     }
     for (const child of this._children.slice()) {
-      this.loadPromise = (0, import_async.chain)(this.loadPromise, () => this.extractLoadPromisable(child));
+      this.appendSequentialLoadStep(() => this.extractLoadPromisable(child));
     }
     if (this.loadPromise) {
       return this.loadPromise;
@@ -174,11 +180,26 @@ class ComponentEx extends import_obsidian.Component {
   /**
    * Loads the component with promises.
    *
-   * @returns A {@link Promise} that resolves when the component is loaded or `null` if the component and its children don't use `async` logic.
+   * Unlike {@link load}, this method never rejects with an individual error: every failure raised by {@link onloadAsync}
+   * or a child's load is collected, and once everything settles the returned {@link Promise} rejects with a single
+   * {@link AggregateError} holding all of them. Non-`Error` throwables are normalized via {@link ErrorWrapper.create}.
+   *
+   * @returns A {@link Promise} that resolves when the component and its children finish loading, rejects with an {@link AggregateError} if any load step failed, or `null` if the component and its children don't use `async` logic and none failed synchronously.
    */
   loadWithPromises() {
     this.load();
-    return this.loadPromise;
+    const loadPromise = this.loadPromise;
+    if (!loadPromise) {
+      if (this.loadErrors.length > 0) {
+        return Promise.reject(new AggregateError(this.loadErrors));
+      }
+      return null;
+    }
+    return loadPromise.then(() => {
+      if (this.loadErrors.length > 0) {
+        throw new AggregateError(this.loadErrors);
+      }
+    });
   }
   /**
    * Asynchronously loads the component.
@@ -208,6 +229,94 @@ class ComponentEx extends import_obsidian.Component {
   [Symbol.dispose]() {
     this.unload();
   }
+  /**
+   * Ensures the component is loaded, throwing if it is not.
+   *
+   * Use this to guard public methods that register teardown-bearing resources (via {@link Component.register},
+   * {@link Component.registerEvent}, {@link Component.registerDomEvent}, etc.). Registering before load is unsafe:
+   * {@link Component.unload} is a no-op while the component is not loaded, so any teardown registered beforehand would
+   * never run if the component is unloaded without first being loaded.
+   *
+   * @throws An {@link Error} if the component is not loaded.
+   */
+  ensureLoaded() {
+    if (!this._loaded) {
+      throw new Error("Component is not loaded");
+    }
+  }
+  /**
+   * Sequences an already-started load step into the load promise.
+   *
+   * The step is presumed to have started synchronously (so any `_loaded` flag it sets is already visible); only the
+   * awaiting of its async tail is sequenced here.
+   *
+   * @param loadPromisable - The result of an already-started load step.
+   */
+  appendEagerLoadStep(loadPromisable) {
+    const captured = this.captureSettled(loadPromisable);
+    if (!captured) {
+      return;
+    }
+    const previous = this.loadPromise;
+    this.setLoadPromise(previous ? previous.then(() => captured) : captured);
+  }
+  /**
+   * Sequences a deferred load step into the load promise, running it only after previously-appended steps settle.
+   *
+   * @param loadPromisableFn - A function that starts the load step and returns its result.
+   */
+  appendSequentialLoadStep(loadPromisableFn) {
+    const previous = this.loadPromise;
+    if (previous) {
+      this.setLoadPromise(previous.then(() => this.runAndCapture(loadPromisableFn)));
+      return;
+    }
+    const captured = this.captureSync(loadPromisableFn);
+    if (captured) {
+      this.setLoadPromise(captured);
+    }
+  }
+  /**
+   * Records a load failure.
+   *
+   * A failure raised by a child {@link ComponentEx} is itself an {@link AggregateError}; it is recorded as-is so the
+   * grouping by child component is preserved (own failures stay flat, child-subtree failures stay nested).
+   *
+   * @param error - The thrown value to record.
+   */
+  captureError(error) {
+    this.loadErrors.push(import_error.ErrorWrapper.create(error));
+  }
+  /**
+   * Wraps an already-started load result so it never rejects: any failure is recorded into `loadErrors`.
+   *
+   * @param loadPromisable - The load result to observe.
+   * @returns A never-rejecting {@link Promise}, or `null` if the result is fully synchronous.
+   */
+  captureSettled(loadPromisable) {
+    if (loadPromisable === null || loadPromisable === void 0) {
+      return null;
+    }
+    return Promise.resolve(loadPromisable).then(import_function.noop, (error) => {
+      this.captureError(error);
+    });
+  }
+  /**
+   * Runs a load step synchronously, recording a synchronous throw, and wraps any async tail so it never rejects.
+   *
+   * @param loadPromisableFn - A function that starts the load step and returns its result.
+   * @returns A never-rejecting {@link Promise}, or `null` if the step is fully synchronous.
+   */
+  captureSync(loadPromisableFn) {
+    let loadPromisable;
+    try {
+      loadPromisable = loadPromisableFn();
+    } catch (error) {
+      this.captureError(error);
+      return null;
+    }
+    return this.captureSettled(loadPromisable);
+  }
   extractLoadPromisable(component) {
     if (!this.childrenSet.has(component)) {
       return null;
@@ -217,9 +326,33 @@ class ComponentEx extends import_obsidian.Component {
     }
     return component.load();
   }
+  resetLoadState() {
+    this.loadErrors = [];
+    this.loadPromise = null;
+  }
+  /**
+   * Runs a deferred load step, recording a synchronous throw or an async rejection without ever re-throwing.
+   *
+   * @param loadPromisableFn - A function that starts the load step and returns its result.
+   */
+  async runAndCapture(loadPromisableFn) {
+    try {
+      await (loadPromisableFn() ?? void 0);
+    } catch (error) {
+      this.captureError(error);
+    }
+  }
+  setLoadPromise(loadPromise) {
+    const loadPromiseWithReset = loadPromise.then(() => {
+      if (this.loadPromise === loadPromiseWithReset) {
+        this.loadPromise = null;
+      }
+    });
+    this.loadPromise = loadPromiseWithReset;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ComponentEx
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/component-ex.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Extended Component\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { Component } from 'obsidian';\n\nimport { ErrorWrapper } from '../../error.ts';\nimport {\n  noop,\n  noopAsyncSingletonPromise\n} from '../../function.ts';\n\n/**\n * Extended Component\n */\n// eslint-disable-next-line obsidian-dev-utils/require-component-suffix -- Extended base class.\nexport class ComponentEx extends Component implements Disposable {\n  private readonly childrenSet = new Set<Component>();\n  private loadErrors: Error[] = [];\n  private loadPromise: null | Promise<void> = null;\n\n  /**\n   * Adds a child component.\n   *\n   * Mirrors the native `Component.addChild` contract: if this component is already loaded, the child is loaded\n   * immediately, so `child._loaded` is set before this method returns even when this component has async load logic.\n   * The child's async tail (if any) is sequenced into the load promise so a later {@link loadWithPromises} call awaits it.\n   *\n   * @typeParam TComponent - The type of component to add.\n   * @param component - The component instance to add.\n   * @returns The added component.\n   */\n  public override addChild<TComponent extends Component>(component: TComponent): TComponent {\n    this._children.push(component);\n    this.childrenSet.add(component);\n\n    if (this._loaded) {\n      this.appendEagerLoadStep(this.extractLoadPromisable(component));\n    }\n\n    return component;\n  }\n\n  /**\n   * Loads the component.\n   *\n   * @returns Despite the declared `void` return type, this method returns a {@link Promise} that resolves when the component is loaded or `null` if the component is fully synchronous.\n   */\n  public override load(): void {\n    if (this._loaded) {\n      return;\n    }\n\n    this._loaded = true;\n    this.resetLoadState();\n\n    this.onload();\n\n    const onloadAsyncPromise = this.onloadAsync();\n    if (onloadAsyncPromise !== noopAsyncSingletonPromise) {\n      this.appendEagerLoadStep(onloadAsyncPromise);\n    }\n\n    for (const child of this._children.slice()) {\n      this.appendSequentialLoadStep(() => this.extractLoadPromisable(child));\n    }\n\n    if (this.loadPromise) {\n      // eslint-disable-next-line @typescript-eslint/no-invalid-void-type, no-restricted-syntax -- We need to bypass type system to return `Promise<void>`.\n      return this.loadPromise as unknown as void;\n    }\n  }\n\n  /**\n   * Loads the component with promises.\n   *\n   * Unlike {@link load}, this method never rejects with an individual error: every failure raised by {@link onloadAsync}\n   * or a child's load is collected, and once everything settles the returned {@link Promise} rejects with a single\n   * {@link AggregateError} holding all of them. Non-`Error` throwables are normalized via {@link ErrorWrapper.create}.\n   *\n   * @returns A {@link Promise} that resolves when the component and its children finish loading, rejects with an {@link AggregateError} if any load step failed, or `null` if the component and its children don't use `async` logic and none failed synchronously.\n   */\n  public loadWithPromises(): null | Promise<void> {\n    this.load();\n\n    const loadPromise = this.loadPromise;\n    if (!loadPromise) {\n      if (this.loadErrors.length > 0) {\n        return Promise.reject(new AggregateError(this.loadErrors));\n      }\n      return null;\n    }\n\n    return loadPromise.then(() => {\n      if (this.loadErrors.length > 0) {\n        throw new AggregateError(this.loadErrors);\n      }\n    });\n  }\n\n  /**\n   * Asynchronously loads the component.\n   *\n   * Override to add async load logic, which is executed after {@link Component.onload}.\n   *\n   * @returns A {@link Promise} that resolves when the component is loaded.\n   */\n  public onloadAsync(): Promise<void> {\n    return noopAsyncSingletonPromise;\n  }\n\n  /**\n   * Removes a child component.\n   *\n   * @typeParam TComponent - The type of component to remove.\n   * @param component - The component instance to remove.\n   * @returns The removed component.\n   */\n  public override removeChild<TComponent extends Component>(component: TComponent): TComponent {\n    super.removeChild(component);\n    this.childrenSet.delete(component);\n    return component;\n  }\n\n  /**\n   * Disposes of the component.\n   */\n  public [Symbol.dispose](): void {\n    this.unload();\n  }\n\n  /**\n   * Ensures the component is loaded, throwing if it is not.\n   *\n   * Use this to guard public methods that register teardown-bearing resources (via {@link Component.register},\n   * {@link Component.registerEvent}, {@link Component.registerDomEvent}, etc.). Registering before load is unsafe:\n   * {@link Component.unload} is a no-op while the component is not loaded, so any teardown registered beforehand would\n   * never run if the component is unloaded without first being loaded.\n   *\n   * @throws An {@link Error} if the component is not loaded.\n   */\n  protected ensureLoaded(): void {\n    if (!this._loaded) {\n      throw new Error('Component is not loaded');\n    }\n  }\n\n  /**\n   * Sequences an already-started load step into the load promise.\n   *\n   * The step is presumed to have started synchronously (so any `_loaded` flag it sets is already visible); only the\n   * awaiting of its async tail is sequenced here.\n   *\n   * @param loadPromisable - The result of an already-started load step.\n   */\n  private appendEagerLoadStep(loadPromisable: null | Promisable<void>): void {\n    const captured = this.captureSettled(loadPromisable);\n    if (!captured) {\n      return;\n    }\n\n    const previous = this.loadPromise;\n    this.setLoadPromise(previous ? previous.then(() => captured) : captured);\n  }\n\n  /**\n   * Sequences a deferred load step into the load promise, running it only after previously-appended steps settle.\n   *\n   * @param loadPromisableFn - A function that starts the load step and returns its result.\n   */\n  private appendSequentialLoadStep(loadPromisableFn: () => null | Promisable<void>): void {\n    const previous = this.loadPromise;\n    if (previous) {\n      this.setLoadPromise(previous.then(() => this.runAndCapture(loadPromisableFn)));\n      return;\n    }\n\n    const captured = this.captureSync(loadPromisableFn);\n    if (captured) {\n      this.setLoadPromise(captured);\n    }\n  }\n\n  /**\n   * Records a load failure.\n   *\n   * A failure raised by a child {@link ComponentEx} is itself an {@link AggregateError}; it is recorded as-is so the\n   * grouping by child component is preserved (own failures stay flat, child-subtree failures stay nested).\n   *\n   * @param error - The thrown value to record.\n   */\n  private captureError(error: unknown): void {\n    this.loadErrors.push(ErrorWrapper.create(error));\n  }\n\n  /**\n   * Wraps an already-started load result so it never rejects: any failure is recorded into `loadErrors`.\n   *\n   * @param loadPromisable - The load result to observe.\n   * @returns A never-rejecting {@link Promise}, or `null` if the result is fully synchronous.\n   */\n  private captureSettled(loadPromisable: null | Promisable<void>): null | Promise<void> {\n    if (loadPromisable === null || loadPromisable === undefined) {\n      return null;\n    }\n\n    return Promise.resolve(loadPromisable).then(noop, (error: unknown) => {\n      this.captureError(error);\n    });\n  }\n\n  /**\n   * Runs a load step synchronously, recording a synchronous throw, and wraps any async tail so it never rejects.\n   *\n   * @param loadPromisableFn - A function that starts the load step and returns its result.\n   * @returns A never-rejecting {@link Promise}, or `null` if the step is fully synchronous.\n   */\n  private captureSync(loadPromisableFn: () => null | Promisable<void>): null | Promise<void> {\n    let loadPromisable: null | Promisable<void>;\n    try {\n      loadPromisable = loadPromisableFn();\n    } catch (error) {\n      this.captureError(error);\n      return null;\n    }\n\n    return this.captureSettled(loadPromisable);\n  }\n\n  private extractLoadPromisable(component: Component): null | Promisable<void> {\n    if (!this.childrenSet.has(component)) {\n      return null;\n    }\n    if (component instanceof ComponentEx) {\n      return component.loadWithPromises();\n    }\n    // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression, @typescript-eslint/no-unnecessary-type-assertion -- It can be `Promise<void>` in runtime. Want explicitly cast to show we know it may be promise, despite the declared type `void`.\n    return component.load() as Promisable<void>;\n  }\n\n  private resetLoadState(): void {\n    this.loadErrors = [];\n    this.loadPromise = null;\n  }\n\n  /**\n   * Runs a deferred load step, recording a synchronous throw or an async rejection without ever re-throwing.\n   *\n   * @param loadPromisableFn - A function that starts the load step and returns its result.\n   */\n  private async runAndCapture(loadPromisableFn: () => null | Promisable<void>): Promise<void> {\n    try {\n      await (loadPromisableFn() ?? undefined);\n    } catch (error) {\n      this.captureError(error);\n    }\n  }\n\n  private setLoadPromise(loadPromise: Promise<void>): void {\n    const loadPromiseWithReset: Promise<void> = loadPromise.then(() => {\n      if (this.loadPromise === loadPromiseWithReset) {\n        this.loadPromise = null;\n      }\n    });\n    this.loadPromise = loadPromiseWithReset;\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/obsidian/components/component-ex.d.cts

@@ -10,10 +10,15 @@ import { Component } from 'obsidian';
  */
 export declare class ComponentEx extends Component implements Disposable {
     private readonly childrenSet;
+    private loadErrors;
     private loadPromise;
     /**
      * Adds a child component.
      *
+     * Mirrors the native `Component.addChild` contract: if this component is already loaded, the child is loaded
+     * immediately, so `child._loaded` is set before this method returns even when this component has async load logic.
+     * The child's async tail (if any) is sequenced into the load promise so a later {@link loadWithPromises} call awaits it.
+     *
      * @typeParam TComponent - The type of component to add.
      * @param component - The component instance to add.
      * @returns The added component.
@@ -22,13 +27,17 @@ export declare class ComponentEx extends Component implements Disposable {
     /**
      * Loads the component.
      *
-     * @returns Despite the declared `void` return type, this method returns a {@link Promise} that resolves when the component is loaded or `null` if the component if fully synchronous.
+     * @returns Despite the declared `void` return type, this method returns a {@link Promise} that resolves when the component is loaded or `null` if the component is fully synchronous.
      */
     load(): void;
     /**
      * Loads the component with promises.
      *
-     * @returns A {@link Promise} that resolves when the component is loaded or `null` if the component and its children don't use `async` logic.
+     * Unlike {@link load}, this method never rejects with an individual error: every failure raised by {@link onloadAsync}
+     * or a child's load is collected, and once everything settles the returned {@link Promise} rejects with a single
+     * {@link AggregateError} holding all of them. Non-`Error` throwables are normalized via {@link ErrorWrapper.create}.
+     *
+     * @returns A {@link Promise} that resolves when the component and its children finish loading, rejects with an {@link AggregateError} if any load step failed, or `null` if the component and its children don't use `async` logic and none failed synchronously.
      */
     loadWithPromises(): null | Promise<void>;
     /**
@@ -51,5 +60,62 @@ export declare class ComponentEx extends Component implements Disposable {
      * Disposes of the component.
      */
     [Symbol.dispose](): void;
+    /**
+     * Ensures the component is loaded, throwing if it is not.
+     *
+     * Use this to guard public methods that register teardown-bearing resources (via {@link Component.register},
+     * {@link Component.registerEvent}, {@link Component.registerDomEvent}, etc.). Registering before load is unsafe:
+     * {@link Component.unload} is a no-op while the component is not loaded, so any teardown registered beforehand would
+     * never run if the component is unloaded without first being loaded.
+     *
+     * @throws An {@link Error} if the component is not loaded.
+     */
+    protected ensureLoaded(): void;
+    /**
+     * Sequences an already-started load step into the load promise.
+     *
+     * The step is presumed to have started synchronously (so any `_loaded` flag it sets is already visible); only the
+     * awaiting of its async tail is sequenced here.
+     *
+     * @param loadPromisable - The result of an already-started load step.
+     */
+    private appendEagerLoadStep;
+    /**
+     * Sequences a deferred load step into the load promise, running it only after previously-appended steps settle.
+     *
+     * @param loadPromisableFn - A function that starts the load step and returns its result.
+     */
+    private appendSequentialLoadStep;
+    /**
+     * Records a load failure.
+     *
+     * A failure raised by a child {@link ComponentEx} is itself an {@link AggregateError}; it is recorded as-is so the
+     * grouping by child component is preserved (own failures stay flat, child-subtree failures stay nested).
+     *
+     * @param error - The thrown value to record.
+     */
+    private captureError;
+    /**
+     * Wraps an already-started load result so it never rejects: any failure is recorded into `loadErrors`.
+     *
+     * @param loadPromisable - The load result to observe.
+     * @returns A never-rejecting {@link Promise}, or `null` if the result is fully synchronous.
+     */
+    private captureSettled;
+    /**
+     * Runs a load step synchronously, recording a synchronous throw, and wraps any async tail so it never rejects.
+     *
+     * @param loadPromisableFn - A function that starts the load step and returns its result.
+     * @returns A never-rejecting {@link Promise}, or `null` if the step is fully synchronous.
+     */
+    private captureSync;
     private extractLoadPromisable;
+    private resetLoadState;
+    /**
+     * Runs a deferred load step, recording a synchronous throw or an async rejection without ever re-throwing.
+     *
+     * @param loadPromisableFn - A function that starts the load step and returns its result.
+     */
+    private runAndCapture;
+    private setLoadPromise;
 }

package/dist/lib/cjs/obsidian/components/console-debug-component.cjs

@@ -147,7 +147,8 @@ class ConsoleDebugComponent extends import_component_ex.ComponentEx {
    * @param message - The message to log.
    * @param args - Additional arguments to log.
    */
-  debug(message, ...args) {
+  consoleDebug(message, ...args) {
+    this.ensureLoaded();
     const FRAMES_TO_SKIP = 1;
     const pluginDebugger = (0, import_debug.getDebugger)(this.pluginId, FRAMES_TO_SKIP);
     pluginDebugger(message, ...args);
@@ -157,4 +158,4 @@ class ConsoleDebugComponent extends import_component_ex.ComponentEx {
 0 && (module.exports = {
   ConsoleDebugComponent
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2NvbXBvbmVudHMvY29uc29sZS1kZWJ1Zy1jb21wb25lbnQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBDb21wb25lbnQgdGhhdCBwcm92aWRlcyBuYW1lc3BhY2VkIGNvbnNvbGUgZGVidWcgbG9nZ2luZy5cbiAqL1xuXG5pbXBvcnQgeyBnZXREZWJ1Z2dlciB9IGZyb20gJy4uLy4uL2RlYnVnLnRzJztcbmltcG9ydCB7IENvbXBvbmVudEV4IH0gZnJvbSAnLi9jb21wb25lbnQtZXgudHMnO1xuXG4vKipcbiAqIFByb3ZpZGVzIGEgbmFtZXNwYWNlZCBgY29uc29sZURlYnVnKClgIG1ldGhvZCBmb3IgbG9nZ2luZy5cbiAqXG4gKiBNZXNzYWdlcyBhcmUgbm90IHNob3duIGJ5IGRlZmF1bHQgXHUyMDE0IGVuYWJsZSB0aGUgcGx1Z2luJ3MgZGVidWdnZXIgbmFtZXNwYWNlIHRvIHNlZSB0aGVtLlxuICpcbiAqIEBzZWUge0BsaW5rIGh0dHBzOi8vZ2l0aHViLmNvbS9tbmFvdW1vdi9vYnNpZGlhbi1kZXYtdXRpbHMvYmxvYi9tYWluL2RvY3MvZGVidWdnaW5nLm1kfSBmb3IgbW9yZSBpbmZvcm1hdGlvbi5cbiAqL1xuZXhwb3J0IGNsYXNzIENvbnNvbGVEZWJ1Z0NvbXBvbmVudCBleHRlbmRzIENvbXBvbmVudEV4IHtcbiAgLyoqXG4gICAqIENyZWF0ZXMgYSBuZXcgY29uc29sZSBkZWJ1ZyBjb21wb25lbnQuXG4gICAqXG4gICAqIEBwYXJhbSBwbHVnaW5JZCAtIFRoZSBwbHVnaW4gSUQgKHVzZWQgYXMgdGhlIGRlYnVnZ2VyIG5hbWVzcGFjZSkuXG4gICAqL1xuICBwdWJsaWMgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBwbHVnaW5JZDogc3RyaW5nKSB7XG4gICAgc3VwZXIoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBMb2dzIGEgbWVzc2FnZSB0byB0aGUgY29uc29sZSB1bmRlciB0aGUgcGx1Z2luJ3MgZGVidWdnZXIgbmFtZXNwYWNlLlxuICAgKlxuICAgKiBAcGFyYW0gbWVzc2FnZSAtIFRoZSBtZXNzYWdlIHRvIGxvZy5cbiAgICogQHBhcmFtIGFyZ3MgLSBBZGRpdGlvbmFsIGFyZ3VtZW50cyB0byBsb2cuXG4gICAqL1xuICBwdWJsaWMgZGVidWcobWVzc2FnZTogc3RyaW5nLCAuLi5hcmdzOiB1bmtub3duW10pOiB2b2lkIHtcbiAgICAvLyBTa2lwIHRoZSBgZGVidWcoKWAgY2FsbCBpdHNlbGZcbiAgICBjb25zdCBGUkFNRVNfVE9fU0tJUCA9IDE7XG4gICAgY29uc3QgcGx1Z2luRGVidWdnZXIgPSBnZXREZWJ1Z2dlcih0aGlzLnBsdWdpbklkLCBGUkFNRVNfVE9fU0tJUCk7XG4gICAgcGx1Z2luRGVidWdnZXIobWVzc2FnZSwgLi4uYXJncyk7XG4gIH1cbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQU1BLG1CQUE0QjtBQUM1QiwwQkFBNEI7QUFTckIsTUFBTSw4QkFBOEIsZ0NBQVk7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFNOUMsWUFBNkIsVUFBa0I7QUFDcEQsVUFBTTtBQUQ0QjtBQUFBLEVBRXBDO0FBQUEsRUFGb0M7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQVU3QixNQUFNLFlBQW9CLE1BQXVCO0FBRXRELFVBQU0saUJBQWlCO0FBQ3ZCLFVBQU0scUJBQWlCLDBCQUFZLEtBQUssVUFBVSxjQUFjO0FBQ2hFLG1CQUFlLFNBQVMsR0FBRyxJQUFJO0FBQUEsRUFDakM7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/components/console-debug-component.d.cts

@@ -26,5 +26,5 @@ export declare class ConsoleDebugComponent extends ComponentEx {
      * @param message - The message to log.
      * @param args - Additional arguments to log.
      */
-    debug(message: string, ...args: unknown[]): void;
+    consoleDebug(message: string, ...args: unknown[]): void;
 }

package/dist/lib/cjs/obsidian/components/menu-event-registrar-component.cjs

@@ -146,6 +146,7 @@ class MenuEventRegistrarComponent extends import_component_ex.ComponentEx {
    * @param handler - The handler to register.
    */
   registerEditorMenuEventHandler(handler) {
+    this.ensureLoaded();
     this.registerEvent(this.app.workspace.on("editor-menu", handler));
   }
   /**
@@ -154,6 +155,7 @@ class MenuEventRegistrarComponent extends import_component_ex.ComponentEx {
    * @param handler - The handler to register.
    */
   registerFileMenuEventHandler(handler) {
+    this.ensureLoaded();
     this.registerEvent(this.app.workspace.on("file-menu", handler));
   }
   /**
@@ -162,6 +164,7 @@ class MenuEventRegistrarComponent extends import_component_ex.ComponentEx {
    * @param handler - The handler to register.
    */
   registerFilesMenuEventHandler(handler) {
+    this.ensureLoaded();
     this.registerEvent(this.app.workspace.on("files-menu", handler));
   }
 }
@@ -169,4 +172,4 @@ class MenuEventRegistrarComponent extends import_component_ex.ComponentEx {
 0 && (module.exports = {
   MenuEventRegistrarComponent
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/components/monkey-around-component.cjs

@@ -142,6 +142,7 @@ class MonkeyAroundComponent extends import_component_ex.ComponentEx {
    * @param params - The parameters of the patch.
    */
   registerMethodPatch(params) {
+    this.ensureLoaded();
     if (params.patchToken) {
       const originalMethod = params.obj[params.methodName];
       getMonkeyAroundPatches().set(originalMethod, params.patchToken);
@@ -172,9 +173,7 @@ class MonkeyAroundComponent extends import_component_ex.ComponentEx {
    * @param factories - The factories to apply to the object.
    */
   registerPatch(obj, factories) {
-    if (!this._loaded) {
-      throw new Error("Cannot register patch on a component that is not loaded.");
-    }
+    this.ensureLoaded();
     const uninstaller = around(obj, factories);
     this.register(uninstaller);
   }
@@ -194,4 +193,4 @@ function getMonkeyAroundPatches() {
   around,
   hasPatchToken
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/monkey-around-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Improved type-safe wrapper of {@link https://www.npmjs.com/package/monkey-around} library.\n */\n\nimport type { ConditionalKeys } from 'type-fest';\n\nimport { around as originalAround } from 'monkey-around';\n\nimport type { GenericFunction } from '../../function.ts';\nimport type { GenericObject } from '../../type-guards.ts';\n\nimport { getObsidianDevUtilsState } from '../app.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * A type of the factories to apply to the object.\n *\n * @typeParam Obj - The object to patch.\n */\nexport type Factories<Obj extends object> = Partial<\n  {\n    [Key in ConditionalKeys<Obj, GenericFunction | undefined>]: WrapperFactory<Extract<Obj[Key], GenericFunction | undefined>>;\n  }\n>;\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.\n *\n * @typeParam Obj - The object to patch.\n * @typeParam MethodName - The method name to patch.\n */\nexport interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The method name to patch.\n   */\n  readonly methodName: MethodName;\n\n  /**\n   * The object to patch.\n   */\n  readonly obj: Obj;\n\n  /**\n   * The patch handler function.\n   */\n  readonly patchHandler: PatchHandlerFn<Obj, MethodName>;\n\n  /**\n   * An optional token to identify the patch.\n   */\n  readonly patchToken?: symbol;\n}\n\n/**\n * A patch handler function that intercepts calls to a method on an object.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam K - The method name being patched.\n */\nexport type PatchHandlerFn<Obj extends object, K extends MethodKeys<Obj>> = (\n  params: PatchHandlerParams<Obj, K>\n) => ReturnType<Extract<Obj[K], GenericFunction>>;\n\n/**\n * Parameters passed to a {@link PatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam K - The method name being patched.\n */\nexport interface PatchHandlerParams<Obj extends object, K extends MethodKeys<Obj>> {\n  fallback(this: void): ReturnType<Extract<Obj[K], GenericFunction>>;\n\n  /**\n   * The original arguments of the intercepted call, as a tuple.\n   */\n  readonly originalArgs: Parameters<Extract<Obj[K], GenericFunction>>;\n\n  /**\n   * The original (unpatched) function. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: Extract<Obj[K], GenericFunction>;\n\n  readonly originalMethodBound: OmitThisParameter<Extract<Obj[K], GenericFunction>>;\n\n  /**\n   * The original `this` context of the intercepted call.\n   */\n  readonly originalThis: Obj;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type as a generic restriction.\ntype MethodKeys<Obj extends object> = ConditionalKeys<Obj, Function | undefined> & keyof Obj;\n\ntype OriginalFactories<Obj extends GenericObject> = Parameters<typeof originalAround<Obj>>[1];\n\ntype Uninstaller = () => void;\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type as a generic restriction.\ntype WrapperFactory<T extends Function | undefined> = (next: T) => T;\n\n/**\n * A component that manages monkey-patches with lifecycle-bound cleanup.\n * All patches registered via this component are automatically uninstalled when the component unloads.\n */\nexport class MonkeyAroundComponent extends ComponentEx {\n  /**\n   * Registers a single-method patch using a simplified handler.\n   *\n   * @typeParam Obj - The object to patch.\n   * @typeParam MethodName - The method name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerMethodPatch<Obj extends object, const MethodName extends MethodKeys<Obj>>(\n    params: MonkeyAroundComponentRegisterMethodPatchParams<Obj, MethodName>\n  ): void {\n    if (params.patchToken) {\n      const originalMethod = params.obj[params.methodName] as GenericFunction;\n      getMonkeyAroundPatches().set(originalMethod, params.patchToken);\n    }\n\n    type RawFn = Extract<Obj[MethodName], GenericFunction>;\n    type Fn = GenericFunction<Parameters<RawFn>, ReturnType<RawFn>>;\n    this.registerPatch(params.obj, {\n      [params.methodName]: (originalMethod: Fn): Fn => {\n        return patchedMethod;\n        function patchedMethod(this: Obj, ...originalArgs: Parameters<RawFn>): ReturnType<RawFn> {\n          // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias -- We need to use the `this` context.\n          const originalThis = this;\n          return params.patchHandler({\n            fallback() {\n              return originalMethod.call(originalThis, ...originalArgs);\n            },\n            originalArgs,\n            originalMethod: originalMethod as RawFn,\n            originalMethodBound: originalMethod.bind(originalThis) as OmitThisParameter<RawFn>,\n            originalThis\n          });\n        }\n      }\n    } as Factories<Obj>);\n  }\n\n  /**\n   * Registers a patch using raw factories (advanced API).\n   *\n   * @typeParam Obj - The object to patch.\n   * @param obj - The object to patch.\n   * @param factories - The factories to apply to the object.\n   */\n  public registerPatch<Obj extends object>(obj: Obj, factories: Factories<Obj>): void {\n    if (!this._loaded) {\n      throw new Error('Cannot register patch on a component that is not loaded.');\n    }\n\n    const uninstaller = around(obj, factories);\n    this.register(uninstaller);\n  }\n}\n\n/**\n * Applies a patch to the object.\n * Better strongly-typed version of `monkey-around`.\n *\n * @typeParam Obj - The object to patch.\n * @param obj - The object to patch.\n * @param factories - The factories to apply to the object.\n * @returns The uninstaller that removes the patch when called.\n */\nexport function around<Obj extends object>(obj: Obj, factories: Factories<Obj>): Uninstaller {\n  return originalAround(obj as GenericObject, factories as OriginalFactories<GenericObject>);\n}\n\n/**\n * Checks if a function has a specific patch token.\n *\n * @param fn - The function to check.\n * @param patchToken - The patch token to check for.\n * @returns Whether the function has the patch token.\n */\nexport function hasPatchToken(fn: GenericFunction, patchToken: symbol): boolean {\n  return getMonkeyAroundPatches().get(fn) === patchToken;\n}\n\nfunction getMonkeyAroundPatches(): WeakMap<GenericFunction, symbol> {\n  return getObsidianDevUtilsState(null, 'monkeyAroundPatches', new WeakMap<GenericFunction, symbol>()).value;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,2BAAyC;AAKzC,iBAAyC;AACzC,0BAA4B;AA4FrB,MAAM,8BAA8B,gCAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,oBACL,QACM;AACN,QAAI,OAAO,YAAY;AACrB,YAAM,iBAAiB,OAAO,IAAI,OAAO,UAAU;AACnD,6BAAuB,EAAE,IAAI,gBAAgB,OAAO,UAAU;AAAA,IAChE;AAIA,SAAK,cAAc,OAAO,KAAK;AAAA,MAC7B,CAAC,OAAO,UAAU,GAAG,CAAC,mBAA2B;AAC/C,eAAO;AACP,iBAAS,iBAA4B,cAAoD;AAEvF,gBAAM,eAAe;AACrB,iBAAO,OAAO,aAAa;AAAA,YACzB,WAAW;AACT,qBAAO,eAAe,KAAK,cAAc,GAAG,YAAY;AAAA,YAC1D;AAAA,YACA;AAAA,YACA;AAAA,YACA,qBAAqB,eAAe,KAAK,YAAY;AAAA,YACrD;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAmB;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,cAAkC,KAAU,WAAiC;AAClF,QAAI,CAAC,KAAK,SAAS;AACjB,YAAM,IAAI,MAAM,0DAA0D;AAAA,IAC5E;AAEA,UAAM,cAAc,OAAO,KAAK,SAAS;AACzC,SAAK,SAAS,WAAW;AAAA,EAC3B;AACF;AAWO,SAAS,OAA2B,KAAU,WAAwC;AAC3F,aAAO,qBAAAA,QAAe,KAAsB,SAA6C;AAC3F;AASO,SAAS,cAAc,IAAqB,YAA6B;AAC9E,SAAO,uBAAuB,EAAE,IAAI,EAAE,MAAM;AAC9C;AAEA,SAAS,yBAA2D;AAClE,aAAO,qCAAyB,MAAM,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AACvG;",
  "names": ["originalAround"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/monkey-around-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Improved type-safe wrapper of {@link https://www.npmjs.com/package/monkey-around} library.\n */\n\nimport type { ConditionalKeys } from 'type-fest';\n\nimport { around as originalAround } from 'monkey-around';\n\nimport type { GenericFunction } from '../../function.ts';\nimport type { GenericObject } from '../../type-guards.ts';\n\nimport { getObsidianDevUtilsState } from '../app.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * A type of the factories to apply to the object.\n *\n * @typeParam Obj - The object to patch.\n */\nexport type Factories<Obj extends object> = Partial<\n  {\n    [Key in ConditionalKeys<Obj, GenericFunction | undefined>]: WrapperFactory<Extract<Obj[Key], GenericFunction | undefined>>;\n  }\n>;\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.\n *\n * @typeParam Obj - The object to patch.\n * @typeParam MethodName - The method name to patch.\n */\nexport interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The method name to patch.\n   */\n  readonly methodName: MethodName;\n\n  /**\n   * The object to patch.\n   */\n  readonly obj: Obj;\n\n  /**\n   * The patch handler function.\n   */\n  readonly patchHandler: PatchHandlerFn<Obj, MethodName>;\n\n  /**\n   * An optional token to identify the patch.\n   */\n  readonly patchToken?: symbol;\n}\n\n/**\n * A patch handler function that intercepts calls to a method on an object.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam K - The method name being patched.\n */\nexport type PatchHandlerFn<Obj extends object, K extends MethodKeys<Obj>> = (\n  params: PatchHandlerParams<Obj, K>\n) => ReturnType<Extract<Obj[K], GenericFunction>>;\n\n/**\n * Parameters passed to a {@link PatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam K - The method name being patched.\n */\nexport interface PatchHandlerParams<Obj extends object, K extends MethodKeys<Obj>> {\n  fallback(this: void): ReturnType<Extract<Obj[K], GenericFunction>>;\n\n  /**\n   * The original arguments of the intercepted call, as a tuple.\n   */\n  readonly originalArgs: Parameters<Extract<Obj[K], GenericFunction>>;\n\n  /**\n   * The original (unpatched) function. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: Extract<Obj[K], GenericFunction>;\n\n  readonly originalMethodBound: OmitThisParameter<Extract<Obj[K], GenericFunction>>;\n\n  /**\n   * The original `this` context of the intercepted call.\n   */\n  readonly originalThis: Obj;\n}\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type as a generic restriction.\ntype MethodKeys<Obj extends object> = ConditionalKeys<Obj, Function | undefined> & keyof Obj;\n\ntype OriginalFactories<Obj extends GenericObject> = Parameters<typeof originalAround<Obj>>[1];\n\ntype Uninstaller = () => void;\n\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type -- We need to use `Function` type as a generic restriction.\ntype WrapperFactory<T extends Function | undefined> = (next: T) => T;\n\n/**\n * A component that manages monkey-patches with lifecycle-bound cleanup.\n * All patches registered via this component are automatically uninstalled when the component unloads.\n */\nexport class MonkeyAroundComponent extends ComponentEx {\n  /**\n   * Registers a single-method patch using a simplified handler.\n   *\n   * @typeParam Obj - The object to patch.\n   * @typeParam MethodName - The method name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerMethodPatch<Obj extends object, const MethodName extends MethodKeys<Obj>>(\n    params: MonkeyAroundComponentRegisterMethodPatchParams<Obj, MethodName>\n  ): void {\n    this.ensureLoaded();\n\n    if (params.patchToken) {\n      const originalMethod = params.obj[params.methodName] as GenericFunction;\n      getMonkeyAroundPatches().set(originalMethod, params.patchToken);\n    }\n\n    type RawFn = Extract<Obj[MethodName], GenericFunction>;\n    type Fn = GenericFunction<Parameters<RawFn>, ReturnType<RawFn>>;\n    this.registerPatch(params.obj, {\n      [params.methodName]: (originalMethod: Fn): Fn => {\n        return patchedMethod;\n        function patchedMethod(this: Obj, ...originalArgs: Parameters<RawFn>): ReturnType<RawFn> {\n          // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias -- We need to use the `this` context.\n          const originalThis = this;\n          return params.patchHandler({\n            fallback() {\n              return originalMethod.call(originalThis, ...originalArgs);\n            },\n            originalArgs,\n            originalMethod: originalMethod as RawFn,\n            originalMethodBound: originalMethod.bind(originalThis) as OmitThisParameter<RawFn>,\n            originalThis\n          });\n        }\n      }\n    } as Factories<Obj>);\n  }\n\n  /**\n   * Registers a patch using raw factories (advanced API).\n   *\n   * @typeParam Obj - The object to patch.\n   * @param obj - The object to patch.\n   * @param factories - The factories to apply to the object.\n   */\n  public registerPatch<Obj extends object>(obj: Obj, factories: Factories<Obj>): void {\n    this.ensureLoaded();\n\n    const uninstaller = around(obj, factories);\n    this.register(uninstaller);\n  }\n}\n\n/**\n * Applies a patch to the object.\n * Better strongly-typed version of `monkey-around`.\n *\n * @typeParam Obj - The object to patch.\n * @param obj - The object to patch.\n * @param factories - The factories to apply to the object.\n * @returns The uninstaller that removes the patch when called.\n */\nexport function around<Obj extends object>(obj: Obj, factories: Factories<Obj>): Uninstaller {\n  return originalAround(obj as GenericObject, factories as OriginalFactories<GenericObject>);\n}\n\n/**\n * Checks if a function has a specific patch token.\n *\n * @param fn - The function to check.\n * @param patchToken - The patch token to check for.\n * @returns Whether the function has the patch token.\n */\nexport function hasPatchToken(fn: GenericFunction, patchToken: symbol): boolean {\n  return getMonkeyAroundPatches().get(fn) === patchToken;\n}\n\nfunction getMonkeyAroundPatches(): WeakMap<GenericFunction, symbol> {\n  return getObsidianDevUtilsState(null, 'monkeyAroundPatches', new WeakMap<GenericFunction, symbol>()).value;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,2BAAyC;AAKzC,iBAAyC;AACzC,0BAA4B;AA4FrB,MAAM,8BAA8B,gCAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,oBACL,QACM;AACN,SAAK,aAAa;AAElB,QAAI,OAAO,YAAY;AACrB,YAAM,iBAAiB,OAAO,IAAI,OAAO,UAAU;AACnD,6BAAuB,EAAE,IAAI,gBAAgB,OAAO,UAAU;AAAA,IAChE;AAIA,SAAK,cAAc,OAAO,KAAK;AAAA,MAC7B,CAAC,OAAO,UAAU,GAAG,CAAC,mBAA2B;AAC/C,eAAO;AACP,iBAAS,iBAA4B,cAAoD;AAEvF,gBAAM,eAAe;AACrB,iBAAO,OAAO,aAAa;AAAA,YACzB,WAAW;AACT,qBAAO,eAAe,KAAK,cAAc,GAAG,YAAY;AAAA,YAC1D;AAAA,YACA;AAAA,YACA;AAAA,YACA,qBAAqB,eAAe,KAAK,YAAY;AAAA,YACrD;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAmB;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,cAAkC,KAAU,WAAiC;AAClF,SAAK,aAAa;AAElB,UAAM,cAAc,OAAO,KAAK,SAAS;AACzC,SAAK,SAAS,WAAW;AAAA,EAC3B;AACF;AAWO,SAAS,OAA2B,KAAU,WAAwC;AAC3F,aAAO,qBAAAA,QAAe,KAAsB,SAA6C;AAC3F;AASO,SAAS,cAAc,IAAqB,YAA6B;AAC9E,SAAO,uBAAuB,EAAE,IAAI,EAAE,MAAM;AAC9C;AAEA,SAAS,yBAA2D;AAClE,aAAO,qCAAyB,MAAM,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AACvG;",
  "names": ["originalAround"]
}


package/dist/lib/cjs/obsidian/components/plugin-notice-component.cjs

@@ -142,15 +142,20 @@ class PluginNoticeComponent extends import_component_ex.ComponentEx {
   }
   pluginName;
   notice;
+  /**
+   * Hides the current notice on unload.
+   */
+  onunload() {
+    this.notice?.hide();
+  }
   /**
    * Displays a notice message to the user.
    *
    * @param message - The message to display.
    */
   showNotice(message) {
-    if (this.notice) {
-      this.notice.hide();
-    }
+    this.ensureLoaded();
+    this.notice?.hide();
     this.notice = new import_obsidian.Notice(`${this.pluginName}
 ${message}`);
   }
@@ -159,4 +164,4 @@ ${message}`);
 0 && (module.exports = {
   PluginNoticeComponent
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/components/plugin-notice-component.d.cts

@@ -17,6 +17,10 @@ export declare class PluginNoticeComponent extends ComponentEx {
      * @param pluginName - The plugin name (shown as prefix in notices).
      */
     constructor(pluginName: string);
+    /**
+     * Hides the current notice on unload.
+     */
+    onunload(): void;
     /**
      * Displays a notice message to the user.
      *