@mnaoumov/obsidian-lib 10.11.0 → 11.0.0

package/dist/lib/esm/components/all-windows-status-bar-item-component.d.mts

@@ -0,0 +1,146 @@
+/// <reference path="../library-references.d.mts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, and
+ * removes only its own items when a window closes or the component unloads.
+ *
+ * Read from Obsidian `1.15.1`: the main window builds `body > .app-container > .status-bar`, and
+ * `Plugin.addStatusBarItem` is a `.status-bar-item` created in it. A popout builds `body > .app-container` with the
+ * workspace only, and **no status bar**. `app.css` styles `.status-bar` without scoping it to a window, so a
+ * `.status-bar` created inside a popout's `.app-container` looks and sits exactly like the main one. By default
+ * this component creates that bar in a popout that lacks one, and marks it with
+ * {@link WINDOW_STATUS_BAR_CSS_CLASS}. The marker is a wire constant shared by every copy of this library: any copy
+ * reuses a marked bar, and whichever copy removes the last item from it removes the bar too.
+ *
+ * Mobile has no popouts, and `app.css` hides `.status-bar` under `.is-mobile`, so on mobile the component creates
+ * nothing and never calls the render callback.
+ */
+import type { App, Component } from 'obsidian';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * The class that marks a status bar this library created in a window that had none.
+ * Other copies of the library match it, so its value must never change.
+ */
+export declare const WINDOW_STATUS_BAR_CSS_CLASS = "obsidian-lib-window-status-bar";
+/**
+ * Parameters for the {@link AllWindowsStatusBarItemComponent} constructor.
+ */
+export interface AllWindowsStatusBarItemComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * Extra CSS classes for each item.
+     */
+    readonly cls?: readonly string[];
+    /**
+     * The plugin id. When given, each item gets the `plugin-<id>` class that `Plugin.addStatusBarItem` adds, so
+     * themes and CSS snippets that target the plugin's status-bar items match these too.
+     */
+    readonly pluginId?: string;
+    /**
+     * Renders the item of one window. Called when the item is created and again by
+     * {@link AllWindowsStatusBarItemComponent.refresh}, so it must be safe to call repeatedly on the same element.
+     *
+     * @param params - The item and its window.
+     */
+    readonly render: (params: AllWindowsStatusBarItemRenderParams) => void;
+    /**
+     * Whether to create a status bar in a window that has none, as every popout in Obsidian `1.15.1` does.
+     * When `false`, such a window gets no item. Defaults to `true`.
+     */
+    readonly shouldCreateMissingStatusBar?: boolean;
+}
+/**
+ * Parameters passed to {@link AllWindowsStatusBarItemComponentConstructorParams.render}.
+ */
+export interface AllWindowsStatusBarItemRenderParams {
+    /**
+     * The status-bar item owned by this component in {@link win}.
+     */
+    readonly el: HTMLElement;
+    /**
+     * The window the item is in. Use its document for anything the render creates outside the item.
+     */
+    readonly win: Window;
+}
+/**
+ * Parameters for {@link registerAllWindowsStatusBarItem}.
+ */
+export interface RegisterAllWindowsStatusBarItemParams extends AllWindowsStatusBarItemComponentConstructorParams {
+    /**
+     * The component that owns the items: they are removed when it unloads.
+     */
+    readonly component: Component;
+}
+/**
+ * Shows one status-bar item in the main window and in every desktop popout while loaded.
+ */
+export declare class AllWindowsStatusBarItemComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The CSS classes added to each item.
+     */
+    protected readonly itemClasses: readonly string[];
+    /**
+     * Renders the item of one window.
+     */
+    protected readonly renderItem: (params: AllWindowsStatusBarItemRenderParams) => void;
+    /**
+     * Whether a status bar is created in a window that has none.
+     */
+    protected readonly shouldCreateMissingStatusBar: boolean;
+    private readonly itemElsByWindow;
+    /**
+     * Creates a new instance of the `AllWindowsStatusBarItemComponent` class.
+     *
+     * @param params - The {@link AllWindowsStatusBarItemComponentConstructorParams}.
+     */
+    constructor(params: AllWindowsStatusBarItemComponentConstructorParams);
+    /**
+     * Gets the item of a window.
+     *
+     * @param win - The window.
+     * @returns The item, or `null` when the window has none.
+     */
+    getItemEl(win: Window): HTMLElement | null;
+    /**
+     * Gets the items of every window that has one.
+     *
+     * @returns The items.
+     */
+    getItemEls(): HTMLElement[];
+    /**
+     * Creates the item in every window, now and as popouts open. A no-op on mobile.
+     */
+    onload(): void;
+    /**
+     * Renders the item of every window again.
+     */
+    refresh(): void;
+    private attach;
+    private findOrCreateStatusBar;
+}
+/**
+ * Gets the class `Plugin.addStatusBarItem` adds to a plugin's status-bar items.
+ * It copies Obsidian `1.15.1` exactly, including that only the first disallowed character is replaced.
+ *
+ * @param pluginId - The plugin id.
+ * @returns The CSS class.
+ */
+export declare function getPluginStatusBarItemCssClass(pluginId: string): string;
+/**
+ * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, until
+ * the owning component unloads.
+ *
+ * @param params - The {@link RegisterAllWindowsStatusBarItemParams}. The owner must be loaded.
+ * @returns The {@link AllWindowsStatusBarItemComponent}. Call its {@link AllWindowsStatusBarItemComponent.refresh} to
+ *   render every item again, or remove it from the owner to stop early.
+ */
+export declare function registerAllWindowsStatusBarItem(params: RegisterAllWindowsStatusBarItemParams): AllWindowsStatusBarItemComponent;

package/dist/lib/esm/components/all-windows-status-bar-item-component.mjs

