@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

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

@@ -0,0 +1,413 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  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
+} from "@mnaoumov/typescript-lib/error";
+import {
+  noop,
+  noopAsyncSingletonPromise
+} from "@mnaoumov/typescript-lib/function";
+import { Component } from "obsidian";
+class ComponentEx extends 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 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 !== noopAsyncSingletonPromise) {
+      this.appendEagerLoadStep(onloadAsyncPromise);
+    }
+    for (const child of 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(createAggregateError(this.loadErrors)) : null;
+    }
+    return loadPromise.then(() => {
+      if (this.loadErrors.length > 0) {
+        throw 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 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(() => {
+      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 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(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(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();
+    }
+  }
+}
+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-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": []
}


package/dist/lib/esm/components/console-debug-component.d.mts

@@ -0,0 +1,30 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Component that provides namespaced console debug logging.
+ */
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * Provides a namespaced `consoleDebug()` method for logging.
+ *
+ * Messages are not shown by default — enable the plugin's debugger namespace to see them.
+ *
+ * @see {@link https://mnaoumov.dev/obsidian-dev-utils/guides/debugging/} for more information.
+ */
+export declare class ConsoleDebugComponent extends ComponentEx {
+    protected readonly pluginId: string;
+    /**
+     * Creates a new console debug component.
+     *
+     * @param pluginId - The plugin ID (used as the debugger namespace).
+     */
+    constructor(pluginId: string);
+    /**
+     * Logs a message to the console under the plugin's debugger namespace.
+     *
+     * @param message - The message to log.
+     * @param $arguments - Additional arguments to log.
+     */
+    consoleDebug(message: string, ...$arguments: unknown[]): void;
+}

package/dist/lib/esm/components/console-debug-component.mjs

@@ -0,0 +1,73 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { getDebugger } from "@mnaoumov/typescript-lib/debug";
+import { ComponentEx } from "./component-ex.mjs";
+class ConsoleDebugComponent extends ComponentEx {
+  /**
+   * Creates a new console debug component.
+   *
+   * @param pluginId - The plugin ID (used as the debugger namespace).
+   */
+  constructor(pluginId) {
+    super();
+    this.pluginId = pluginId;
+  }
+  pluginId;
+  /**
+   * Logs a message to the console under the plugin's debugger namespace.
+   *
+   * @param message - The message to log.
+   * @param $arguments - Additional arguments to log.
+   */
+  consoleDebug(message, ...$arguments) {
+    const FRAMES_TO_SKIP = 1;
+    const pluginDebugger = getDebugger(this.pluginId, FRAMES_TO_SKIP);
+    if (!this._loaded) {
+      pluginDebugger("Plugin is unloaded but sent the following message:");
+    }
+    pluginDebugger(message, ...$arguments);
+  }
+}
+export {
+  ConsoleDebugComponent
+};
+//# sourceMappingURL=data:application/json;base64,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