@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

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

@@ -0,0 +1,229 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Extended Component
+ */
+import { Component } from 'obsidian';
+/**
+ * Extended Component
+ */
+export declare class ComponentEx extends Component implements Disposable {
+    private readonly childrenSet;
+    private hasBeenLoaded;
+    private loadErrors;
+    private loadPromise;
+    private parentComponent;
+    /**
+     * 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<TComponent extends Component>(component: TComponent): TComponent;
+    /**
+     * 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: Component): boolean;
+    /**
+     * 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(): void;
+    /**
+     * 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(): null | Promise<void>;
+    /**
+     * 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(): Promise<void>;
+    /**
+     * 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<TDisposable extends Disposable>(disposable: TDisposable): TDisposable;
+    /**
+     * Removes a child component.
+     *
+     * @typeParam TComponent - The type of component to remove.
+     * @param component - The component instance to remove.
+     * @returns The removed component.
+     */
+    removeChild<TComponent extends Component>(component: TComponent): TComponent;
+    /**
+     * Disposes of the component.
+     */
+    [Symbol.dispose](): void;
+    /**
+     * Ensures the component is loaded, throwing if it is not.
+     *
+     * Use this to guard public methods that register teardown-bearing resources (via {@link Component.register},
+     * {@link Component.registerEvent}, {@link Component.registerDomEvent}, etc.). Registering before load is unsafe:
+     * {@link Component.unload} is a no-op while the component is not loaded, so any teardown registered beforehand would
+     * never run if the component is unloaded without first being loaded.
+     *
+     * 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.
+     */
+    protected ensureLoaded(): void;
+    /**
+     * 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.
+     */
+    protected getInFlightAncestryLoadPromise(): null | Promise<void>;
+    /**
+     * 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.
+     */
+    protected getInFlightLoadPromise(): null | Promise<void>;
+    /**
+     * 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`.
+     */
+    protected hasLoadErrors(): boolean;
+    /**
+     * 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`.
+     */
+    protected isUnloaded(): boolean;
+    /**
+     * Sequences an already-started load step into the load promise.
+     *
+     * The step is presumed to have started synchronously (so any `_loaded` flag it sets is already visible); only the
+     * awaiting of its async tail is sequenced here.
+     *
+     * @param loadPromisable - The result of an already-started load step.
+     */
+    private appendEagerLoadStep;
+    /**
+     * Sequences a deferred load step into the load promise, running it only after previously-appended steps settle.
+     *
+     * @param loadPromisableFunction - A function that starts the load step and returns its result.
+     */
+    private appendSequentialLoadStep;
+    /**
+     * Records a load failure.
+     *
+     * A failure raised by a child {@link ComponentEx} is itself an {@link AggregateError}; it is recorded as-is so the
+     * grouping by child component is preserved (own failures stay flat, child-subtree failures stay nested).
+     *
+     * @param error - The thrown value to record.
+     */
+    private captureError;
+    /**
+     * Wraps an already-started load result so it never rejects: any failure is recorded into `loadErrors`.
+     *
+     * @param loadPromisable - The load result to observe.
+     * @returns A never-rejecting {@link Promise}, or `null` if the result is fully synchronous.
+     */
+    private captureSettled;
+    /**
+     * Runs a load step synchronously, recording a synchronous throw, and wraps any async tail so it never rejects.
+     *
+     * @param 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.
+     */
+    private captureSync;
+    private extractLoadPromisable;
+    private findInFlightAncestryLoadPromise;
+    private resetLoadState;
+    /**
+     * 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.
+     */
+    private runAndCapture;
+    private setLoadPromise;
+    /**
+     * 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.
+     */
+    private waitForAncestryLoad;
+}

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

@@ -0,0 +1,194 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+  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 = 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 = 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);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        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);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    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 console_debug_component_exports = {};
+__export(console_debug_component_exports, {
+  ConsoleDebugComponent: () => ConsoleDebugComponent
+});
+module.exports = __toCommonJS(console_debug_component_exports);
+var import_debug = require('@mnaoumov/typescript-lib/debug');
+var import_component_ex = require('./component-ex.cjs');
+class ConsoleDebugComponent extends import_component_ex.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 = (0, import_debug.getDebugger)(this.pluginId, FRAMES_TO_SKIP);
+    if (!this._loaded) {
+      pluginDebugger("Plugin is unloaded but sent the following message:");
+    }
+    pluginDebugger(message, ...$arguments);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConsoleDebugComponent
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,30 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Component that provides namespaced console debug logging.
+ */
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * 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;
+}