@@ -0,0 +1,154 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { Platform } from "obsidian";
+import { AllWindowsEventComponent } from "./all-windows-event-component.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+const WINDOW_STATUS_BAR_CSS_CLASS = "obsidian-lib-window-status-bar";
+const APP_CONTAINER_CSS_CLASS = "app-container";
+const STATUS_BAR_CSS_CLASS = "status-bar";
+const STATUS_BAR_ITEM_CSS_CLASS = "status-bar-item";
+class AllWindowsStatusBarItemComponent extends ComponentEx {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * The CSS classes added to each item.
+   */
+  itemClasses;
+  /**
+   * Renders the item of one window.
+   */
+  renderItem;
+  /**
+   * Whether a status bar is created in a window that has none.
+   */
+  shouldCreateMissingStatusBar;
+  itemElsByWindow = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new instance of the `AllWindowsStatusBarItemComponent` class.
+   *
+   * @param params - The {@link AllWindowsStatusBarItemComponentConstructorParams}.
+   */
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.renderItem = params.render;
+    this.shouldCreateMissingStatusBar = params.shouldCreateMissingStatusBar ?? true;
+    this.itemClasses = [
+      STATUS_BAR_ITEM_CSS_CLASS,
+      ...params.pluginId === void 0 ? [] : [getPluginStatusBarItemCssClass(params.pluginId)],
+      ...params.cls ?? []
+    ];
+  }
+  /**
+   * Gets the item of a window.
+   *
+   * @param win - The window.
+   * @returns The item, or `null` when the window has none.
+   */
+  getItemEl(win) {
+    return this.itemElsByWindow.get(win) ?? null;
+  }
+  /**
+   * Gets the items of every window that has one.
+   *
+   * @returns The items.
+   */
+  getItemEls() {
+    return [...this.itemElsByWindow.values()];
+  }
+  /**
+   * Creates the item in every window, now and as popouts open. A no-op on mobile.
+   */
+  onload() {
+    super.onload();
+    if (Platform.isMobile) {
+      return;
+    }
+    const allWindowsEventComponent = this.addChild(new AllWindowsEventComponent(this.app));
+    allWindowsEventComponent.registerAllWindowsHandler((win) => this.attach(win));
+  }
+  /**
+   * Renders the item of every window again.
+   */
+  refresh() {
+    for (const [win, el] of this.itemElsByWindow) {
+      this.renderItem({ el, win });
+    }
+  }
+  attach(win) {
+    const statusBarEl = this.findOrCreateStatusBar(win.document);
+    if (!statusBarEl) {
+      return null;
+    }
+    const el = statusBarEl.createDiv({ cls: [...this.itemClasses] });
+    this.itemElsByWindow.set(win, el);
+    this.renderItem({ el, win });
+    return () => {
+      this.itemElsByWindow.delete(win);
+      el.remove();
+      if (statusBarEl.classList.contains(WINDOW_STATUS_BAR_CSS_CLASS) && !statusBarEl.querySelector(`:scope > .${STATUS_BAR_ITEM_CSS_CLASS}`)) {
+        statusBarEl.remove();
+      }
+    };
+  }
+  findOrCreateStatusBar(doc) {
+    const appContainerEl = doc.body.querySelector(`:scope > .${APP_CONTAINER_CSS_CLASS}`);
+    if (!appContainerEl) {
+      return null;
+    }
+    const statusBarEl = appContainerEl.querySelector(`:scope > .${STATUS_BAR_CSS_CLASS}`);
+    if (statusBarEl) {
+      return statusBarEl;
+    }
+    if (!this.shouldCreateMissingStatusBar) {
+      return null;
+    }
+    return appContainerEl.createDiv({ cls: [STATUS_BAR_CSS_CLASS, WINDOW_STATUS_BAR_CSS_CLASS] });
+  }
+}
+function getPluginStatusBarItemCssClass(pluginId) {
+  return `plugin-${pluginId.toLowerCase().replace(/[^_a-zA-Z0-9-]/, "-")}`;
+}
+function registerAllWindowsStatusBarItem(params) {
+  const { component, ...constructorParams } = params;
+  return component.addChild(new AllWindowsStatusBarItemComponent(constructorParams));
+}
+export {
+  AllWindowsStatusBarItemComponent,
+  WINDOW_STATUS_BAR_CSS_CLASS,
+  getPluginStatusBarItemCssClass,
+  registerAllWindowsStatusBarItem
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/all-windows-status-bar-item-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, and\n * removes only its own items when a window closes or the component unloads.\n *\n * Read from Obsidian `1.15.1`: the main window builds `body > .app-container > .status-bar`, and\n * `Plugin.addStatusBarItem` is a `.status-bar-item` created in it. A popout builds `body > .app-container` with the\n * workspace only, and **no status bar**. `app.css` styles `.status-bar` without scoping it to a window, so a\n * `.status-bar` created inside a popout's `.app-container` looks and sits exactly like the main one. By default\n * this component creates that bar in a popout that lacks one, and marks it with\n * {@link WINDOW_STATUS_BAR_CSS_CLASS}. The marker is a wire constant shared by every copy of this library: any copy\n * reuses a marked bar, and whichever copy removes the last item from it removes the bar too.\n *\n * Mobile has no popouts, and `app.css` hides `.status-bar` under `.is-mobile`, so on mobile the component creates\n * nothing and never calls the render callback.\n */\n\nimport type {\n  App,\n  Component\n} from 'obsidian';\n\nimport { Platform } from 'obsidian';\n\nimport { AllWindowsEventComponent } from './all-windows-event-component.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * The class that marks a status bar this library created in a window that had none.\n * Other copies of the library match it, so its value must never change.\n */\nexport const WINDOW_STATUS_BAR_CSS_CLASS = 'obsidian-lib-window-status-bar';\n\nconst APP_CONTAINER_CSS_CLASS = 'app-container';\nconst STATUS_BAR_CSS_CLASS = 'status-bar';\nconst STATUS_BAR_ITEM_CSS_CLASS = 'status-bar-item';\n\n/**\n * Parameters for the {@link AllWindowsStatusBarItemComponent} constructor.\n */\nexport interface AllWindowsStatusBarItemComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Extra CSS classes for each item.\n   */\n  readonly cls?: readonly string[];\n\n  /**\n   * The plugin id. When given, each item gets the `plugin-<id>` class that `Plugin.addStatusBarItem` adds, so\n   * themes and CSS snippets that target the plugin's status-bar items match these too.\n   */\n  readonly pluginId?: string;\n\n  /**\n   * Renders the item of one window. Called when the item is created and again by\n   * {@link AllWindowsStatusBarItemComponent.refresh}, so it must be safe to call repeatedly on the same element.\n   *\n   * @param params - The item and its window.\n   */\n  readonly render: (params: AllWindowsStatusBarItemRenderParams) => void;\n\n  /**\n   * Whether to create a status bar in a window that has none, as every popout in Obsidian `1.15.1` does.\n   * When `false`, such a window gets no item. Defaults to `true`.\n   */\n  readonly shouldCreateMissingStatusBar?: boolean;\n}\n\n/**\n * Parameters passed to {@link AllWindowsStatusBarItemComponentConstructorParams.render}.\n */\nexport interface AllWindowsStatusBarItemRenderParams {\n  /**\n   * The status-bar item owned by this component in {@link win}.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The window the item is in. Use its document for anything the render creates outside the item.\n   */\n  readonly win: Window;\n}\n\n/**\n * Parameters for {@link registerAllWindowsStatusBarItem}.\n */\nexport interface RegisterAllWindowsStatusBarItemParams extends AllWindowsStatusBarItemComponentConstructorParams {\n  /**\n   * The component that owns the items: they are removed when it unloads.\n   */\n  readonly component: Component;\n}\n\n/**\n * Shows one status-bar item in the main window and in every desktop popout while loaded.\n */\nexport class AllWindowsStatusBarItemComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * The CSS classes added to each item.\n   */\n  protected readonly itemClasses: readonly string[];\n\n  /**\n   * Renders the item of one window.\n   */\n  protected readonly renderItem: (params: AllWindowsStatusBarItemRenderParams) => void;\n\n  /**\n   * Whether a status bar is created in a window that has none.\n   */\n  protected readonly shouldCreateMissingStatusBar: boolean;\n\n  private readonly itemElsByWindow = new Map<Window, HTMLElement>();\n\n  /**\n   * Creates a new instance of the `AllWindowsStatusBarItemComponent` class.\n   *\n   * @param params - The {@link AllWindowsStatusBarItemComponentConstructorParams}.\n   */\n  public constructor(params: AllWindowsStatusBarItemComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.renderItem = params.render;\n    this.shouldCreateMissingStatusBar = params.shouldCreateMissingStatusBar ?? true;\n    this.itemClasses = [\n      STATUS_BAR_ITEM_CSS_CLASS,\n      ...params.pluginId === undefined ? [] : [getPluginStatusBarItemCssClass(params.pluginId)],\n      ...params.cls ?? []\n    ];\n  }\n\n  /**\n   * Gets the item of a window.\n   *\n   * @param win - The window.\n   * @returns The item, or `null` when the window has none.\n   */\n  public getItemEl(win: Window): HTMLElement | null {\n    return this.itemElsByWindow.get(win) ?? null;\n  }\n\n  /**\n   * Gets the items of every window that has one.\n   *\n   * @returns The items.\n   */\n  public getItemEls(): HTMLElement[] {\n    return [...this.itemElsByWindow.values()];\n  }\n\n  /**\n   * Creates the item in every window, now and as popouts open. A no-op on mobile.\n   */\n  public override onload(): void {\n    super.onload();\n\n    if (Platform.isMobile) {\n      return;\n    }\n\n    const allWindowsEventComponent = this.addChild(new AllWindowsEventComponent(this.app));\n    allWindowsEventComponent.registerAllWindowsHandler((win) => this.attach(win));\n  }\n\n  /**\n   * Renders the item of every window again.\n   */\n  public refresh(): void {\n    for (const [win, el] of this.itemElsByWindow) {\n      this.renderItem({ el, win });\n    }\n  }\n\n  private attach(win: Window): (() => void) | null {\n    const statusBarEl = this.findOrCreateStatusBar(win.document);\n    if (!statusBarEl) {\n      return null;\n    }\n\n    const el = statusBarEl.createDiv({ cls: [...this.itemClasses] });\n    this.itemElsByWindow.set(win, el);\n    this.renderItem({ el, win });\n\n    return () => {\n      this.itemElsByWindow.delete(win);\n      el.remove();\n      if (statusBarEl.classList.contains(WINDOW_STATUS_BAR_CSS_CLASS) && !statusBarEl.querySelector(`:scope > .${STATUS_BAR_ITEM_CSS_CLASS}`)) {\n        statusBarEl.remove();\n      }\n    };\n  }\n\n  private findOrCreateStatusBar(doc: Document): HTMLElement | null {\n    const appContainerEl = doc.body.querySelector<HTMLElement>(`:scope > .${APP_CONTAINER_CSS_CLASS}`);\n    if (!appContainerEl) {\n      return null;\n    }\n\n    const statusBarEl = appContainerEl.querySelector<HTMLElement>(`:scope > .${STATUS_BAR_CSS_CLASS}`);\n    if (statusBarEl) {\n      return statusBarEl;\n    }\n\n    if (!this.shouldCreateMissingStatusBar) {\n      return null;\n    }\n\n    return appContainerEl.createDiv({ cls: [STATUS_BAR_CSS_CLASS, WINDOW_STATUS_BAR_CSS_CLASS] });\n  }\n}\n\n/**\n * Gets the class `Plugin.addStatusBarItem` adds to a plugin's status-bar items.\n * It copies Obsidian `1.15.1` exactly, including that only the first disallowed character is replaced.\n *\n * @param pluginId - The plugin id.\n * @returns The CSS class.\n */\nexport function getPluginStatusBarItemCssClass(pluginId: string): string {\n  return `plugin-${pluginId.toLowerCase().replace(/[^_a-zA-Z0-9-]/, '-')}`;\n}\n\n/**\n * Shows one status-bar item in the main window and in every desktop popout, including popouts opened later, until\n * the owning component unloads.\n *\n * @param params - The {@link RegisterAllWindowsStatusBarItemParams}. The owner must be loaded.\n * @returns The {@link AllWindowsStatusBarItemComponent}. Call its {@link AllWindowsStatusBarItemComponent.refresh} to\n *   render every item again, or remove it from the owner to stop early.\n */\nexport function registerAllWindowsStatusBarItem(params: RegisterAllWindowsStatusBarItemParams): AllWindowsStatusBarItemComponent {\n  const { component, ...constructorParams } = params;\n  return component.addChild(new AllWindowsStatusBarItemComponent(constructorParams));\n}\n"],"mappings":"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","names":[]}

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

