obsidian-dev-utils 69.2.3 → 70.0.0

package/dist/lib/esm/obsidian/components/abort-signal-component.mjs

@@ -33,13 +33,17 @@ class AbortSignalComponent extends ComponentEx {
     super();
     this.pluginId = pluginId;
     this.abortController = new AbortController();
-    this.abortSignal = this.abortController.signal;
   }
   pluginId;
   /**
    * The abort signal.
+   *
+   * @returns The {@link AbortSignal} that is aborted when the component is unloaded.
    */
-  abortSignal;
+  get abortSignal() {
+    this.ensureLoaded();
+    return this.abortController.signal;
+  }
   abortController;
   /**
    * Aborts the signal on unload.
@@ -51,4 +55,4 @@ class AbortSignalComponent extends ComponentEx {
 export {
   AbortSignalComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -23,6 +23,7 @@ if you want to view the source, please visit the github repository of this plugi
 
 import { getAllDomWindows } from "../workspace.mjs";
 import { ComponentEx } from "./component-ex.mjs";
+import { CallbackLayoutReadyComponent } from "./layout-ready-component.mjs";
 class AllWindowsEventComponent extends ComponentEx {
   /**
    * Creates a new instance of the `AllWindowsEventComponent` class.
@@ -43,6 +44,7 @@ class AllWindowsEventComponent extends ComponentEx {
    * @param options - The options for the event.
    */
   registerAllDocumentsDomEvent(type, callback, options) {
+    this.ensureLoaded();
     this.registerAllWindowsHandler((win) => {
       this.registerDomEvent(win.document, type, callback, options);
     });
@@ -56,6 +58,7 @@ class AllWindowsEventComponent extends ComponentEx {
    * @param options - The options for the event.
    */
   registerAllWindowsDomEvent(type, callback, options) {
+    this.ensureLoaded();
     this.registerAllWindowsHandler((win) => {
       this.registerDomEvent(win, type, callback, options);
     });
@@ -66,28 +69,25 @@ class AllWindowsEventComponent extends ComponentEx {
    * @param allWindowsHandler - The handler called for each window (main + popups).
    */
   registerAllWindowsHandler(allWindowsHandler) {
+    this.ensureLoaded();
     const mainWindow = activeWindow;
-    if (this._loaded) {
-      allWindowsHandler(mainWindow);
-    }
-    this.app.workspace.onLayoutReady(() => {
-      for (const win of getAllDomWindows(this.app)) {
-        if (win === mainWindow) {
-          continue;
-        }
-        if (this._loaded) {
+    allWindowsHandler(mainWindow);
+    this.addChild(
+      new CallbackLayoutReadyComponent(this.app, () => {
+        for (const win of getAllDomWindows(this.app)) {
+          if (win === mainWindow) {
+            continue;
+          }
           allWindowsHandler(win);
         }
-      }
-      this.registerEvent(this.app.workspace.on("window-open", (workspaceWindow) => {
-        if (this._loaded) {
+        this.registerEvent(this.app.workspace.on("window-open", (workspaceWindow) => {
           allWindowsHandler(workspaceWindow.win);
-        }
-      }));
-    });
+        }));
+      })
+    );
   }
 }
 export {
   AllWindowsEventComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/components/async-error-handler-component.d.mts

@@ -10,13 +10,13 @@ import { PluginNoticeComponent } from './plugin-notice-component.mjs';
  * Registers a global async error handler that shows a notice to the user.
  */
 export declare class AsyncErrorHandlerComponent extends ComponentEx {
-    private readonly noticeComponent;
+    private readonly pluginNoticeComponent;
     /**
      * Creates a new async error handler component.
      *
-     * @param noticeComponent - The notice component used to display error messages.
+     * @param pluginNoticeComponent - The notice component used to display error messages.
      */
-    constructor(noticeComponent: PluginNoticeComponent);
+    constructor(pluginNoticeComponent: PluginNoticeComponent);
     /**
      * Registers the error handler.
      */

package/dist/lib/esm/obsidian/components/async-error-handler-component.mjs

@@ -29,13 +29,13 @@ class AsyncErrorHandlerComponent extends ComponentEx {
   /**
    * Creates a new async error handler component.
    *
-   * @param noticeComponent - The notice component used to display error messages.
+   * @param pluginNoticeComponent - The notice component used to display error messages.
    */
-  constructor(noticeComponent) {
+  constructor(pluginNoticeComponent) {
     super();
-    this.noticeComponent = noticeComponent;
+    this.pluginNoticeComponent = pluginNoticeComponent;
   }
-  noticeComponent;
+  pluginNoticeComponent;
   /**
    * Registers the error handler.
    */
@@ -48,10 +48,10 @@ class AsyncErrorHandlerComponent extends ComponentEx {
    * @param _asyncError - The async error.
    */
   handleAsyncError(_asyncError) {
-    this.noticeComponent.showNotice(t(($) => $.obsidianDevUtils.notices.unhandledError));
+    this.pluginNoticeComponent.showNotice(t(($) => $.obsidianDevUtils.notices.unhandledError));
   }
 }
 export {
   AsyncErrorHandlerComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -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/esm/obsidian/components/component-ex.mjs

@@ -22,14 +22,22 @@ if you want to view the source, please visit the github repository of this plugi
 })();
 
 import { Component } from "obsidian";
-import { chain } from "../../async.mjs";
-import { noopAsyncSingletonPromise } from "../../function.mjs";
+import { ErrorWrapper } from "../../error.mjs";
+import {
+  noop,
+  noopAsyncSingletonPromise
+} from "../../function.mjs";
 class ComponentEx extends 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.
@@ -38,27 +46,28 @@ class ComponentEx extends Component {
     this._children.push(component);
     this.childrenSet.add(component);
     if (this._loaded) {
-      this.loadPromise = 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 !== noopAsyncSingletonPromise) {
-      this.loadPromise = chain(this.loadPromise, () => onloadAsyncPromise);
+      this.appendEagerLoadStep(onloadAsyncPromise);
     }
     for (const child of this._children.slice()) {
-      this.loadPromise = chain(this.loadPromise, () => this.extractLoadPromisable(child));
+      this.appendSequentialLoadStep(() => this.extractLoadPromisable(child));
     }
     if (this.loadPromise) {
       return this.loadPromise;
@@ -67,11 +76,26 @@ class ComponentEx extends 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.
@@ -101,6 +125,94 @@ class ComponentEx extends 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(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(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;
@@ -110,8 +222,32 @@ class ComponentEx extends 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;
+  }
 }
 export {
   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/esm/obsidian/components/console-debug-component.d.mts

@@ -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/esm/obsidian/components/console-debug-component.mjs

@@ -40,7 +40,8 @@ class ConsoleDebugComponent extends 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 = getDebugger(this.pluginId, FRAMES_TO_SKIP);
     pluginDebugger(message, ...args);
@@ -49,4 +50,4 @@ class ConsoleDebugComponent extends ComponentEx {
 export {
   ConsoleDebugComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -39,6 +39,7 @@ class MenuEventRegistrarComponent extends ComponentEx {
    * @param handler - The handler to register.
    */
   registerEditorMenuEventHandler(handler) {
+    this.ensureLoaded();
     this.registerEvent(this.app.workspace.on("editor-menu", handler));
   }
   /**
@@ -47,6 +48,7 @@ class MenuEventRegistrarComponent extends ComponentEx {
    * @param handler - The handler to register.
    */
   registerFileMenuEventHandler(handler) {
+    this.ensureLoaded();
     this.registerEvent(this.app.workspace.on("file-menu", handler));
   }
   /**
@@ -55,10 +57,11 @@ class MenuEventRegistrarComponent extends ComponentEx {
    * @param handler - The handler to register.
    */
   registerFilesMenuEventHandler(handler) {
+    this.ensureLoaded();
     this.registerEvent(this.app.workspace.on("files-menu", handler));
   }
 }
 export {
   MenuEventRegistrarComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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