obsidian-dev-utils 67.0.0 → 68.0.0

package/dist/lib/cjs/obsidian/components/plugin-settings-component.d.cts

@@ -8,12 +8,13 @@
  * by this component — no separate manager class is needed.
  */
 import type { Constructor, Promisable, ReadonlyDeep } from 'type-fest';
-import type { AsyncEventRef } from '../../async-events.cjs';
+import type { AsyncEventRef, AsyncEventSource } from '../../async-events.cjs';
 import type { Transformer } from '../../transformers/transformer.cjs';
 import type { GenericObject } from '../../type-guards.cjs';
 import type { MaybeReturn, StringKeys } from '../../type.cjs';
 import type { DataHandler } from '../data-handler.cjs';
-import { AsyncComponent } from './async-component.cjs';
+import type { PluginEventSource } from '../plugin/plugin.cjs';
+import { ComponentEx } from './component-ex.cjs';
 /**
  * Constructor parameters for {@link PluginSettingsComponentBase}.
  *
@@ -24,6 +25,10 @@ export interface PluginSettingsComponentBaseConstructorParams<PluginSettings> {
      * The data handler for the plugin.
      */
     readonly dataHandler: DataHandler;
+    /**
+     * The plugin events.
+     */
+    readonly pluginEventSource: PluginEventSource;
     /**
      * The plugin settings class.
      */
@@ -68,6 +73,17 @@ export type ReadonlyPluginSettingsState<PluginSettings extends object> = Readonl
  * @typeParam PropertyName - The property name.
  */
 export type SettingsValidator<PluginSettings extends object, PropertyName extends StringKeys<PluginSettings> = StringKeys<PluginSettings>> = (value: PluginSettings[PropertyName], settings: PluginSettings) => Promisable<MaybeReturn<string>>;
+interface PluginSettingsComponentBaseEventMap<PluginSettings extends object> {
+    loadSettings: [
+        loadedState: ReadonlyPluginSettingsState<PluginSettings>,
+        isInitialLoad: boolean
+    ];
+    saveSettings: [
+        newState: ReadonlyPluginSettingsState<PluginSettings>,
+        oldState: ReadonlyPluginSettingsState<PluginSettings>,
+        context: unknown
+    ];
+}
 type PropertyNames<PluginSettings extends object> = StringKeys<PluginSettings>;
 type ValidationResult<PluginSettings extends object> = Partial<Record<StringKeys<PluginSettings>, string>>;
 /**
@@ -78,11 +94,7 @@ type ValidationResult<PluginSettings extends object> = Partial<Record<StringKeys
  *
  * @typeParam PluginSettings - The plugin settings type.
  */
-export declare class PluginSettingsComponentBase<PluginSettings extends object> extends AsyncComponent {
-    /**
-     * Component key for singleton replacement via {@link PluginBase.addChild}.
-     */
-    static readonly COMPONENT_KEY: unique symbol;
+export declare class PluginSettingsComponentBase<PluginSettings extends object> extends ComponentEx implements AsyncEventSource<PluginSettingsComponentBaseEventMap<PluginSettings>> {
     /**
      * Gets the readonly default settings.
      *
@@ -106,6 +118,7 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
     private readonly dataHandler;
     private lastSavedState;
     private readonly legacySettingsConverters;
+    private readonly pluginEventSource;
     private readonly pluginSettingsClass;
     private readonly propertyNames;
     private readonly validators;
@@ -147,23 +160,44 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
      */
     loadFromFile(isInitialLoad: boolean): Promise<void>;
     /**
-     * Subscribes to the `loadSettings` event.
+     * Remove an event listener.
+     *
+     * @typeParam EventName - The name of the event.
+     * @typeParam Args - The types of the arguments the event callback accepts.
+     * @param name - The name of the event.
+     * @param callback - The callback to remove.
+     */
+    off<EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>, Args extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName] : unknown[]>(name: EventName, callback: (...args: Args) => Promisable<void>): void;
+    /**
+     * Remove an event listener by reference.
+     *
+     * @param eventRef - The reference to the event listener.
+     */
+    offref(eventRef: AsyncEventRef): void;
+    /**
+     * Add an event listener.
      *
-     * @param name - Always `loadSettings`.
-     * @param callback - The callback.
-     * @param thisArg - The `this` context.
+     * @typeParam EventName - The name of the event.
+     * @typeParam Args - The types of the arguments the event callback accepts.
+     * @param name - The name of the event.
+     * @param callback - The callback to call when the event is triggered.
+     * @param thisArg - The context passed as `this` to the `callback`.
      * @returns A reference to the event listener.
      */
-    on(name: 'loadSettings', callback: (loadedState: ReadonlyPluginSettingsState<PluginSettings>, isInitialLoad: boolean) => Promisable<void>, thisArg?: unknown): AsyncEventRef;
+    on<EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>, Args extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName] : unknown[]>(name: EventName, callback: (...args: Args) => Promisable<void>, thisArg?: unknown): AsyncEventRef;
     /**
-     * Subscribes to the `saveSettings` event.
+     * Trigger an event, executing all the listeners in order even if some of them throw an error.
+     *
+     * Add an event listener that will be called only once.
      *
-     * @param name - Always `saveSettings`.
-     * @param callback - The callback.
-     * @param thisArg - The `this` context.
+     * @typeParam EventName - The name of the event.
+     * @typeParam Args - The types of the arguments the event callback accepts.
+     * @param name - The name of the event.
+     * @param callback - The callback to call when the event is triggered.
+     * @param thisArg - The context passed as `this` to the `callback`.
      * @returns A reference to the event listener.
      */