@@ -72,6 +72,17 @@ export declare class ComponentEx extends Component implements Disposable {
      * @returns A {@link Promise} that resolves when the component is loaded.
      */
     onloadAsync(): Promise<void>;
+    /**
+     * Registers an {@link AsyncDisposable} so its disposal starts when this component unloads, and returns it unchanged.
+     *
+     * Obsidian's unload is synchronous, so nothing awaits the disposal: it runs detached, and a failure is reported, never
+     * rethrown. See the free function {@link registerAsyncDisposable}, which this delegates to.
+     *
+     * @typeParam TAsyncDisposable - The type of the async disposable.
+     * @param asyncDisposable - The async disposable to register.
+     * @returns The same async disposable, for chaining.
+     */
+    registerAsyncDisposable<TAsyncDisposable extends AsyncDisposable>(asyncDisposable: TAsyncDisposable): TAsyncDisposable;
     /**
      * Registers a {@link Disposable} so it is disposed when this component unloads, and returns it unchanged.
      *

package/dist/lib/esm/components/component-ex.mjs

@@ -38,7 +38,6 @@ ensureBrowserProcess();
 
 import { createAggregateError } from "@mnaoumov/typescript-lib/aggregate-error";
 import { snapshot } from "@mnaoumov/typescript-lib/array";
-import { dispose } from "@mnaoumov/typescript-lib/disposable";
 import {
   ErrorWrapper,
   SilentError
@@ -48,6 +47,10 @@ import {
   noopAsyncSingletonPromise
 } from "@mnaoumov/typescript-lib/function";
 import { Component } from "obsidian";
+import {
+  registerAsyncDisposable,
+  registerDisposable
+} from "../disposable.mjs";
 class ComponentEx extends Component {
   childrenSet = /* @__PURE__ */ new Set();
   hasBeenLoaded = false;
@@ -158,6 +161,19 @@ class ComponentEx extends Component {
   onloadAsync() {
     return noopAsyncSingletonPromise;
   }
+  /**
+   * Registers an {@link AsyncDisposable} so its disposal starts when this component unloads, and returns it unchanged.
+   *
+   * Obsidian's unload is synchronous, so nothing awaits the disposal: it runs detached, and a failure is reported, never
+   * rethrown. See the free function {@link registerAsyncDisposable}, which this delegates to.
+   *
+   * @typeParam TAsyncDisposable - The type of the async disposable.
+   * @param asyncDisposable - The async disposable to register.
+   * @returns The same async disposable, for chaining.
+   */
+  registerAsyncDisposable(asyncDisposable) {
+    return registerAsyncDisposable(this, asyncDisposable);
+  }
   /**
    * Registers a {@link Disposable} so it is disposed when this component unloads, and returns it unchanged.
    *
@@ -170,10 +186,7 @@ class ComponentEx extends Component {
    * @returns The same disposable, for chaining.
    */
   registerDisposable(disposable) {
-    this.register(() => {
-      dispose(disposable);
-    });
-    return disposable;
+    return registerDisposable(this, disposable);
   }
   /**
    * Removes a child component.
@@ -407,4 +420,4 @@ class ComponentEx extends Component {
 export {
   ComponentEx
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/component-ex.ts"],"sourcesContent":["/**\n * @file\n *\n * Extended Component\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { createAggregateError } from '@mnaoumov/typescript-lib/aggregate-error';\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\nimport { dispose } from '@mnaoumov/typescript-lib/disposable';\nimport {\n  ErrorWrapper,\n  SilentError\n} from '@mnaoumov/typescript-lib/error';\nimport {\n  noop,\n  noopAsyncSingletonPromise\n} from '@mnaoumov/typescript-lib/function';\nimport { Component } from 'obsidian';\n\n/**\n * Extended Component\n */\n// eslint-disable-next-line obsidian-dev-toolkit/require-component-suffix -- Extended base class.\nexport class ComponentEx extends Component implements Disposable {\n  private readonly childrenSet = new Set<Component>();\n  private hasBeenLoaded = false;\n  private loadErrors: Error[] = [];\n  private loadPromise: null | Promise<void> = null;\n  private parentComponent: ComponentEx | null = 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   * Adding a child BEFORE the first load is legitimate: the child is queued and loaded when this component loads.\n   * Adding one AFTER this component has been unloaded is not — the child would never be loaded and never unloaded\n   * (a leak), so it is refused with a {@link SilentError}. The typical source of such a call is an `async` method\n   * that was suspended on an `await` when the component got unloaded and then resumed on the dead component; the\n   * {@link SilentError} unwinds it quietly (see {@link isUnloaded}).\n   *\n   * @typeParam TComponent - The type of component to add.\n   * @param component - The component instance to add.\n   * @returns The added component.\n   * @throws A {@link SilentError} if the component has already been unloaded.\n   */\n  public override addChild<TComponent extends Component>(component: TComponent): TComponent {\n    if (this.isUnloaded()) {\n      throw new SilentError('Component is already unloaded');\n    }\n\n    this._children.push(component);\n    this.childrenSet.add(component);\n    if (component instanceof ComponentEx) {\n      component.parentComponent = this;\n    }\n\n    if (this._loaded) {\n      this.appendEagerLoadStep(this.extractLoadPromisable(component));\n    }\n\n    return component;\n  }\n\n  /**\n   * Checks whether a component is a direct child of this one.\n   *\n   * Only DIRECT children are reported — this is an ownership question, not a containment one. The caller that\n   * needs it is one holding several parents and deciding which of them a component belongs to, and for that a\n   * grandchild is the wrong answer: removing it from the parent that merely contains its parent would fail.\n   *\n   * @param component - The component to look for.\n   * @returns Whether the component is a direct child of this one.\n   */\n  public hasChild(component: Component): boolean {\n    return this.childrenSet.has(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.hasBeenLoaded = 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 snapshot(this._children)) {\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   * The `AggregateError` is built by {@link createAggregateError}, so its own `message` names the failure rather\n   * than being empty: a lone failure lends its message to every aggregate above it, which is what lets a caller\n   * assert on the sentence that was actually thrown without walking `errors` to find it.\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      return this.loadErrors.length > 0 ? Promise.reject(createAggregateError(this.loadErrors)) : null;\n    }\n\n    return loadPromise.then(() => {\n      if (this.loadErrors.length > 0) {\n        throw createAggregateError(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   * Registers a {@link Disposable} so it is disposed when this component unloads, and returns it unchanged.\n   *\n   * The recurring \"tie a disposable to the component's lifecycle, then keep using it\" idiom: the disposable is\n   * disposed on {@link Component.unload} (or earlier, if the caller disposes it directly — dispose is expected to\n   * be idempotent). Guard with {@link ensureLoaded} at the call site when registering before load would be unsafe.\n   *\n   * @typeParam TDisposable - The type of the disposable.\n   * @param disposable - The disposable to register.\n   * @returns The same disposable, for chaining.\n   */\n  public registerDisposable<TDisposable extends Disposable>(disposable: TDisposable): TDisposable {\n    this.register(() => {\n      dispose(disposable);\n    });\n    return disposable;\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    if (component instanceof ComponentEx && component.parentComponent === this) {\n      component.parentComponent = null;\n    }\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   * The two not-loaded cases are deliberately distinguished. A component that was NEVER loaded is a genuine\n   * programming error, so it throws a loud {@link Error}. A component that has ALREADY been unloaded is not —\n   * it is the expected outcome of work that outlived its component (e.g. an `async` method suspended on an\n   * `await` while the component was unloaded, then resumed) — so it throws a {@link SilentError}, which\n   * `handleSilentError` suppresses, letting such work unwind quietly instead of reporting an async error.\n   *\n   * @throws An {@link Error} if the component was never loaded, or a {@link SilentError} if it has already been unloaded.\n   */\n  protected ensureLoaded(): void {\n    if (this._loaded) {\n      return;\n    }\n\n    if (this.isUnloaded()) {\n      throw new SilentError('Component is already unloaded');\n    }\n\n    throw new Error('Component is not loaded');\n  }\n\n  /**\n   * Returns a {@link Promise} that settles once neither this component nor any {@link ComponentEx} ancestor has a load\n   * in flight, or `null` when none of them has one right now.\n   *\n   * {@link getInFlightLoadPromise} covers this component's OWN load only. A sibling this component depends on — most\n   * often the owning plugin's settings component, which reads `data.json` asynchronously — is outside it, but it is\n   * inside the load of a shared ancestor. Waiting for every ancestor therefore waits for the whole tree the component\n   * was loaded as part of: under `PluginBase` the chain ends at the plugin's universal wrapper, whose load covers the\n   * dependency gate, the feature surface and `onloadImpl`.\n   *\n   * The chain is followed through {@link ComponentEx} parents only. A plain {@link Component} anywhere between this\n   * component and an ancestor ends it, because a plain component records no parent and exposes no load promise.\n   *\n   * Never await this from inside a load step of one of those ancestors: the ancestor's load would then be waiting for\n   * itself. It is meant for work scheduled OUTSIDE the load, such as a layout-ready handler.\n   *\n   * @returns The promise, or `null` if nothing in the ancestry is loading.\n   */\n  protected getInFlightAncestryLoadPromise(): null | Promise<void> {\n    return this.findInFlightAncestryLoadPromise() ? this.waitForAncestryLoad() : null;\n  }\n\n  /**\n   * Returns the component's in-flight load {@link Promise} (its {@link onloadAsync} plus children), or `null` when\n   * nothing is loading — either the component loaded fully synchronously or its async load has already settled.\n   *\n   * Lets a caller scheduled while the component is still loading await the async load tail before acting, instead of\n   * racing it: {@link Component.onload} has run (so `_loaded` is set) but {@link onloadAsync} may not have finished.\n   *\n   * It covers this component's OWN load only. A caller that also depends on a sibling's state — a layout-ready handler\n   * reading settings is the common one — wants {@link getInFlightAncestryLoadPromise}, which `LayoutReadyComponent`\n   * uses.\n   *\n   * @returns The in-flight load promise, or `null` if no load is in flight.\n   */\n  protected getInFlightLoadPromise(): null | Promise<void> {\n    return this.loadPromise;\n  }\n\n  /**\n   * Returns whether the most recent load recorded any failure.\n   *\n   * Reflects the outcome of the last {@link load} / {@link loadWithPromises}: `true` when {@link onloadAsync} or any\n   * child's load threw (synchronously or asynchronously). Unlike {@link loadWithPromises}, reading this does NOT\n   * re-raise the collected errors — it lets a bystander (e.g. a layout-ready handler awaiting the in-flight load) tell\n   * whether the load succeeded without adopting a failure that the load's owner is already responsible for.\n   *\n   * @returns `true` if the last load recorded at least one error, otherwise `false`.\n   */\n  protected hasLoadErrors(): boolean {\n    return this.loadErrors.length > 0;\n  }\n\n  /**\n   * Returns whether the component has already been unloaded, as opposed to simply not having been loaded yet.\n   *\n   * Both states leave `_loaded` false, but they mean opposite things: a component that was never loaded is still\n   * ahead of its lifecycle (queueing children before load is legitimate), while an unloaded one is behind it and\n   * must not be used any further. The distinction is tracked by a flag set in {@link load}, NOT by an\n   * {@link Component.onunload} override, because subclasses override `onunload` and may not call `super`.\n   *\n   * Use it in a long-running `async` method to abandon work whose component was unloaded mid-flight, when\n   * unwinding via the {@link SilentError} thrown by {@link ensureLoaded} / {@link addChild} is not desired.\n   *\n   * @returns `true` if the component was loaded at some point and is currently unloaded, otherwise `false`.\n   */\n  protected isUnloaded(): boolean {\n    return this.hasBeenLoaded && !this._loaded;\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 loadPromisableFunction - A function that starts the load step and returns its result.\n   */\n  private appendSequentialLoadStep(loadPromisableFunction: () => null | Promisable<void>): void {\n    const previous = this.loadPromise;\n    if (previous) {\n      this.setLoadPromise(previous.then(() => this.runAndCapture(loadPromisableFunction)));\n      return;\n    }\n\n    const captured = this.captureSync(loadPromisableFunction);\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    return loadPromisable === null || loadPromisable === undefined\n      ? null\n      : Promise.resolve(loadPromisable).then(noop).catch((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 loadPromisableFunction - 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(loadPromisableFunction: () => null | Promisable<void>): null | Promise<void> {\n    let loadPromisable: null | Promisable<void>;\n    try {\n      loadPromisable = loadPromisableFunction();\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    // 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 instanceof ComponentEx ? component.loadWithPromises() : component.load() as Promisable<void>;\n  }\n\n  private findInFlightAncestryLoadPromise(): null | Promise<void> {\n    return this.loadPromise ?? this.parentComponent?.findInFlightAncestryLoadPromise() ?? null;\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 loadPromisableFunction - A function that starts the load step and returns its result.\n   */\n  private async runAndCapture(loadPromisableFunction: () => null | Promisable<void>): Promise<void> {\n    try {\n      await (loadPromisableFunction() ?? 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  /**\n   * Awaits in-flight loads in the ancestry until none is left.\n   *\n   * Looped rather than awaited once, because an ancestor's load can grow while it is being awaited: a child added\n   * to an already-loaded component appends its async tail to that component's load promise.\n   */\n  private async waitForAncestryLoad(): Promise<void> {\n    let loadPromise = this.findInFlightAncestryLoadPromise();\n    while (loadPromise) {\n      await loadPromise;\n      loadPromise = this.findInFlightAncestryLoadPromise();\n    }\n  }\n}\n"],"mappings":"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","names":[]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/component-ex.ts"],"sourcesContent":["/**\n * @file\n *\n * Extended Component\n */\n\nimport type { Promisable } from 'type-fest';\n\nimport { createAggregateError } from '@mnaoumov/typescript-lib/aggregate-error';\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\nimport {\n  ErrorWrapper,\n  SilentError\n} from '@mnaoumov/typescript-lib/error';\nimport {\n  noop,\n  noopAsyncSingletonPromise\n} from '@mnaoumov/typescript-lib/function';\nimport { Component } from 'obsidian';\n\nimport {\n  registerAsyncDisposable,\n  registerDisposable\n} from '../disposable.ts';\n\n/**\n * Extended Component\n */\n// eslint-disable-next-line obsidian-dev-toolkit/require-component-suffix -- Extended base class.\nexport class ComponentEx extends Component implements Disposable {\n  private readonly childrenSet = new Set<Component>();\n  private hasBeenLoaded = false;\n  private loadErrors: Error[] = [];\n  private loadPromise: null | Promise<void> = null;\n  private parentComponent: ComponentEx | null = 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   * Adding a child BEFORE the first load is legitimate: the child is queued and loaded when this component loads.\n   * Adding one AFTER this component has been unloaded is not — the child would never be loaded and never unloaded\n   * (a leak), so it is refused with a {@link SilentError}. The typical source of such a call is an `async` method\n   * that was suspended on an `await` when the component got unloaded and then resumed on the dead component; the\n   * {@link SilentError} unwinds it quietly (see {@link isUnloaded}).\n   *\n   * @typeParam TComponent - The type of component to add.\n   * @param component - The component instance to add.\n   * @returns The added component.\n   * @throws A {@link SilentError} if the component has already been unloaded.\n   */\n  public override addChild<TComponent extends Component>(component: TComponent): TComponent {\n    if (this.isUnloaded()) {\n      throw new SilentError('Component is already unloaded');\n    }\n\n    this._children.push(component);\n    this.childrenSet.add(component);\n    if (component instanceof ComponentEx) {\n      component.parentComponent = this;\n    }\n\n    if (this._loaded) {\n      this.appendEagerLoadStep(this.extractLoadPromisable(component));\n    }\n\n    return component;\n  }\n\n  /**\n   * Checks whether a component is a direct child of this one.\n   *\n   * Only DIRECT children are reported — this is an ownership question, not a containment one. The caller that\n   * needs it is one holding several parents and deciding which of them a component belongs to, and for that a\n   * grandchild is the wrong answer: removing it from the parent that merely contains its parent would fail.\n   *\n   * @param component - The component to look for.\n   * @returns Whether the component is a direct child of this one.\n   */\n  public hasChild(component: Component): boolean {\n    return this.childrenSet.has(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.hasBeenLoaded = 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 snapshot(this._children)) {\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   * The `AggregateError` is built by {@link createAggregateError}, so its own `message` names the failure rather\n   * than being empty: a lone failure lends its message to every aggregate above it, which is what lets a caller\n   * assert on the sentence that was actually thrown without walking `errors` to find it.\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      return this.loadErrors.length > 0 ? Promise.reject(createAggregateError(this.loadErrors)) : null;\n    }\n\n    return loadPromise.then(() => {\n      if (this.loadErrors.length > 0) {\n        throw createAggregateError(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   * Registers an {@link AsyncDisposable} so its disposal starts when this component unloads, and returns it unchanged.\n   *\n   * Obsidian's unload is synchronous, so nothing awaits the disposal: it runs detached, and a failure is reported, never\n   * rethrown. See the free function {@link registerAsyncDisposable}, which this delegates to.\n   *\n   * @typeParam TAsyncDisposable - The type of the async disposable.\n   * @param asyncDisposable - The async disposable to register.\n   * @returns The same async disposable, for chaining.\n   */\n  public registerAsyncDisposable<TAsyncDisposable extends AsyncDisposable>(asyncDisposable: TAsyncDisposable): TAsyncDisposable {\n    return registerAsyncDisposable(this, asyncDisposable);\n  }\n\n  /**\n   * Registers a {@link Disposable} so it is disposed when this component unloads, and returns it unchanged.\n   *\n   * The recurring \"tie a disposable to the component's lifecycle, then keep using it\" idiom: the disposable is\n   * disposed on {@link Component.unload} (or earlier, if the caller disposes it directly — dispose is expected to\n   * be idempotent). Guard with {@link ensureLoaded} at the call site when registering before load would be unsafe.\n   *\n   * @typeParam TDisposable - The type of the disposable.\n   * @param disposable - The disposable to register.\n   * @returns The same disposable, for chaining.\n   */\n  public registerDisposable<TDisposable extends Disposable>(disposable: TDisposable): TDisposable {\n    return registerDisposable(this, disposable);\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    if (component instanceof ComponentEx && component.parentComponent === this) {\n      component.parentComponent = null;\n    }\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   * The two not-loaded cases are deliberately distinguished. A component that was NEVER loaded is a genuine\n   * programming error, so it throws a loud {@link Error}. A component that has ALREADY been unloaded is not —\n   * it is the expected outcome of work that outlived its component (e.g. an `async` method suspended on an\n   * `await` while the component was unloaded, then resumed) — so it throws a {@link SilentError}, which\n   * `handleSilentError` suppresses, letting such work unwind quietly instead of reporting an async error.\n   *\n   * @throws An {@link Error} if the component was never loaded, or a {@link SilentError} if it has already been unloaded.\n   */\n  protected ensureLoaded(): void {\n    if (this._loaded) {\n      return;\n    }\n\n    if (this.isUnloaded()) {\n      throw new SilentError('Component is already unloaded');\n    }\n\n    throw new Error('Component is not loaded');\n  }\n\n  /**\n   * Returns a {@link Promise} that settles once neither this component nor any {@link ComponentEx} ancestor has a load\n   * in flight, or `null` when none of them has one right now.\n   *\n   * {@link getInFlightLoadPromise} covers this component's OWN load only. A sibling this component depends on — most\n   * often the owning plugin's settings component, which reads `data.json` asynchronously — is outside it, but it is\n   * inside the load of a shared ancestor. Waiting for every ancestor therefore waits for the whole tree the component\n   * was loaded as part of: under `PluginBase` the chain ends at the plugin's universal wrapper, whose load covers the\n   * dependency gate, the feature surface and `onloadImpl`.\n   *\n   * The chain is followed through {@link ComponentEx} parents only. A plain {@link Component} anywhere between this\n   * component and an ancestor ends it, because a plain component records no parent and exposes no load promise.\n   *\n   * Never await this from inside a load step of one of those ancestors: the ancestor's load would then be waiting for\n   * itself. It is meant for work scheduled OUTSIDE the load, such as a layout-ready handler.\n   *\n   * @returns The promise, or `null` if nothing in the ancestry is loading.\n   */\n  protected getInFlightAncestryLoadPromise(): null | Promise<void> {\n    return this.findInFlightAncestryLoadPromise() ? this.waitForAncestryLoad() : null;\n  }\n\n  /**\n   * Returns the component's in-flight load {@link Promise} (its {@link onloadAsync} plus children), or `null` when\n   * nothing is loading — either the component loaded fully synchronously or its async load has already settled.\n   *\n   * Lets a caller scheduled while the component is still loading await the async load tail before acting, instead of\n   * racing it: {@link Component.onload} has run (so `_loaded` is set) but {@link onloadAsync} may not have finished.\n   *\n   * It covers this component's OWN load only. A caller that also depends on a sibling's state — a layout-ready handler\n   * reading settings is the common one — wants {@link getInFlightAncestryLoadPromise}, which `LayoutReadyComponent`\n   * uses.\n   *\n   * @returns The in-flight load promise, or `null` if no load is in flight.\n   */\n  protected getInFlightLoadPromise(): null | Promise<void> {\n    return this.loadPromise;\n  }\n\n  /**\n   * Returns whether the most recent load recorded any failure.\n   *\n   * Reflects the outcome of the last {@link load} / {@link loadWithPromises}: `true` when {@link onloadAsync} or any\n   * child's load threw (synchronously or asynchronously). Unlike {@link loadWithPromises}, reading this does NOT\n   * re-raise the collected errors — it lets a bystander (e.g. a layout-ready handler awaiting the in-flight load) tell\n   * whether the load succeeded without adopting a failure that the load's owner is already responsible for.\n   *\n   * @returns `true` if the last load recorded at least one error, otherwise `false`.\n   */\n  protected hasLoadErrors(): boolean {\n    return this.loadErrors.length > 0;\n  }\n\n  /**\n   * Returns whether the component has already been unloaded, as opposed to simply not having been loaded yet.\n   *\n   * Both states leave `_loaded` false, but they mean opposite things: a component that was never loaded is still\n   * ahead of its lifecycle (queueing children before load is legitimate), while an unloaded one is behind it and\n   * must not be used any further. The distinction is tracked by a flag set in {@link load}, NOT by an\n   * {@link Component.onunload} override, because subclasses override `onunload` and may not call `super`.\n   *\n   * Use it in a long-running `async` method to abandon work whose component was unloaded mid-flight, when\n   * unwinding via the {@link SilentError} thrown by {@link ensureLoaded} / {@link addChild} is not desired.\n   *\n   * @returns `true` if the component was loaded at some point and is currently unloaded, otherwise `false`.\n   */\n  protected isUnloaded(): boolean {\n    return this.hasBeenLoaded && !this._loaded;\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 loadPromisableFunction - A function that starts the load step and returns its result.\n   */\n  private appendSequentialLoadStep(loadPromisableFunction: () => null | Promisable<void>): void {\n    const previous = this.loadPromise;\n    if (previous) {\n      this.setLoadPromise(previous.then(() => this.runAndCapture(loadPromisableFunction)));\n      return;\n    }\n\n    const captured = this.captureSync(loadPromisableFunction);\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    return loadPromisable === null || loadPromisable === undefined\n      ? null\n      : Promise.resolve(loadPromisable).then(noop).catch((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 loadPromisableFunction - 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(loadPromisableFunction: () => null | Promisable<void>): null | Promise<void> {\n    let loadPromisable: null | Promisable<void>;\n    try {\n      loadPromisable = loadPromisableFunction();\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    // 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 instanceof ComponentEx ? component.loadWithPromises() : component.load() as Promisable<void>;\n  }\n\n  private findInFlightAncestryLoadPromise(): null | Promise<void> {\n    return this.loadPromise ?? this.parentComponent?.findInFlightAncestryLoadPromise() ?? null;\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 loadPromisableFunction - A function that starts the load step and returns its result.\n   */\n  private async runAndCapture(loadPromisableFunction: () => null | Promisable<void>): Promise<void> {\n    try {\n      await (loadPromisableFunction() ?? 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  /**\n   * Awaits in-flight loads in the ancestry until none is left.\n   *\n   * Looped rather than awaited once, because an ancestor's load can grow while it is being awaited: a child added\n   * to an already-loaded component appends its async tail to that component's load promise.\n   */\n  private async waitForAncestryLoad(): Promise<void> {\n    let loadPromise = this.findInFlightAncestryLoadPromise();\n    while (loadPromise) {\n      await loadPromise;\n      loadPromise = this.findInFlightAncestryLoadPromise();\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/components/disposable-component.mjs

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

package/dist/lib/esm/components/embed-extensions-component.d.mts

@@ -26,6 +26,14 @@ export declare class EmbedExtensionsComponent extends ComponentEx {
      * Registers the specified file extensions with the given embed type in the Obsidian app.
      * The extensions will be automatically unregistered when the component is unloaded.
      *
+     * The registration is all or nothing: Obsidian throws for an extension that is already registered (by the core or by
+     * another plugin), and in that case every extension this call registered before the conflict is unregistered again
+     * before the error is rethrown. An extension registered by someone else is never unregistered.
+     *
+     * The creator serves every surface that loads an embed: `![[file.ext#subpath]]` in Reading view and Live Preview,
+     * canvas file nodes and the page-preview hover popover. It receives the link's subpath with its leading `#`, or an
+     * empty string. Returning `null` makes Obsidian fall back to its generic file embed.
+     *
      * @param extensions - An array of file extensions to register.
      * @param embedCreator - The embed creator function to associate with the extensions.
      *

package/dist/lib/esm/components/embed-extensions-component.mjs

@@ -19,6 +19,14 @@ class EmbedExtensionsComponent extends ComponentEx {
    * Registers the specified file extensions with the given embed type in the Obsidian app.
    * The extensions will be automatically unregistered when the component is unloaded.
    *
+   * The registration is all or nothing: Obsidian throws for an extension that is already registered (by the core or by
+   * another plugin), and in that case every extension this call registered before the conflict is unregistered again
+   * before the error is rethrown. An extension registered by someone else is never unregistered.
+   *
+   * The creator serves every surface that loads an embed: `![[file.ext#subpath]]` in Reading view and Live Preview,
+   * canvas file nodes and the page-preview hover popover. It receives the link's subpath with its leading `#`, or an
+   * empty string. Returning `null` makes Obsidian fall back to its generic file embed.
+   *
    * @param extensions - An array of file extensions to register.
    * @param embedCreator - The embed creator function to associate with the extensions.
    *
@@ -29,13 +37,22 @@ class EmbedExtensionsComponent extends ComponentEx {
    */
   registerExtensions(extensions, embedCreator) {
     this.ensureLoaded();
-    this.app.embedRegistry.registerExtensions(extensions, embedCreator);
+    const registeredExtensions = [];
+    try {
+      for (const extension of extensions) {
+        this.app.embedRegistry.registerExtension(extension, embedCreator);
+        registeredExtensions.push(extension);
+      }
+    } catch (error) {
+      this.app.embedRegistry.unregisterExtensions(registeredExtensions);
+      throw error;
+    }
     this.register(() => {
-      this.app.embedRegistry.unregisterExtensions(extensions);
+      this.app.embedRegistry.unregisterExtensions(registeredExtensions);
     });
   }
 }
 export {
   EmbedExtensionsComponent
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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