@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

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

@@ -0,0 +1,504 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+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;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var component_ex_exports = {};
+__export(component_ex_exports, {
+  ComponentEx: () => ComponentEx
+});
+module.exports = __toCommonJS(component_ex_exports);
+var import_aggregate_error = require('@mnaoumov/typescript-lib/aggregate-error');
+var import_array = require('@mnaoumov/typescript-lib/array');
+var import_disposable = require('@mnaoumov/typescript-lib/disposable');
+var import_error = require('@mnaoumov/typescript-lib/error');
+var import_function = require('@mnaoumov/typescript-lib/function');
+var import_obsidian = require('obsidian');
+class ComponentEx extends import_obsidian.Component {
+  childrenSet = /* @__PURE__ */ new Set();
+  hasBeenLoaded = false;
+  loadErrors = [];
+  loadPromise = null;
+  parentComponent = 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.
+   *
+   * Adding a child BEFORE the first load is legitimate: the child is queued and loaded when this component loads.
+   * Adding one AFTER this component has been unloaded is not — the child would never be loaded and never unloaded
+   * (a leak), so it is refused with a {@link SilentError}. The typical source of such a call is an `async` method
+   * that was suspended on an `await` when the component got unloaded and then resumed on the dead component; the
+   * {@link SilentError} unwinds it quietly (see {@link isUnloaded}).
+   *
+   * @typeParam TComponent - The type of component to add.
+   * @param component - The component instance to add.
+   * @returns The added component.
+   * @throws A {@link SilentError} if the component has already been unloaded.
+   */
+  addChild(component) {
+    if (this.isUnloaded()) {
+      throw new import_error.SilentError("Component is already unloaded");
+    }
+    this._children.push(component);
+    this.childrenSet.add(component);
+    if (component instanceof ComponentEx) {
+      component.parentComponent = this;
+    }
+    if (this._loaded) {
+      this.appendEagerLoadStep(this.extractLoadPromisable(component));
+    }
+    return component;
+  }
+  /**
+   * Checks whether a component is a direct child of this one.
+   *
+   * Only DIRECT children are reported — this is an ownership question, not a containment one. The caller that
+   * needs it is one holding several parents and deciding which of them a component belongs to, and for that a
+   * grandchild is the wrong answer: removing it from the parent that merely contains its parent would fail.
+   *
+   * @param component - The component to look for.
+   * @returns Whether the component is a direct child of this one.
+   */
+  hasChild(component) {
+    return this.childrenSet.has(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 is fully synchronous.
+   */
+  load() {
+    if (this._loaded) {
+      return;
+    }
+    this._loaded = true;
+    this.hasBeenLoaded = true;
+    this.resetLoadState();
+    this.onload();
+    const onloadAsyncPromise = this.onloadAsync();
+    if (onloadAsyncPromise !== import_function.noopAsyncSingletonPromise) {
+      this.appendEagerLoadStep(onloadAsyncPromise);
+    }
+    for (const child of (0, import_array.snapshot)(this._children)) {
+      this.appendSequentialLoadStep(() => this.extractLoadPromisable(child));
+    }
+    if (this.loadPromise) {
+      return this.loadPromise;
+    }
+  }
+  /**
+   * Loads the component with promises.
+   *
+   * 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}.
+   *
+   * The `AggregateError` is built by {@link createAggregateError}, so its own `message` names the failure rather
+   * than being empty: a lone failure lends its message to every aggregate above it, which is what lets a caller
+   * assert on the sentence that was actually thrown without walking `errors` to find it.
+   *
+   * @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();
+    const loadPromise = this.loadPromise;
+    if (!loadPromise) {
+      return this.loadErrors.length > 0 ? Promise.reject((0, import_aggregate_error.createAggregateError)(this.loadErrors)) : null;
+    }
+    return loadPromise.then(() => {
+      if (this.loadErrors.length > 0) {
+        throw (0, import_aggregate_error.createAggregateError)(this.loadErrors);
+      }
+    });
+  }
+  /**
+   * Asynchronously loads the component.
+   *
+   * Override to add async load logic, which is executed after {@link Component.onload}.
+   *
+   * @returns A {@link Promise} that resolves when the component is loaded.
+   */
+  onloadAsync() {
+    return import_function.noopAsyncSingletonPromise;
+  }
+  /**
+   * Registers a {@link Disposable} so it is disposed when this component unloads, and returns it unchanged.
+   *
+   * The recurring "tie a disposable to the component's lifecycle, then keep using it" idiom: the disposable is
+   * disposed on {@link Component.unload} (or earlier, if the caller disposes it directly — dispose is expected to
+   * be idempotent). Guard with {@link ensureLoaded} at the call site when registering before load would be unsafe.
+   *
+   * @typeParam TDisposable - The type of the disposable.
+   * @param disposable - The disposable to register.
+   * @returns The same disposable, for chaining.
+   */
+  registerDisposable(disposable) {
+    this.register(() => {
+      (0, import_disposable.dispose)(disposable);
+    });
+    return disposable;
+  }
+  /**
+   * Removes a child component.
+   *
+   * @typeParam TComponent - The type of component to remove.
+   * @param component - The component instance to remove.
+   * @returns The removed component.
+   */
+  removeChild(component) {
+    super.removeChild(component);
+    this.childrenSet.delete(component);
+    if (component instanceof ComponentEx && component.parentComponent === this) {
+      component.parentComponent = null;
+    }
+    return component;
+  }
+  /**
+   * Disposes of the 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.
+   *
+   * The two not-loaded cases are deliberately distinguished. A component that was NEVER loaded is a genuine
+   * programming error, so it throws a loud {@link Error}. A component that has ALREADY been unloaded is not —
+   * it is the expected outcome of work that outlived its component (e.g. an `async` method suspended on an
+   * `await` while the component was unloaded, then resumed) — so it throws a {@link SilentError}, which
+   * `handleSilentError` suppresses, letting such work unwind quietly instead of reporting an async error.
+   *
+   * @throws An {@link Error} if the component was never loaded, or a {@link SilentError} if it has already been unloaded.
+   */
+  ensureLoaded() {
+    if (this._loaded) {
+      return;
+    }
+    if (this.isUnloaded()) {
+      throw new import_error.SilentError("Component is already unloaded");
+    }
+    throw new Error("Component is not loaded");
+  }
+  /**
+   * Returns a {@link Promise} that settles once neither this component nor any {@link ComponentEx} ancestor has a load
+   * in flight, or `null` when none of them has one right now.
+   *
+   * {@link getInFlightLoadPromise} covers this component's OWN load only. A sibling this component depends on — most
+   * often the owning plugin's settings component, which reads `data.json` asynchronously — is outside it, but it is
+   * inside the load of a shared ancestor. Waiting for every ancestor therefore waits for the whole tree the component
+   * was loaded as part of: under `PluginBase` the chain ends at the plugin's universal wrapper, whose load covers the
+   * dependency gate, the feature surface and `onloadImpl`.
+   *
+   * The chain is followed through {@link ComponentEx} parents only. A plain {@link Component} anywhere between this
+   * component and an ancestor ends it, because a plain component records no parent and exposes no load promise.
+   *
+   * Never await this from inside a load step of one of those ancestors: the ancestor's load would then be waiting for
+   * itself. It is meant for work scheduled OUTSIDE the load, such as a layout-ready handler.
+   *
+   * @returns The promise, or `null` if nothing in the ancestry is loading.
+   */
+  getInFlightAncestryLoadPromise() {
+    return this.findInFlightAncestryLoadPromise() ? this.waitForAncestryLoad() : null;
+  }
+  /**
+   * Returns the component's in-flight load {@link Promise} (its {@link onloadAsync} plus children), or `null` when
+   * nothing is loading — either the component loaded fully synchronously or its async load has already settled.
+   *
+   * Lets a caller scheduled while the component is still loading await the async load tail before acting, instead of
+   * racing it: {@link Component.onload} has run (so `_loaded` is set) but {@link onloadAsync} may not have finished.
+   *
+   * It covers this component's OWN load only. A caller that also depends on a sibling's state — a layout-ready handler
+   * reading settings is the common one — wants {@link getInFlightAncestryLoadPromise}, which `LayoutReadyComponent`
+   * uses.
+   *
+   * @returns The in-flight load promise, or `null` if no load is in flight.
+   */
+  getInFlightLoadPromise() {
+    return this.loadPromise;
+  }
+  /**
+   * Returns whether the most recent load recorded any failure.
+   *
+   * Reflects the outcome of the last {@link load} / {@link loadWithPromises}: `true` when {@link onloadAsync} or any
+   * child's load threw (synchronously or asynchronously). Unlike {@link loadWithPromises}, reading this does NOT
+   * re-raise the collected errors — it lets a bystander (e.g. a layout-ready handler awaiting the in-flight load) tell
+   * whether the load succeeded without adopting a failure that the load's owner is already responsible for.
+   *
+   * @returns `true` if the last load recorded at least one error, otherwise `false`.
+   */
+  hasLoadErrors() {
+    return this.loadErrors.length > 0;
+  }
+  /**
+   * Returns whether the component has already been unloaded, as opposed to simply not having been loaded yet.
+   *
+   * Both states leave `_loaded` false, but they mean opposite things: a component that was never loaded is still
+   * ahead of its lifecycle (queueing children before load is legitimate), while an unloaded one is behind it and
+   * must not be used any further. The distinction is tracked by a flag set in {@link load}, NOT by an
+   * {@link Component.onunload} override, because subclasses override `onunload` and may not call `super`.
+   *
+   * Use it in a long-running `async` method to abandon work whose component was unloaded mid-flight, when
+   * unwinding via the {@link SilentError} thrown by {@link ensureLoaded} / {@link addChild} is not desired.
+   *
+   * @returns `true` if the component was loaded at some point and is currently unloaded, otherwise `false`.
+   */
+  isUnloaded() {
+    return this.hasBeenLoaded && !this._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 loadPromisableFunction - A function that starts the load step and returns its result.
+   */
+  appendSequentialLoadStep(loadPromisableFunction) {
+    const previous = this.loadPromise;
+    if (previous) {
+      this.setLoadPromise(previous.then(() => this.runAndCapture(loadPromisableFunction)));
+      return;
+    }
+    const captured = this.captureSync(loadPromisableFunction);
+    if (captured) {
+      this.setLoadPromise(captured);
+    }
+  }
+  /**
+   * Records a load failure.
+   *
+   * A failure raised by a child {@link ComponentEx} is itself an {@link AggregateError}; it is recorded as-is so the
+   * grouping by child component is preserved (own failures stay flat, child-subtree failures stay nested).
+   *
+   * @param error - The thrown value to record.
+   */
+  captureError(error) {
+    this.loadErrors.push(import_error.ErrorWrapper.create(error));
+  }
+  /**
+   * Wraps an already-started load result so it never rejects: any failure is recorded into `loadErrors`.
+   *
+   * @param loadPromisable - The load result to observe.
+   * @returns A never-rejecting {@link Promise}, or `null` if the result is fully synchronous.
+   */
+  captureSettled(loadPromisable) {
+    return loadPromisable === null || loadPromisable === void 0 ? null : Promise.resolve(loadPromisable).then(import_function.noop).catch((error) => {
+      this.captureError(error);
+    });
+  }
+  /**
+   * Runs a load step synchronously, recording a synchronous throw, and wraps any async tail so it never rejects.
+   *
+   * @param loadPromisableFunction - 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(loadPromisableFunction) {
+    let loadPromisable;
+    try {
+      loadPromisable = loadPromisableFunction();
+    } catch (error) {
+      this.captureError(error);
+      return null;
+    }
+    return this.captureSettled(loadPromisable);
+  }
+  extractLoadPromisable(component) {
+    if (!this.childrenSet.has(component)) {
+      return null;
+    }
+    return component instanceof ComponentEx ? component.loadWithPromises() : component.load();
+  }
+  findInFlightAncestryLoadPromise() {
+    return this.loadPromise ?? this.parentComponent?.findInFlightAncestryLoadPromise() ?? null;
+  }
+  resetLoadState() {
+    this.loadErrors = [];
+    this.loadPromise = null;
+  }
+  /**
+   * Runs a deferred load step, recording a synchronous throw or an async rejection without ever re-throwing.
+   *
+   * @param loadPromisableFunction - A function that starts the load step and returns its result.
+   */
+  async runAndCapture(loadPromisableFunction) {
+    try {
+      await (loadPromisableFunction() ?? void 0);
+    } catch (error) {
+      this.captureError(error);
+    }
+  }
+  setLoadPromise(loadPromise) {
+    const loadPromiseWithReset = loadPromise.then(() => {
+      if (this.loadPromise === loadPromiseWithReset) {
+        this.loadPromise = null;
+      }
+    });
+    this.loadPromise = loadPromiseWithReset;
+  }
+  /**
+   * Awaits in-flight loads in the ancestry until none is left.
+   *
+   * Looped rather than awaited once, because an ancestor's load can grow while it is being awaited: a child added
+   * to an already-loaded component appends its async tail to that component's load promise.
+   */
+  async waitForAncestryLoad() {
+    let loadPromise = this.findInFlightAncestryLoadPromise();
+    while (loadPromise) {
+      await loadPromise;
+      loadPromise = this.findInFlightAncestryLoadPromise();
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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-utils/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 \u2014 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 \u2014 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 \u2014 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 \u2014\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) \u2014 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 \u2014 most\n   * often the owning plugin's settings component, which reads `data.json` asynchronously \u2014 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 \u2014 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 \u2014 a layout-ready handler\n   * reading settings is the common one \u2014 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 \u2014 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": []
}