-    on(name: 'saveSettings', callback: (newState: ReadonlyPluginSettingsState<PluginSettings>, oldState: ReadonlyPluginSettingsState<PluginSettings>, context: unknown) => Promisable<void>, thisArg?: unknown): AsyncEventRef;
+    once<EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings>, Args extends EventName extends keyof PluginSettingsComponentBaseEventMap<PluginSettings> ? PluginSettingsComponentBaseEventMap<PluginSettings>[EventName] : unknown[]>(name: EventName, callback: (...args: Args) => Promisable<void>, thisArg?: unknown): AsyncEventRef;
     /**
      * Called when the external settings change.
      *
@@ -173,7 +207,7 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
     /**
      * Loads settings from file and registers event handlers.
      */
-    onload(): Promise<void>;
+    onloadAsync(): Promise<void>;
     /**
      * Registers a legacy settings converter.
      *
@@ -185,6 +219,7 @@ export declare class PluginSettingsComponentBase<PluginSettings extends object>
     /**
      * Registers a validator for a property.
      *
+     * @typeParam PropertyName - The name of the settings property.
      * @param propertyName - The name of the property.
      * @param validator - The validator.
      */

package/dist/lib/cjs/obsidian/components/plugin-settings-tab-component.cjs

@@ -129,8 +129,8 @@ __export(plugin_settings_tab_component_exports, {
 });
 module.exports = __toCommonJS(plugin_settings_tab_component_exports);
 var import_obsidian = require('obsidian');
-var import_disposable_component = require('./disposable-component.cjs');
-class PluginSettingsTabComponent extends import_disposable_component.DisposableComponent {
+var import_component_ex = require('./component-ex.cjs');
+class PluginSettingsTabComponent extends import_component_ex.ComponentEx {
   plugin;
   pluginSettingsTab;
   /**
@@ -154,4 +154,4 @@ class PluginSettingsTabComponent extends import_disposable_component.DisposableC
 0 && (module.exports = {
   PluginSettingsTabComponent
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/components/plugin-settings-tab-component.d.cts

@@ -6,7 +6,7 @@
  */
 import type { Plugin } from 'obsidian';
 import { PluginSettingTab } from 'obsidian';
-import { DisposableComponent } from './disposable-component.cjs';
+import { ComponentEx } from './component-ex.cjs';
 interface PluginSettingsTabComponentConstructorParams {
     readonly plugin: Plugin;
     readonly pluginSettingsTab: PluginSettingTab;
@@ -15,7 +15,7 @@ interface PluginSettingsTabComponentConstructorParams {
  * Wraps a {@link PluginSettingTab} and registers it with Obsidian on load.
  * Also registers an "Open Settings" command to open the settings tab from the command palette.
  */
-export declare class PluginSettingsTabComponent extends DisposableComponent {
+export declare class PluginSettingsTabComponent extends ComponentEx {
     private readonly plugin;
     private readonly pluginSettingsTab;
     /**

package/dist/lib/cjs/obsidian/components/registry-component.cjs

@@ -0,0 +1,180 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // 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
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@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.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(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.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.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 registry_component_exports = {};
+__export(registry_component_exports, {
+  RegistryComponent: () => RegistryComponent
+});
+module.exports = __toCommonJS(registry_component_exports);
+var import_type_guards = require('../../type-guards.cjs');
+var import_component_ex = require('./component-ex.cjs');
+class RegistryComponent extends import_component_ex.ComponentEx {
+  /**
+   * Get the single child of the given type.
+   *
+   * @typeParam TComponent - The type of component to get.
+   * @param componentClass - The class of the component to get.
+   * @returns The single registered child of the given type.
+   */
+  getChild(componentClass) {
+    const child = this.getChildOrNull(componentClass);
+    if (child) {
+      return child;
+    }
+    throw new Error(`No instance of ${componentClass.name} registered`);
+  }
+  /**
+   * Get the single child of the given type.
+   *
+   * @typeParam TComponent - The type of component to get.
+   * @param componentClass - The class of the component to get.
+   * @returns The single registered child of the given type, or `null` if none are registered.
+   */
+  getChildOrNull(componentClass) {
+    const children = this.getChildren(componentClass);
+    if (children.length === 0) {
+      return null;
+    }
+    if (children.length === 1) {
+      return (0, import_type_guards.ensureNonNullable)(children[0]);
+    }
+    throw new Error(`Multiple instances of ${componentClass.name} registered`);
+  }
+  /**
+   * Get all children of the given type.
+   *
+   * @typeParam TComponent - The type of component to get.
+   * @param componentClass - The class of the component to get.
+   * @returns All registered children of the given type.
+   */
+  getChildren(componentClass) {
+    return this._children.filter((child) => child instanceof componentClass);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RegistryComponent
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2NvbXBvbmVudHMvcmVnaXN0cnktY29tcG9uZW50LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICoge0BsaW5rIFJlZ2lzdHJ5Q29tcG9uZW50fS5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7IENvbnN0cnVjdG9yIH0gZnJvbSAndHlwZS1mZXN0JztcblxuaW1wb3J0IHsgZW5zdXJlTm9uTnVsbGFibGUgfSBmcm9tICcuLi8uLi90eXBlLWd1YXJkcy50cyc7XG5pbXBvcnQgeyBDb21wb25lbnRFeCB9IGZyb20gJy4vY29tcG9uZW50LWV4LnRzJztcblxuLyoqXG4gKiBBIGNvbXBvbmVudCB0aGF0IGtlZXBzIHJlZ2lzdHJ5IG9mIGl0cyBjaGlsZHJlbi5cbiAqL1xuZXhwb3J0IGNsYXNzIFJlZ2lzdHJ5Q29tcG9uZW50IGV4dGVuZHMgQ29tcG9uZW50RXgge1xuICAvKipcbiAgICogR2V0IHRoZSBzaW5nbGUgY2hpbGQgb2YgdGhlIGdpdmVuIHR5cGUuXG4gICAqXG4gICAqIEB0eXBlUGFyYW0gVENvbXBvbmVudCAtIFRoZSB0eXBlIG9mIGNvbXBvbmVudCB0byBnZXQuXG4gICAqIEBwYXJhbSBjb21wb25lbnRDbGFzcyAtIFRoZSBjbGFzcyBvZiB0aGUgY29tcG9uZW50IHRvIGdldC5cbiAgICogQHJldHVybnMgVGhlIHNpbmdsZSByZWdpc3RlcmVkIGNoaWxkIG9mIHRoZSBnaXZlbiB0eXBlLlxuICAgKi9cbiAgcHVibGljIGdldENoaWxkPFRDb21wb25lbnQ+KGNvbXBvbmVudENsYXNzOiBDb25zdHJ1Y3RvcjxUQ29tcG9uZW50Pik6IFRDb21wb25lbnQge1xuICAgIGNvbnN0IGNoaWxkID0gdGhpcy5nZXRDaGlsZE9yTnVsbChjb21wb25lbnRDbGFzcyk7XG4gICAgaWYgKGNoaWxkKSB7XG4gICAgICByZXR1cm4gY2hpbGQ7XG4gICAgfVxuXG4gICAgdGhyb3cgbmV3IEVycm9yKGBObyBpbnN0YW5jZSBvZiAke2NvbXBvbmVudENsYXNzLm5hbWV9IHJlZ2lzdGVyZWRgKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBHZXQgdGhlIHNpbmdsZSBjaGlsZCBvZiB0aGUgZ2l2ZW4gdHlwZS5cbiAgICpcbiAgICogQHR5cGVQYXJhbSBUQ29tcG9uZW50IC0gVGhlIHR5cGUgb2YgY29tcG9uZW50IHRvIGdldC5cbiAgICogQHBhcmFtIGNvbXBvbmVudENsYXNzIC0gVGhlIGNsYXNzIG9mIHRoZSBjb21wb25lbnQgdG8gZ2V0LlxuICAgKiBAcmV0dXJucyBUaGUgc2luZ2xlIHJlZ2lzdGVyZWQgY2hpbGQgb2YgdGhlIGdpdmVuIHR5cGUsIG9yIGBudWxsYCBpZiBub25lIGFyZSByZWdpc3RlcmVkLlxuICAgKi9cbiAgcHVibGljIGdldENoaWxkT3JOdWxsPFRDb21wb25lbnQ+KGNvbXBvbmVudENsYXNzOiBDb25zdHJ1Y3RvcjxUQ29tcG9uZW50Pik6IG51bGwgfCBUQ29tcG9uZW50IHtcbiAgICBjb25zdCBjaGlsZHJlbiA9IHRoaXMuZ2V0Q2hpbGRyZW4oY29tcG9uZW50Q2xhc3MpO1xuICAgIGlmIChjaGlsZHJlbi5sZW5ndGggPT09IDApIHtcbiAgICAgIHJldHVybiBudWxsO1xuICAgIH1cblxuICAgIGlmIChjaGlsZHJlbi5sZW5ndGggPT09IDEpIHtcbiAgICAgIHJldHVybiBlbnN1cmVOb25OdWxsYWJsZShjaGlsZHJlblswXSk7XG4gICAgfVxuXG4gICAgdGhyb3cgbmV3IEVycm9yKGBNdWx0aXBsZSBpbnN0YW5jZXMgb2YgJHtjb21wb25lbnRDbGFzcy5uYW1lfSByZWdpc3RlcmVkYCk7XG4gIH1cblxuICAvKipcbiAgICogR2V0IGFsbCBjaGlsZHJlbiBvZiB0aGUgZ2l2ZW4gdHlwZS5cbiAgICpcbiAgICogQHR5cGVQYXJhbSBUQ29tcG9uZW50IC0gVGhlIHR5cGUgb2YgY29tcG9uZW50IHRvIGdldC5cbiAgICogQHBhcmFtIGNvbXBvbmVudENsYXNzIC0gVGhlIGNsYXNzIG9mIHRoZSBjb21wb25lbnQgdG8gZ2V0LlxuICAgKiBAcmV0dXJucyBBbGwgcmVnaXN0ZXJlZCBjaGlsZHJlbiBvZiB0aGUgZ2l2ZW4gdHlwZS5cbiAgICovXG4gIHB1YmxpYyBnZXRDaGlsZHJlbjxUQ29tcG9uZW50Pihjb21wb25lbnRDbGFzczogQ29uc3RydWN0b3I8VENvbXBvbmVudD4pOiBUQ29tcG9uZW50W10ge1xuICAgIHJldHVybiB0aGlzLl9jaGlsZHJlbi5maWx0ZXIoKGNoaWxkKSA9PiBjaGlsZCBpbnN0YW5jZW9mIGNvbXBvbmVudENsYXNzKSBhcyBUQ29tcG9uZW50W107XG4gIH1cbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQVFBLHlCQUFrQztBQUNsQywwQkFBNEI7QUFLckIsTUFBTSwwQkFBMEIsZ0NBQVk7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBUTFDLFNBQXFCLGdCQUFxRDtBQUMvRSxVQUFNLFFBQVEsS0FBSyxlQUFlLGNBQWM7QUFDaEQsUUFBSSxPQUFPO0FBQ1QsYUFBTztBQUFBLElBQ1Q7QUFFQSxVQUFNLElBQUksTUFBTSxrQkFBa0IsZUFBZSxJQUFJLGFBQWE7QUFBQSxFQUNwRTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFTTyxlQUEyQixnQkFBNEQ7QUFDNUYsVUFBTSxXQUFXLEtBQUssWUFBWSxjQUFjO0FBQ2hELFFBQUksU0FBUyxXQUFXLEdBQUc7QUFDekIsYUFBTztBQUFBLElBQ1Q7QUFFQSxRQUFJLFNBQVMsV0FBVyxHQUFHO0FBQ3pCLGlCQUFPLHNDQUFrQixTQUFTLENBQUMsQ0FBQztBQUFBLElBQ3RDO0FBRUEsVUFBTSxJQUFJLE1BQU0seUJBQXlCLGVBQWUsSUFBSSxhQUFhO0FBQUEsRUFDM0U7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBU08sWUFBd0IsZ0JBQXVEO0FBQ3BGLFdBQU8sS0FBSyxVQUFVLE9BQU8sQ0FBQyxVQUFVLGlCQUFpQixjQUFjO0FBQUEsRUFDekU7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/cjs/obsidian/components/registry-component.d.cts

@@ -0,0 +1,36 @@
+/**
+ * @file
+ *
+ * {@link RegistryComponent}.
+ */
+import type { Constructor } from 'type-fest';
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * A component that keeps registry of its children.
+ */
+export declare class RegistryComponent extends ComponentEx {
+    /**
+     * Get the single child of the given type.
+     *
+     * @typeParam TComponent - The type of component to get.
+     * @param componentClass - The class of the component to get.
+     * @returns The single registered child of the given type.
+     */
+    getChild<TComponent>(componentClass: Constructor<TComponent>): TComponent;
+    /**
+     * Get the single child of the given type.
+     *
+     * @typeParam TComponent - The type of component to get.
+     * @param componentClass - The class of the component to get.
+     * @returns The single registered child of the given type, or `null` if none are registered.
+     */
+    getChildOrNull<TComponent>(componentClass: Constructor<TComponent>): null | TComponent;
+    /**
+     * Get all children of the given type.
+     *
+     * @typeParam TComponent - The type of component to get.
+     * @param componentClass - The class of the component to get.
+     * @returns All registered children of the given type.
+     */
+    getChildren<TComponent>(componentClass: Constructor<TComponent>): TComponent[];
+}

package/dist/lib/cjs/obsidian/markdown.cjs

@@ -183,8 +183,7 @@ async function fullRender(params) {
     component.load();
     shouldUnloadComponent = true;
   }
-  using patch = new import_monkey_around_component.MonkeyAroundComponent();
-  patch.load();
+  using patch = component.addChild(new import_monkey_around_component.MonkeyAroundComponent());
   patch.registerMethodPatch({
     methodName: "md",
     obj: params.app.embedRegistry.embedByExtension,
@@ -268,4 +267,4 @@ async function renderInternalLink(app, pathOrAbstractFile, displayText) {
   renderExternalLink,
   renderInternalLink
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/markdown.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions for processing Markdown content in Obsidian.\n */\n\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\n\nimport type {\n  DomEventsHandlers,\n  DomEventsHandlersInfo\n} from '@obsidian-typings/obsidian-public-latest';\nimport type { ExtractConstructor } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport type { App } from 'obsidian';\n\nimport { InternalPluginName } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  Component,\n  HoverPopover,\n  MarkdownPreviewRenderer,\n  MarkdownRenderer\n} from 'obsidian';\n\nimport type { PathOrAbstractFile } from './file-system.ts';\n\nimport { getZIndex } from '../html-element.ts';\nimport { MonkeyAroundComponent } from './components/monkey-around-component.ts';\nimport { getDomEventsHandlersConstructor } from './constructors/getDomEventsHandlersConstructor.ts';\nimport {\n  getAbstractFileOrNull,\n  getPath,\n  isFolder\n} from './file-system.ts';\n\ntype DomEventsHandlersConstructor = ExtractConstructor<DomEventsHandlers>;\n\nlet domEventsHandlersConstructor: DomEventsHandlersConstructor | null = null;\n\n/**\n * The params for the full render.\n */\nexport interface FullRenderParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The Component instance to use for the render.\n   */\n  readonly component?: Component;\n\n  /**\n   * The HTMLElement to render to.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The Markdown string to render.\n   */\n  readonly markdown: string;\n\n  /**\n   * Whether to register link handlers for the rendered element.\n   */\n  readonly shouldRegisterLinkHandlers?: boolean;\n\n  /**\n   * The source path to resolve relative links.\n   */\n  readonly sourcePath?: string;\n}\n\ninterface FixedZIndexDomEventsHandlersInfoConstructorParams {\n  readonly app: App;\n  readonly el: HTMLElement;\n  readonly path: string;\n}\n\nclass FixedZIndexDomEventsHandlersInfo implements DomEventsHandlersInfo {\n  public readonly app: App;\n  public readonly el: HTMLElement;\n  public readonly path: string;\n\n  public get hoverPopover(): HoverPopover | null {\n    return this._hoverPopover;\n  }\n\n  public set hoverPopover(hoverPopover: HoverPopover | null) {\n    this._hoverPopover = hoverPopover;\n    if (hoverPopover && this.zIndex !== undefined) {\n      hoverPopover.hoverEl.setCssStyles({\n        zIndex: String(this.zIndex)\n      });\n    }\n  }\n\n  private _hoverPopover: HoverPopover | null = null;\n\n  private zIndex?: number;\n\n  public constructor(params: FixedZIndexDomEventsHandlersInfoConstructorParams) {\n    this.app = params.app;\n    this.path = params.path;\n    this.el = params.el;\n\n    if (this.el.isConnected) {\n      this.updateZIndex(this.el);\n    } else {\n      this.el.onNodeInserted(() => {\n        this.updateZIndex(this.el);\n      });\n    }\n  }\n\n  private updateZIndex(el: HTMLElement): void {\n    this.zIndex = getZIndex(el) + 1;\n  }\n}\n\n/**\n * Render the markdown and embeds.\n *\n * @param params - The parameters for the full render.\n * @returns The {@link Promise} that resolves when the full render is complete.\n */\nexport async function fullRender(params: FullRenderParams): Promise<void> {\n  const sourcePath = params.sourcePath ?? '/';\n  let shouldUnloadComponent = false;\n  let component: Component;\n  if (params.component) {\n    component = params.component;\n  } else {\n    component = new Component();\n    component.load();\n    shouldUnloadComponent = true;\n  }\n\n  using patch = new MonkeyAroundComponent();\n  patch.load();\n\n  patch.registerMethodPatch({\n    methodName: 'md',\n    obj: params.app.embedRegistry.embedByExtension,\n    patchHandler: ({\n      fallback,\n      originalArgs: [context]\n    }) => {\n      context.displayMode = false;\n      return fallback();\n    }\n  });\n\n  await MarkdownRenderer.render(params.app, params.markdown, params.el, sourcePath, component);\n\n  if (shouldUnloadComponent) {\n    component.unload();\n  }\n\n  if (params.shouldRegisterLinkHandlers) {\n    await registerLinkHandlers(params.app, params.el, params.sourcePath);\n  }\n}\n\n/**\n * Converts Markdown to HTML.\n *\n * @param app - The Obsidian app instance.\n * @param markdown - The Markdown string to convert.\n * @param sourcePath - (optional) The source path to resolve relative links.\n * @returns The HTML string.\n */\nexport async function markdownToHtml(app: App, markdown: string, sourcePath?: string): Promise<string> {\n  const component = new Component();\n  component.load();\n  const renderDiv = createDiv();\n  await MarkdownRenderer.render(app, markdown, renderDiv, sourcePath ?? '', component);\n  const html = renderDiv.innerHTML;\n  component.unload();\n  return html;\n}\n\n/**\n * Registers link handlers for the given element.\n *\n * @param app - The Obsidian app instance.\n * @param el - The HTMLElement to register link handlers for.\n * @param sourcePath - The source path to resolve relative links from.\n */\nexport async function registerLinkHandlers(app: App, el: HTMLElement, sourcePath?: string): Promise<void> {\n  // eslint-disable-next-line require-atomic-updates -- No race condition.\n  domEventsHandlersConstructor ??= await getDomEventsHandlersConstructor(app);\n  MarkdownPreviewRenderer.registerDomEvents(\n    el,\n    new domEventsHandlersConstructor(\n      new FixedZIndexDomEventsHandlersInfo({\n        app,\n        el,\n        path: sourcePath ?? ''\n      })\n    )\n  );\n}\n\n/**\n * Renders an external link.\n *\n * @param app - The Obsidian app instance.\n * @param url - The URL to render the external link for.\n * @param displayText - The text to display for the external link.\n * @returns The HTMLAnchorElement containing the rendered external link.\n */\nexport async function renderExternalLink(app: App, url: string, displayText?: string): Promise<HTMLAnchorElement> {\n  displayText ??= url;\n  const wrapperEl = createSpan();\n  await fullRender({\n    app,\n    el: wrapperEl,\n    markdown: `[${displayText}](${url})`\n  });\n  const aEl = wrapperEl.find('a') as HTMLAnchorElement;\n  await registerLinkHandlers(app, aEl);\n  return aEl;\n}\n\n/**\n * Renders an internal link.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrAbstractFile - The path or abstract file to render the internal link for.\n * @param displayText - The text to display for the internal link.\n * @returns The HTMLAnchorElement containing the rendered internal link.\n */\nexport async function renderInternalLink(app: App, pathOrAbstractFile: PathOrAbstractFile, displayText?: string): Promise<HTMLAnchorElement> {\n  const abstractFile = getAbstractFileOrNull(app, pathOrAbstractFile);\n  const path = getPath(app, pathOrAbstractFile);\n  displayText ??= path;\n  if (isFolder(abstractFile)) {\n    return createEl('a', { text: displayText }, (aEl) => {\n      aEl.addEventListener('click', (evt) => {\n        evt.preventDefault();\n        app.internalPlugins.getEnabledPluginById(InternalPluginName.FileExplorer)?.revealInFolder(abstractFile);\n      });\n    });\n  }\n\n  const wrapperEl = createSpan();\n  await fullRender({\n    app,\n    el: wrapperEl,\n    markdown: `[[${path}|${displayText}]]`\n  });\n  const aEl = wrapperEl.find('a') as HTMLAnchorElement;\n  await registerLinkHandlers(app, aEl);\n  return aEl;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["aEl"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/markdown.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions for processing Markdown content in Obsidian.\n */\n\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\n\nimport type {\n  DomEventsHandlers,\n  DomEventsHandlersInfo\n} from '@obsidian-typings/obsidian-public-latest';\nimport type { ExtractConstructor } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport type { App } from 'obsidian';\n\nimport { InternalPluginName } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  Component,\n  HoverPopover,\n  MarkdownPreviewRenderer,\n  MarkdownRenderer\n} from 'obsidian';\n\nimport type { PathOrAbstractFile } from './file-system.ts';\n\nimport { getZIndex } from '../html-element.ts';\nimport { MonkeyAroundComponent } from './components/monkey-around-component.ts';\nimport { getDomEventsHandlersConstructor } from './constructors/getDomEventsHandlersConstructor.ts';\nimport {\n  getAbstractFileOrNull,\n  getPath,\n  isFolder\n} from './file-system.ts';\n\ntype DomEventsHandlersConstructor = ExtractConstructor<DomEventsHandlers>;\n\nlet domEventsHandlersConstructor: DomEventsHandlersConstructor | null = null;\n\n/**\n * The params for the full render.\n */\nexport interface FullRenderParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The Component instance to use for the render.\n   */\n  readonly component?: Component;\n\n  /**\n   * The HTMLElement to render to.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The Markdown string to render.\n   */\n  readonly markdown: string;\n\n  /**\n   * Whether to register link handlers for the rendered element.\n   */\n  readonly shouldRegisterLinkHandlers?: boolean;\n\n  /**\n   * The source path to resolve relative links.\n   */\n  readonly sourcePath?: string;\n}\n\ninterface FixedZIndexDomEventsHandlersInfoConstructorParams {\n  readonly app: App;\n  readonly el: HTMLElement;\n  readonly path: string;\n}\n\nclass FixedZIndexDomEventsHandlersInfo implements DomEventsHandlersInfo {\n  public readonly app: App;\n  public readonly el: HTMLElement;\n  public readonly path: string;\n\n  public get hoverPopover(): HoverPopover | null {\n    return this._hoverPopover;\n  }\n\n  public set hoverPopover(hoverPopover: HoverPopover | null) {\n    this._hoverPopover = hoverPopover;\n    if (hoverPopover && this.zIndex !== undefined) {\n      hoverPopover.hoverEl.setCssStyles({\n        zIndex: String(this.zIndex)\n      });\n    }\n  }\n\n  private _hoverPopover: HoverPopover | null = null;\n\n  private zIndex?: number;\n\n  public constructor(params: FixedZIndexDomEventsHandlersInfoConstructorParams) {\n    this.app = params.app;\n    this.path = params.path;\n    this.el = params.el;\n\n    if (this.el.isConnected) {\n      this.updateZIndex(this.el);\n    } else {\n      this.el.onNodeInserted(() => {\n        this.updateZIndex(this.el);\n      });\n    }\n  }\n\n  private updateZIndex(el: HTMLElement): void {\n    this.zIndex = getZIndex(el) + 1;\n  }\n}\n\n/**\n * Render the markdown and embeds.\n *\n * @param params - The parameters for the full render.\n * @returns The {@link Promise} that resolves when the full render is complete.\n */\nexport async function fullRender(params: FullRenderParams): Promise<void> {\n  const sourcePath = params.sourcePath ?? '/';\n  let shouldUnloadComponent = false;\n  let component: Component;\n  if (params.component) {\n    component = params.component;\n  } else {\n    component = new Component();\n    component.load();\n    shouldUnloadComponent = true;\n  }\n\n  using patch = component.addChild(new MonkeyAroundComponent());\n\n  patch.registerMethodPatch({\n    methodName: 'md',\n    obj: params.app.embedRegistry.embedByExtension,\n    patchHandler: ({\n      fallback,\n      originalArgs: [context]\n    }) => {\n      context.displayMode = false;\n      return fallback();\n    }\n  });\n\n  await MarkdownRenderer.render(params.app, params.markdown, params.el, sourcePath, component);\n\n  if (shouldUnloadComponent) {\n    component.unload();\n  }\n\n  if (params.shouldRegisterLinkHandlers) {\n    await registerLinkHandlers(params.app, params.el, params.sourcePath);\n  }\n}\n\n/**\n * Converts Markdown to HTML.\n *\n * @param app - The Obsidian app instance.\n * @param markdown - The Markdown string to convert.\n * @param sourcePath - (optional) The source path to resolve relative links.\n * @returns The HTML string.\n */\nexport async function markdownToHtml(app: App, markdown: string, sourcePath?: string): Promise<string> {\n  const component = new Component();\n  component.load();\n  const renderDiv = createDiv();\n  await MarkdownRenderer.render(app, markdown, renderDiv, sourcePath ?? '', component);\n  const html = renderDiv.innerHTML;\n  component.unload();\n  return html;\n}\n\n/**\n * Registers link handlers for the given element.\n *\n * @param app - The Obsidian app instance.\n * @param el - The HTMLElement to register link handlers for.\n * @param sourcePath - The source path to resolve relative links from.\n */\nexport async function registerLinkHandlers(app: App, el: HTMLElement, sourcePath?: string): Promise<void> {\n  // eslint-disable-next-line require-atomic-updates -- No race condition.\n  domEventsHandlersConstructor ??= await getDomEventsHandlersConstructor(app);\n  MarkdownPreviewRenderer.registerDomEvents(\n    el,\n    new domEventsHandlersConstructor(\n      new FixedZIndexDomEventsHandlersInfo({\n        app,\n        el,\n        path: sourcePath ?? ''\n      })\n    )\n  );\n}\n\n/**\n * Renders an external link.\n *\n * @param app - The Obsidian app instance.\n * @param url - The URL to render the external link for.\n * @param displayText - The text to display for the external link.\n * @returns The HTMLAnchorElement containing the rendered external link.\n */\nexport async function renderExternalLink(app: App, url: string, displayText?: string): Promise<HTMLAnchorElement> {\n  displayText ??= url;\n  const wrapperEl = createSpan();\n  await fullRender({\n    app,\n    el: wrapperEl,\n    markdown: `[${displayText}](${url})`\n  });\n  const aEl = wrapperEl.find('a') as HTMLAnchorElement;\n  await registerLinkHandlers(app, aEl);\n  return aEl;\n}\n\n/**\n * Renders an internal link.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrAbstractFile - The path or abstract file to render the internal link for.\n * @param displayText - The text to display for the internal link.\n * @returns The HTMLAnchorElement containing the rendered internal link.\n */\nexport async function renderInternalLink(app: App, pathOrAbstractFile: PathOrAbstractFile, displayText?: string): Promise<HTMLAnchorElement> {\n  const abstractFile = getAbstractFileOrNull(app, pathOrAbstractFile);\n  const path = getPath(app, pathOrAbstractFile);\n  displayText ??= path;\n  if (isFolder(abstractFile)) {\n    return createEl('a', { text: displayText }, (aEl) => {\n      aEl.addEventListener('click', (evt) => {\n        evt.preventDefault();\n        app.internalPlugins.getEnabledPluginById(InternalPluginName.FileExplorer)?.revealInFolder(abstractFile);\n      });\n    });\n  }\n\n  const wrapperEl = createSpan();\n  await fullRender({\n    app,\n    el: wrapperEl,\n    markdown: `[[${path}|${displayText}]]`\n  });\n  const aEl = wrapperEl.find('a') as HTMLAnchorElement;\n  await registerLinkHandlers(app, aEl);\n  return aEl;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["aEl"]
}


package/dist/lib/cjs/obsidian/menu-event-registrar.cjs

@@ -121,4 +121,4 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var menu_event_registrar_exports = {};
 module.exports = __toCommonJS(menu_event_registrar_exports);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/obsidian/menu-event-registrar.d.cts

@@ -33,7 +33,6 @@ export type FilesMenuEventHandler = (menu: Menu, abstractFiles: TAbstractFile[],
 /**
  * Registers menu event handlers with lifecycle management.
  */
-/** */
 export interface MenuEventRegistrar {
     /**
      * Registers a handler for the editor context menu event.