obsidian-dev-utils 101.5.0 → 101.7.0

package/dist/lib/esm/obsidian/plugin/plugin.mjs

@@ -57,13 +57,20 @@ import { ConsoleDebugComponent } from "../components/console-debug-component.mjs
 import { MenuEventRegistrarComponent } from "../components/menu-event-registrar-component.mjs";
 import { NotebookNavigatorMenuEventRegistrarComponent } from "../components/notebook-navigator-menu-event-registrar-component.mjs";
 import { PluginContextComponent } from "../components/plugin-context-component.mjs";
+import { PluginGateComponent } from "../components/plugin-gate-component.mjs";
 import { PluginNoticeComponent } from "../components/plugin-notice-component.mjs";
 import { PluginSettingsComponentBase } from "../components/plugin-settings-component.mjs";
 import { PluginDataHandler } from "../data-handler.mjs";
 import { initI18N } from "../i18n/i18n.mjs";
 import { defaultTranslationsMap } from "../i18n/locales/translations-map.mjs";
 import { ResourceLockComponent } from "../resource-lock.mjs";
+import { publishPluginApi } from "./plugin-api.mjs";
 import { PluginEventSourceImpl } from "./plugin-event-source.mjs";
+import {
+  PLUGIN_LOADED_EVENT_NAME,
+  PLUGIN_UNLOADED_EVENT_NAME,
+  triggerPluginLifecycleEvent
+} from "./plugin-lifecycle-events.mjs";
 class PluginBase extends mixinAsyncEvents()(Plugin) {
   /**
    * Gets abort signal component.
@@ -148,6 +155,26 @@ class PluginBase extends mixinAsyncEvents()(Plugin) {
   set pluginContextComponent(value) {
     this.setComponent("pluginContextComponent", value);
   }
+  /**
+   * Gets the gate holding the plugin's feature surface up or down.
+   *
+   * Reach for it from a settings tab to render the overlap banner for a
+   * {@link obsidian/components/plugin-gate-component!PluginConflictSeverity.Warn} conflict — the one
+   * banner the library cannot place itself, because a running plugin builds its own settings tab.
+   *
+   * @returns The plugin gate component.
+   */
+  get pluginGateComponent() {
+    return ensureNonNullable(this.components.pluginGateComponent);
+  }
+  /**
+   * Sets the plugin gate component.
+   *
+   * @param value - The plugin gate component.
+   */
+  set pluginGateComponent(value) {
+    this.setComponent("pluginGateComponent", value);
+  }
   /**
    * Gets plugin notice component.
    *
@@ -198,20 +225,45 @@ class PluginBase extends mixinAsyncEvents()(Plugin) {
     this.setComponent("resourceLockComponent", value);
   }
   components = {};
-  wrapperComponent = new ComponentEx();
+  // Everything the SUBCLASS owns: what `onloadImpl` adds, and what it adds later.
+  //
+  // A second wrapper rather than one, because the two tiers have opposite lifetimes. The universal
+  // Components have to OUTLIVE a lost dependency — they are what shows the notice naming the plugin that
+  // Went away and renders the button that brings it back — while the subclass's surface is exactly what
+  // Must stop running. Unloading one wrapper holding both would silence the plugin at the moment it most
+  // Needs to speak.
+  //
+  // Always present, never null, and REPLACED rather than emptied when the surface is torn down. That keeps
+  // `addChild` callable at every point in the plugin's life, exactly as it was before the tiers existed:
+  // A child added before the gate opens is queued and loaded when it does, which is what `ComponentEx`
+  // Already does for any child added to a not-yet-loaded component.
+  gatedWrapperComponent = new ComponentEx();
+  // The payload broadcast when this plugin finished loading, kept so the matching unloaded broadcast
+  // Describes the same plugin without re-deriving it from a surface that has since been torn down. Null
+  // Whenever no loaded broadcast is outstanding, which is what keeps the two events paired.
+  lifecycleEventPayload = null;
+  // The library's own components, which outlive any dependency.
+  universalWrapperComponent = new ComponentEx();
   /**
    * Adds a child component.
    *
-   * The child is added to an internal wrapper component, which {@link onload} attaches and loads
-   * before wiring anything up. So a child added during {@link onloadImpl} is loaded immediately,
-   * children-first, and is usable by the time this method returns.
+   * The child is added to the internal wrapper holding the subclass's own surface, which {@link onload}
+   * creates and loads before calling {@link onloadImpl}. So a child added during {@link onloadImpl} is
+   * loaded immediately, children-first, and is usable by the time this method returns.
+   *
+   * That wrapper is torn down and rebuilt whenever the gate closes and opens again — a dependency declared
+   * by {@link getPluginDependencies} going away and coming back, or a conflict declared by
+   * {@link getPluginConflicts} appearing and being resolved — so a child added here lives exactly as long
+   * as the plugin's feature surface does. Adding one while the surface is down is still legitimate — it is
+   * queued and loaded when the surface next comes up, the way {@link ComponentEx.addChild} already queues
+   * a child added to a not-yet-loaded component.
    *
    * @typeParam TComponent - The type of component to add.
    * @param component - The component instance to add.
    * @returns The added component.
    */
   addChild(component) {
-    return this.wrapperComponent.addChild(component);
+    return this.gatedWrapperComponent.addChild(component);
   }
   /**
    * Called when the external settings change.
@@ -233,38 +285,38 @@ class PluginBase extends mixinAsyncEvents()(Plugin) {
    */
   async onload() {
     try {
-      super.addChild(this.wrapperComponent);
-      this.wrapperComponent.load();
+      super.addChild(this.universalWrapperComponent);
+      this.universalWrapperComponent.load();
       await initI18N(this.createTranslationsMap());
-      this.pluginContextComponent = this.addChild(
+      this.pluginContextComponent = this.addUniversalChild(
         new PluginContextComponent({
           app: this.app,
           pluginId: this.manifest.id
         })
       );
-      this.pluginNoticeComponent = this.addChild(
+      this.pluginNoticeComponent = this.addUniversalChild(
         new PluginNoticeComponent({
           app: this.app,
           pluginName: this.manifest.name
         })
       );
-      this.asyncErrorHandlerComponent = this.addChild(new AsyncErrorHandlerComponent(this.pluginNoticeComponent));
-      this.abortSignalComponent = this.addChild(new AbortSignalComponent(this.manifest.id));
-      this.consoleDebugComponent = this.addChild(new ConsoleDebugComponent(this.manifest.id));
-      this.resourceLockComponent = this.addChild(new ResourceLockComponent(this.app, this.manifest.id));
-      const notebookNavigatorMenuEventRegistrarComponent = this.addChild(
+      this.asyncErrorHandlerComponent = this.addUniversalChild(new AsyncErrorHandlerComponent(this.pluginNoticeComponent));
+      this.abortSignalComponent = this.addUniversalChild(new AbortSignalComponent(this.manifest.id));
+      this.consoleDebugComponent = this.addUniversalChild(new ConsoleDebugComponent(this.manifest.id));
+      this.resourceLockComponent = this.addUniversalChild(new ResourceLockComponent(this.app, this.manifest.id));
+      const notebookNavigatorMenuEventRegistrarComponent = this.addUniversalChild(
         new NotebookNavigatorMenuEventRegistrarComponent({
           app: this.app,
           pluginName: this.manifest.name,
           submenuIcon: this.getNotebookNavigatorMenuSubmenuIcon()
         })
       );
-      this.commandHandlerComponent = this.addChild(
+      this.commandHandlerComponent = this.addUniversalChild(
         new CommandHandlerComponent({
           activeFileProvider: new AppActiveFileProvider(this.app),
           additionalMenuEventRegistrars: [notebookNavigatorMenuEventRegistrarComponent],
           commandRegistrar: new PluginCommandRegistrar(this),
-          menuEventRegistrar: this.addChild(new MenuEventRegistrarComponent(this.app)),
+          menuEventRegistrar: this.addUniversalChild(new MenuEventRegistrarComponent(this.app)),
           pluginName: this.manifest.name
         })
       );
@@ -274,20 +326,43 @@ class PluginBase extends mixinAsyncEvents()(Plugin) {
           resourceLockComponent: this.resourceLockComponent
         })
       ]);
-      this.pluginSettingsComponent = this.addChild(
+      this.pluginSettingsComponent = this.addUniversalChild(
         new PluginSettingsComponentBase({
           dataHandler: new PluginDataHandler(this),
           pluginEventSource: new PluginEventSourceImpl(this),
           pluginSettingsClass: Object
         })
       );
-      await this.onloadImpl();
-      await this.wrapperComponent.loadWithPromises();
+      this.pluginGateComponent = this.addUniversalChild(
+        new PluginGateComponent({
+          conflicts: this.getPluginConflicts(),
+          dependencies: this.getPluginDependencies(),
+          loadFeatureSurface: () => this.loadFeatureSurface(),
+          plugin: this,
+          pluginNoticeComponent: this.pluginNoticeComponent,
+          unloadFeatureSurface: () => {
+            this.unloadFeatureSurface();
+          }
+        })
+      );
+      await this.universalWrapperComponent.loadWithPromises();
     } catch (error) {
       printError(new Error(`Error loading plugin ${this.manifest.name} (${this.manifest.id})`, { cause: error }));
       throw error;
     }
   }
+  /**
+   * Called when the plugin is unloaded.
+   *
+   * Announces the departure on `app.workspace` so anything depending on this plugin learns of it at the
+   * moment it happens, rather than discovering it later through behavior that quietly stopped.
+   *
+   * Do NOT override this method; put teardown on a component instead, which unloads with the plugin.
+   */
+  onunload() {
+    this.broadcastUnloaded();
+    super.onunload();
+  }
   /**
    * Removes a child component.
    *
@@ -296,7 +371,10 @@ class PluginBase extends mixinAsyncEvents()(Plugin) {
    * @returns The removed component.
    */
   removeChild(component) {
-    return this.wrapperComponent.removeChild(component);
+    if (this.gatedWrapperComponent.hasChild(component)) {
+      return this.gatedWrapperComponent.removeChild(component);
+    }
+    return this.universalWrapperComponent.removeChild(component);
   }
   /**
    * Provides the translations map used to initialize i18n during {@link onload}.
@@ -321,6 +399,68 @@ class PluginBase extends mixinAsyncEvents()(Plugin) {
   getNotebookNavigatorMenuSubmenuIcon() {
     return "";
   }
+  /**
+   * Provides the APIs this plugin exposes to other plugins.
+   *
+   * Override in subclass to publish one. The default publishes none. Called after {@link onloadImpl}, so a
+   * declaration may reference anything it created; the returned declarations are published through
+   * `publishPluginApi` and revoked when the plugin's feature surface unloads.
+   *
+   * Returning a LIST rather than a single API is deliberate: the registry supports several contract
+   * versions published side by side, which is how a provider ships a breaking `2.0.0` without stranding
+   * consumers still pinned to `^1`.
+   *
+   * Every declaration here is published BEFORE the `obsidian-dev-utils:plugin-loaded` broadcast, which is
+   * what lets a listener call these APIs the moment it hears that event.
+   *
+   * @returns The API declarations.
+   */
+  getPluginApis() {
+    return [];
+  }
+  /**
+   * Provides the plugins this one refuses, or warns about, running beside.
+   *
+   * Override in subclass to declare an overlap. The default declares none.
+   *
+   * A `Block` conflict is the mirror image of a dependency: while a conflicting plugin is enabled at a
+   * conflicting version, {@link onloadImpl} does not run at all and the plugin registers nothing. Declare
+   * it when both plugins acting on the same operation damages the vault — there is no reliable way to win
+   * that race, because whichever plugin loaded first keeps a hand on the wheel, so refusing deterministically
+   * beats competing unpredictably. A `Warn` conflict declares an overlap that is merely annoying, such as a
+   * duplicated command: both plugins keep running and the user is told.
+   *
+   * Unlike a dependency, a conflicting plugin need not publish anything — it is detected by reading its
+   * installed version, which is the only thing about another plugin that reads the same regardless of load
+   * order.
+   *
+   * @returns The declared conflicts.
+   */
+  getPluginConflicts() {
+    return [];
+  }
+  /**
+   * Provides the plugins this one cannot work without.
+   *
+   * Override in subclass to declare a mandatory dependency. The default declares none, and such a plugin
+   * loads exactly as it always has.
+   *
+   * A declared dependency is MANDATORY, unlike the offer `PluginSuggestionComponent` makes: while one is
+   * missing, disabled, or too old, {@link onloadImpl} does not run at all and the plugin registers nothing
+   * — no commands, no handlers, no patches. It stays enabled in Obsidian's list rather than disabling
+   * itself, because the enabled set is the user's to change, and it explains itself through a notice and a
+   * settings banner that installs the missing plugin in one click. The load completes the moment the
+   * dependency arrives, with no restart.
+   *
+   * A dependency must publish an API through `publishPluginApi`, which is what makes its presence,
+   * absence, version and departure all observable through one mechanism. A plugin with nothing to expose
+   * can publish an empty API purely so it can be depended upon.
+   *
+   * @returns The declared dependencies.
+   */
+  getPluginDependencies() {
+    return [];
+  }
   /**
    * Called during {@link onload} to wire plugin-specific child components.
    *
@@ -343,6 +483,81 @@ class PluginBase extends mixinAsyncEvents()(Plugin) {
    * @param key - The key of the component to store.
    * @param value - The component to store.
    */
+  /**
+   * Adds a component to the universal tier, which outlives any dependency.
+   *
+   * Private on purpose: only this class decides what is universal. A subclass adding one of its own goes
+   * through {@link addChild} and lands in the gated tier, where it belongs.
+   *
+   * @typeParam TComponent - The type of component to add.
+   * @param component - The component instance to add.
+   * @returns The added component.
+   */
+  addUniversalChild(component) {
+    return this.universalWrapperComponent.addChild(component);
+  }
+  /**
+   * Announces on `app.workspace` that this plugin is loaded and its APIs are callable.
+   */
+  broadcastLoaded() {
+    this.lifecycleEventPayload = {
+      apiVersions: this.getPluginApis().map((declaration) => declaration.apiVersion),
+      dependencyPluginIds: this.getPluginDependencies().map((dependency) => dependency.pluginId),
+      pluginId: this.manifest.id,
+      pluginName: this.manifest.name,
+      pluginVersion: this.manifest.version
+    };
+    triggerPluginLifecycleEvent({
+      app: this.app,
+      name: PLUGIN_LOADED_EVENT_NAME,
+      payload: this.lifecycleEventPayload
+    });
+  }
+  /**
+   * Announces on `app.workspace` that this plugin's surface has gone away.
+   *
+   * Silent unless a loaded broadcast is outstanding, so the two events stay paired: a plugin that never
+   * got past its dependency gate never announced itself, and must not announce a departure either.
+   */
+  broadcastUnloaded() {
+    const payload = this.lifecycleEventPayload;
+    if (!payload) {
+      return;
+    }
+    this.lifecycleEventPayload = null;
+    triggerPluginLifecycleEvent({
+      app: this.app,
+      name: PLUGIN_UNLOADED_EVENT_NAME,
+      payload
+    });
+  }
+  /**
+   * Builds and loads the subclass's feature surface, then publishes its APIs and announces itself.
+   *
+   * NOT idempotent, deliberately. `PluginGateComponent` owns the up/down state machine and calls
+   * this only on a real transition; a second guard here would be a second copy of that state, which is the
+   * kind of duplicate that drifts.
+   *
+   * @returns A {@link Promise} that resolves once the surface is loaded and the broadcast has been made.
+   */
+  async loadFeatureSurface() {
+    const gatedWrapperComponent = this.gatedWrapperComponent;
+    this.universalWrapperComponent.addChild(gatedWrapperComponent);
+    gatedWrapperComponent.load();
+    await this.onloadImpl();
+    await gatedWrapperComponent.loadWithPromises();
+    for (const declaration of this.getPluginApis()) {
+      publishPluginApi({
+        ...declaration,
+        // Revoked with the SURFACE, not with the plugin: a plugin whose dependency goes away keeps running
+        // Its universal components, and a consumer must not be left holding a handle into the half of it
+        // That was just torn down.
+        component: gatedWrapperComponent,
+        plugin: this
+      });
+    }
+    this.broadcastLoaded();
+  }
   setComponent(key, value) {
     const oldComponent = this.components[key];
     if (oldComponent) {
@@ -350,6 +565,15 @@ class PluginBase extends mixinAsyncEvents()(Plugin) {
     }
     this.components[key] = value;
   }
+  /**
+   * Tears the subclass's feature surface down, leaving the universal components running.
+   */
+  unloadFeatureSurface() {
+    const gatedWrapperComponent = this.gatedWrapperComponent;
+    this.gatedWrapperComponent = new ComponentEx();
+    this.universalWrapperComponent.removeChild(gatedWrapperComponent);
+    this.broadcastUnloaded();
+  }
 }
 async function reloadPlugin(plugin) {
   const plugins = plugin.app.plugins;
@@ -371,4 +595,4 @@ export {
   reloadPlugin,
   showErrorAndDisablePlugin
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Base class for Obsidian plugins using a component-based architecture.\n *\n * PluginBase registers universal components (context, i18n, error handling, abort signal, lifecycle events, debug).\n */\n\nimport type {\n  Component,\n  IconName\n} from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { Plugin } from 'obsidian';\n\nimport type { TranslationsMap } from '../i18n/i18n.ts';\nimport type {\n  PluginEventMap,\n  PluginEventSource\n} from './plugin-event-source.ts';\n\nimport { mixinAsyncEvents } from '../../async-events.ts';\nimport { printError } from '../../error.ts';\nimport { noopAsync } from '../../function.ts';\nimport { ensureNonNullable } from '../../type-guards.ts';\nimport { AppActiveFileProvider } from '../active-file-provider.ts';\nimport { CommandHandlerComponent } from '../command-handlers/command-handler-component.ts';\nimport { UnlockActiveNoteCommandHandler } from '../command-handlers/unlock-active-note-command-handler.ts';\nimport { PluginCommandRegistrar } from '../command-registrar.ts';\nimport { AbortSignalComponent } from '../components/abort-signal-component.ts';\nimport { AsyncErrorHandlerComponent } from '../components/async-error-handler-component.ts';\nimport { ComponentEx } from '../components/component-ex.ts';\nimport { ConsoleDebugComponent } from '../components/console-debug-component.ts';\nimport { MenuEventRegistrarComponent } from '../components/menu-event-registrar-component.ts';\nimport { NotebookNavigatorMenuEventRegistrarComponent } from '../components/notebook-navigator-menu-event-registrar-component.ts';\nimport { PluginContextComponent } from '../components/plugin-context-component.ts';\nimport { PluginNoticeComponent } from '../components/plugin-notice-component.ts';\nimport { PluginSettingsComponentBase } from '../components/plugin-settings-component.ts';\nimport { PluginDataHandler } from '../data-handler.ts';\nimport { initI18N } from '../i18n/i18n.ts';\nimport { defaultTranslationsMap } from '../i18n/locales/translations-map.ts';\nimport { ResourceLockComponent } from '../resource-lock.ts';\nimport { PluginEventSourceImpl } from './plugin-event-source.ts';\n\n/**\n * The universal components owned by {@link PluginBase}, keyed by the name of the accessor exposing\n * each one. Every member is optional because a component only exists once {@link PluginBase.onload}\n * has created it.\n */\ninterface PluginBaseComponents {\n  abortSignalComponent?: AbortSignalComponent;\n  asyncErrorHandlerComponent?: AsyncErrorHandlerComponent;\n  commandHandlerComponent?: CommandHandlerComponent;\n  consoleDebugComponent?: ConsoleDebugComponent;\n  pluginContextComponent?: PluginContextComponent;\n  pluginNoticeComponent?: PluginNoticeComponent;\n  pluginSettingsComponent?: PluginSettingsComponentBase<object>;\n  resourceLockComponent?: ResourceLockComponent;\n}\n\n/**\n * Base class for creating Obsidian plugins with a component-based architecture.\n *\n * Registers universal components automatically. Subclasses add or replace components\n * via {@link removeChild} / {@link addChild}.\n */\nexport abstract class PluginBase extends mixinAsyncEvents<PluginEventMap>()(Plugin) implements PluginEventSource {\n  /**\n   * Gets abort signal component.\n   *\n   * @returns abort signal component.\n   */\n  protected get abortSignalComponent(): AbortSignalComponent {\n    return ensureNonNullable(this.components.abortSignalComponent);\n  }\n\n  /**\n   * Sets abort signal component.\n   *\n   * @param value - Abort signal component.\n   */\n  protected set abortSignalComponent(value: AbortSignalComponent) {\n    this.setComponent('abortSignalComponent', value);\n  }\n\n  /**\n   * Gets async error handler component.\n   *\n   * @returns async error handler component.\n   */\n  protected get asyncErrorHandlerComponent(): AsyncErrorHandlerComponent {\n    return ensureNonNullable(this.components.asyncErrorHandlerComponent);\n  }\n\n  /**\n   * Sets async error handler component.\n   *\n   * @param value - Async error handler component.\n   */\n  protected set asyncErrorHandlerComponent(value: AsyncErrorHandlerComponent) {\n    this.setComponent('asyncErrorHandlerComponent', value);\n  }\n\n  /**\n   * Gets the shared command handler component. Register a plugin's commands on it via\n   * {@link CommandHandlerComponent.registerCommandHandlers} rather than constructing your own\n   * {@link CommandHandlerComponent} \u2014 the app-backed active-file provider, command registrar, menu\n   * event registrar, and plugin name are already wired.\n   *\n   * @returns The command handler component.\n   */\n  protected get commandHandlerComponent(): CommandHandlerComponent {\n    return ensureNonNullable(this.components.commandHandlerComponent);\n  }\n\n  /**\n   * Sets the command handler component.\n   *\n   * @param value - The command handler component.\n   */\n  protected set commandHandlerComponent(value: CommandHandlerComponent) {\n    this.setComponent('commandHandlerComponent', value);\n  }\n\n  /**\n   * Gets console debug component.\n   *\n   * @returns console debug component.\n   */\n  protected get consoleDebugComponent(): ConsoleDebugComponent {\n    return ensureNonNullable(this.components.consoleDebugComponent);\n  }\n\n  /**\n   * Sets console debug component.\n   *\n   * @param value - Console debug component.\n   */\n  protected set consoleDebugComponent(value: ConsoleDebugComponent) {\n    this.setComponent('consoleDebugComponent', value);\n  }\n\n  /**\n   * Gets plugin context component (plugin ID, debug controller, library styles).\n   *\n   * @returns plugin context component.\n   */\n  protected get pluginContextComponent(): PluginContextComponent {\n    return ensureNonNullable(this.components.pluginContextComponent);\n  }\n\n  /**\n   * Sets plugin context component.\n   *\n   * @param value - Plugin context component.\n   */\n  protected set pluginContextComponent(value: PluginContextComponent) {\n    this.setComponent('pluginContextComponent', value);\n  }\n\n  /**\n   * Gets plugin notice component.\n   *\n   * @returns plugin notice component.\n   */\n  protected get pluginNoticeComponent(): PluginNoticeComponent {\n    return ensureNonNullable(this.components.pluginNoticeComponent);\n  }\n\n  /**\n   * Sets plugin notice component.\n   *\n   * @param value - Plugin notice component.\n   */\n  protected set pluginNoticeComponent(value: PluginNoticeComponent) {\n    this.setComponent('pluginNoticeComponent', value);\n  }\n\n  /**\n   * Gets plugin settings component.\n   *\n   * @returns plugin settings component.\n   */\n  protected get pluginSettingsComponent(): PluginSettingsComponentBase<object> {\n    return ensureNonNullable(this.components.pluginSettingsComponent);\n  }\n\n  /**\n   * Sets plugin settings component.\n   *\n   * @param value - Plugin settings component.\n   */\n  protected set pluginSettingsComponent(value: PluginSettingsComponentBase<object>) {\n    this.setComponent('pluginSettingsComponent', value);\n  }\n\n  /**\n   * Gets the editor lock component, used to lock notes read-only during long operations. Owned by\n   * the plugin, so its locks are released automatically when the plugin unloads.\n   *\n   * @returns Editor lock component.\n   */\n  protected get resourceLockComponent(): ResourceLockComponent {\n    return ensureNonNullable(this.components.resourceLockComponent);\n  }\n\n  /**\n   * Sets the editor lock component.\n   *\n   * @param value - Editor lock component.\n   */\n  protected set resourceLockComponent(value: ResourceLockComponent) {\n    this.setComponent('resourceLockComponent', value);\n  }\n\n  private readonly components: PluginBaseComponents = {};\n\n  private readonly wrapperComponent = new ComponentEx();\n\n  /**\n   * Adds a child component.\n   *\n   * The child is added to an internal wrapper component, which {@link onload} attaches and loads\n   * before wiring anything up. So a child added during {@link onloadImpl} is loaded immediately,\n   * children-first, and is usable by the time this method returns.\n   *\n   * @typeParam TComponent - The type of component to add.\n   * @param component - The component instance to add.\n   * @returns The added component.\n   */\n  public override addChild<TComponent extends Component>(component: TComponent): TComponent {\n    return this.wrapperComponent.addChild(component);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * Override in subclass if needed. Make sure to call `await super.onExternalSettingsChange()` first.\n   */\n  public override async onExternalSettingsChange(): Promise<void> {\n    await super.onExternalSettingsChange?.();\n    await this.triggerAsync('externalSettingsChange');\n  }\n\n  /**\n   * Called when the plugin is loaded.\n   *\n   * Orchestrates loading: registers the universal components, lets the subclass wire its own\n   * components via {@link onloadImpl}, then awaits the async tail of every load.\n   * Each component loads as it is added, children-first.\n   *\n   * Do NOT override this method. Override {@link onloadImpl} instead.\n   */\n  public override async onload(): Promise<void> {\n    try {\n      // The wrapper is attached and loaded before anything is wired up, so every `addChild` below\n      // Loads its child straight away rather than queuing it.\n      // That is what lets a command handler register its menu events from `onRegistered`, which\n      // `registerCommandHandlers` awaits and which a registrar refuses while unloaded.\n      // Attaching it up front also registers the wrapper for teardown before anything can throw.\n      // The load is explicit rather than left to `addChild`, which loads the child only when the\n      // Plugin itself is loaded \u2014 true when Obsidian calls `load()`, but not when a caller invokes\n      // `onload()` directly.\n      super.addChild(this.wrapperComponent);\n      this.wrapperComponent.load();\n\n      await initI18N(this.createTranslationsMap());\n      this.pluginContextComponent = this.addChild(\n        new PluginContextComponent({\n          app: this.app,\n          pluginId: this.manifest.id\n        })\n      );\n      this.pluginNoticeComponent = this.addChild(\n        new PluginNoticeComponent({\n          app: this.app,\n          pluginName: this.manifest.name\n        })\n      );\n      this.asyncErrorHandlerComponent = this.addChild(new AsyncErrorHandlerComponent(this.pluginNoticeComponent));\n      this.abortSignalComponent = this.addChild(new AbortSignalComponent(this.manifest.id));\n      this.consoleDebugComponent = this.addChild(new ConsoleDebugComponent(this.manifest.id));\n      this.resourceLockComponent = this.addChild(new ResourceLockComponent(this.app, this.manifest.id));\n      // Notebook Navigator draws its own file tree and never raises Obsidian's `file-menu` /\n      // `files-menu` events, so every plugin's context-menu items would vanish for anyone browsing\n      // Through it. Wired here rather than per-plugin: the bridge stays dormant when Notebook\n      // Navigator is not installed, and a plugin with no file/folder handlers contributes nothing.\n      const notebookNavigatorMenuEventRegistrarComponent = this.addChild(\n        new NotebookNavigatorMenuEventRegistrarComponent({\n          app: this.app,\n          pluginName: this.manifest.name,\n          submenuIcon: this.getNotebookNavigatorMenuSubmenuIcon()\n        })\n      );\n      this.commandHandlerComponent = this.addChild(\n        new CommandHandlerComponent({\n          activeFileProvider: new AppActiveFileProvider(this.app),\n          additionalMenuEventRegistrars: [notebookNavigatorMenuEventRegistrarComponent],\n          commandRegistrar: new PluginCommandRegistrar(this),\n          menuEventRegistrar: this.addChild(new MenuEventRegistrarComponent(this.app)),\n          pluginName: this.manifest.name\n        })\n      );\n      // Always available; the command's own `canExecute` hides it unless the active note is locked.\n      await this.commandHandlerComponent.registerCommandHandlers(() => [\n        new UnlockActiveNoteCommandHandler({\n          app: this.app,\n          resourceLockComponent: this.resourceLockComponent\n        })\n      ]);\n\n      this.pluginSettingsComponent = this.addChild(\n        new PluginSettingsComponentBase<object>({\n          dataHandler: new PluginDataHandler(this),\n          pluginEventSource: new PluginEventSourceImpl(this),\n          pluginSettingsClass: Object\n        })\n      );\n\n      await this.onloadImpl();\n\n      // Every child has already loaded as it was added; this awaits their accumulated async tails and\n      // Reports any failure as a single `AggregateError`.\n      await this.wrapperComponent.loadWithPromises();\n    } catch (error) {\n      printError(new Error(`Error loading plugin ${this.manifest.name} (${this.manifest.id})`, { cause: error }));\n      throw error;\n    }\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    return this.wrapperComponent.removeChild(component);\n  }\n\n  /**\n   * Provides the translations map used to initialize i18n during {@link onload}.\n   *\n   * Override in subclass to supply plugin-specific translations. The default returns the built-in\n   * `obsidian-dev-utils` translations.\n   *\n   * @returns The translations map.\n   */\n  protected createTranslationsMap(): TranslationsMap {\n    return defaultTranslationsMap;\n  }\n\n  /**\n   * Provides the icon shown on the plugin's parent entry in Notebook Navigator's context menus.\n   *\n   * Override in subclass to brand that entry; the default leaves it without an icon. The entry is\n   * titled with the plugin name and is added automatically \u2014 see\n   * {@link NotebookNavigatorMenuEventRegistrarComponent}.\n   *\n   * @returns The icon, or `''` for no icon.\n   */\n  protected getNotebookNavigatorMenuSubmenuIcon(): IconName {\n    return '';\n  }\n\n  /**\n   * Called during {@link onload} to wire plugin-specific child components.\n   *\n   * Override in subclass to add child components via {@link addChild}. The universal components are\n   * available here. Children are loaded sequentially in the order they are added (children-first).\n   *\n   * @returns A {@link Promise} that resolves when the subclass load logic is complete.\n   */\n  protected onloadImpl(): Promisable<void> {\n    return noopAsync();\n  }\n\n  /**\n   * Stores a universal component, unloading whichever component the key held before.\n   *\n   * Keyed by name rather than handed the previous value because `keyof this` excludes private\n   * members, so the components live in a single {@link PluginBaseComponents} bag whose keys ARE\n   * indexable.\n   *\n   * @typeParam TKey - The key of the component to store.\n   * @param key - The key of the component to store.\n   * @param value - The component to store.\n   */\n  private setComponent<TKey extends keyof PluginBaseComponents>(key: TKey, value: NonNullable<PluginBaseComponents[TKey]>): void {\n    const oldComponent = this.components[key];\n    if (oldComponent) {\n      this.removeChild(oldComponent);\n    }\n    this.components[key] = value;\n  }\n}\n\n/**\n * Reloads the specified plugin by disabling and then re-enabling it.\n *\n * @param plugin - The plugin to reload.\n * @returns A {@link Promise} that resolves when the plugin is reloaded.\n */\nexport async function reloadPlugin(plugin: Plugin): Promise<void> {\n  const plugins = plugin.app.plugins;\n  const pluginId = plugin.manifest.id;\n  await plugins.disablePlugin(pluginId);\n  await plugins.enablePlugin(pluginId);\n}\n\n/**\n * Displays an error message as a notice, logs it to the console, and disables the specified plugin.\n *\n * @param plugin - The plugin to disable.\n * @param message - The error message to display and log.\n * @returns A {@link Promise} that resolves when the plugin is disabled.\n */\nexport async function showErrorAndDisablePlugin(plugin: Plugin, message: string): Promise<void> {\n  const pluginNoticeComponent = new PluginNoticeComponent({\n    app: plugin.app,\n    pluginName: plugin.manifest.name\n  });\n  pluginNoticeComponent.showNotice(message);\n  printError(new Error(message));\n  await plugin.app.plugins.disablePlugin(plugin.manifest.id);\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/plugin.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Base class for Obsidian plugins using a component-based architecture.\n *\n * PluginBase registers universal components (context, i18n, error handling, abort signal, lifecycle events, debug).\n */\n\nimport type {\n  Component,\n  IconName\n} from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { Plugin } from 'obsidian';\n\nimport type {\n  PluginConflict,\n  PluginDependency\n} from '../components/plugin-gate-component.ts';\nimport type { TranslationsMap } from '../i18n/i18n.ts';\nimport type { PluginApiDeclaration } from './plugin-api.ts';\nimport type {\n  PluginEventMap,\n  PluginEventSource\n} from './plugin-event-source.ts';\nimport type { PluginLifecycleEventPayload } from './plugin-lifecycle-events.ts';\n\nimport { mixinAsyncEvents } from '../../async-events.ts';\nimport { printError } from '../../error.ts';\nimport { noopAsync } from '../../function.ts';\nimport { ensureNonNullable } from '../../type-guards.ts';\nimport { AppActiveFileProvider } from '../active-file-provider.ts';\nimport { CommandHandlerComponent } from '../command-handlers/command-handler-component.ts';\nimport { UnlockActiveNoteCommandHandler } from '../command-handlers/unlock-active-note-command-handler.ts';\nimport { PluginCommandRegistrar } from '../command-registrar.ts';\nimport { AbortSignalComponent } from '../components/abort-signal-component.ts';\nimport { AsyncErrorHandlerComponent } from '../components/async-error-handler-component.ts';\nimport { ComponentEx } from '../components/component-ex.ts';\nimport { ConsoleDebugComponent } from '../components/console-debug-component.ts';\nimport { MenuEventRegistrarComponent } from '../components/menu-event-registrar-component.ts';\nimport { NotebookNavigatorMenuEventRegistrarComponent } from '../components/notebook-navigator-menu-event-registrar-component.ts';\nimport { PluginContextComponent } from '../components/plugin-context-component.ts';\nimport { PluginGateComponent } from '../components/plugin-gate-component.ts';\nimport { PluginNoticeComponent } from '../components/plugin-notice-component.ts';\nimport { PluginSettingsComponentBase } from '../components/plugin-settings-component.ts';\nimport { PluginDataHandler } from '../data-handler.ts';\nimport { initI18N } from '../i18n/i18n.ts';\nimport { defaultTranslationsMap } from '../i18n/locales/translations-map.ts';\nimport { ResourceLockComponent } from '../resource-lock.ts';\nimport { publishPluginApi } from './plugin-api.ts';\nimport { PluginEventSourceImpl } from './plugin-event-source.ts';\nimport {\n  PLUGIN_LOADED_EVENT_NAME,\n  PLUGIN_UNLOADED_EVENT_NAME,\n  triggerPluginLifecycleEvent\n} from './plugin-lifecycle-events.ts';\n\n/**\n * The universal components owned by {@link PluginBase}, keyed by the name of the accessor exposing\n * each one. Every member is optional because a component only exists once {@link PluginBase.onload}\n * has created it.\n */\ninterface PluginBaseComponents {\n  abortSignalComponent?: AbortSignalComponent;\n  asyncErrorHandlerComponent?: AsyncErrorHandlerComponent;\n  commandHandlerComponent?: CommandHandlerComponent;\n  consoleDebugComponent?: ConsoleDebugComponent;\n  pluginContextComponent?: PluginContextComponent;\n  pluginGateComponent?: PluginGateComponent;\n  pluginNoticeComponent?: PluginNoticeComponent;\n  pluginSettingsComponent?: PluginSettingsComponentBase<object>;\n  resourceLockComponent?: ResourceLockComponent;\n}\n\n/**\n * Base class for creating Obsidian plugins with a component-based architecture.\n *\n * Registers universal components automatically. Subclasses add or replace components\n * via {@link removeChild} / {@link addChild}.\n */\nexport abstract class PluginBase extends mixinAsyncEvents<PluginEventMap>()(Plugin) implements PluginEventSource {\n  /**\n   * Gets abort signal component.\n   *\n   * @returns abort signal component.\n   */\n  protected get abortSignalComponent(): AbortSignalComponent {\n    return ensureNonNullable(this.components.abortSignalComponent);\n  }\n\n  /**\n   * Sets abort signal component.\n   *\n   * @param value - Abort signal component.\n   */\n  protected set abortSignalComponent(value: AbortSignalComponent) {\n    this.setComponent('abortSignalComponent', value);\n  }\n\n  /**\n   * Gets async error handler component.\n   *\n   * @returns async error handler component.\n   */\n  protected get asyncErrorHandlerComponent(): AsyncErrorHandlerComponent {\n    return ensureNonNullable(this.components.asyncErrorHandlerComponent);\n  }\n\n  /**\n   * Sets async error handler component.\n   *\n   * @param value - Async error handler component.\n   */\n  protected set asyncErrorHandlerComponent(value: AsyncErrorHandlerComponent) {\n    this.setComponent('asyncErrorHandlerComponent', value);\n  }\n\n  /**\n   * Gets the shared command handler component. Register a plugin's commands on it via\n   * {@link CommandHandlerComponent.registerCommandHandlers} rather than constructing your own\n   * {@link CommandHandlerComponent} \u2014 the app-backed active-file provider, command registrar, menu\n   * event registrar, and plugin name are already wired.\n   *\n   * @returns The command handler component.\n   */\n  protected get commandHandlerComponent(): CommandHandlerComponent {\n    return ensureNonNullable(this.components.commandHandlerComponent);\n  }\n\n  /**\n   * Sets the command handler component.\n   *\n   * @param value - The command handler component.\n   */\n  protected set commandHandlerComponent(value: CommandHandlerComponent) {\n    this.setComponent('commandHandlerComponent', value);\n  }\n\n  /**\n   * Gets console debug component.\n   *\n   * @returns console debug component.\n   */\n  protected get consoleDebugComponent(): ConsoleDebugComponent {\n    return ensureNonNullable(this.components.consoleDebugComponent);\n  }\n\n  /**\n   * Sets console debug component.\n   *\n   * @param value - Console debug component.\n   */\n  protected set consoleDebugComponent(value: ConsoleDebugComponent) {\n    this.setComponent('consoleDebugComponent', value);\n  }\n\n  /**\n   * Gets plugin context component (plugin ID, debug controller, library styles).\n   *\n   * @returns plugin context component.\n   */\n  protected get pluginContextComponent(): PluginContextComponent {\n    return ensureNonNullable(this.components.pluginContextComponent);\n  }\n\n  /**\n   * Sets plugin context component.\n   *\n   * @param value - Plugin context component.\n   */\n  protected set pluginContextComponent(value: PluginContextComponent) {\n    this.setComponent('pluginContextComponent', value);\n  }\n\n  /**\n   * Gets the gate holding the plugin's feature surface up or down.\n   *\n   * Reach for it from a settings tab to render the overlap banner for a\n   * {@link obsidian/components/plugin-gate-component!PluginConflictSeverity.Warn} conflict \u2014 the one\n   * banner the library cannot place itself, because a running plugin builds its own settings tab.\n   *\n   * @returns The plugin gate component.\n   */\n  protected get pluginGateComponent(): PluginGateComponent {\n    return ensureNonNullable(this.components.pluginGateComponent);\n  }\n\n  /**\n   * Sets the plugin gate component.\n   *\n   * @param value - The plugin gate component.\n   */\n  protected set pluginGateComponent(value: PluginGateComponent) {\n    this.setComponent('pluginGateComponent', value);\n  }\n\n  /**\n   * Gets plugin notice component.\n   *\n   * @returns plugin notice component.\n   */\n  protected get pluginNoticeComponent(): PluginNoticeComponent {\n    return ensureNonNullable(this.components.pluginNoticeComponent);\n  }\n\n  /**\n   * Sets plugin notice component.\n   *\n   * @param value - Plugin notice component.\n   */\n  protected set pluginNoticeComponent(value: PluginNoticeComponent) {\n    this.setComponent('pluginNoticeComponent', value);\n  }\n\n  /**\n   * Gets plugin settings component.\n   *\n   * @returns plugin settings component.\n   */\n  protected get pluginSettingsComponent(): PluginSettingsComponentBase<object> {\n    return ensureNonNullable(this.components.pluginSettingsComponent);\n  }\n\n  /**\n   * Sets plugin settings component.\n   *\n   * @param value - Plugin settings component.\n   */\n  protected set pluginSettingsComponent(value: PluginSettingsComponentBase<object>) {\n    this.setComponent('pluginSettingsComponent', value);\n  }\n\n  /**\n   * Gets the editor lock component, used to lock notes read-only during long operations. Owned by\n   * the plugin, so its locks are released automatically when the plugin unloads.\n   *\n   * @returns Editor lock component.\n   */\n  protected get resourceLockComponent(): ResourceLockComponent {\n    return ensureNonNullable(this.components.resourceLockComponent);\n  }\n\n  /**\n   * Sets the editor lock component.\n   *\n   * @param value - Editor lock component.\n   */\n  protected set resourceLockComponent(value: ResourceLockComponent) {\n    this.setComponent('resourceLockComponent', value);\n  }\n\n  private readonly components: PluginBaseComponents = {};\n\n  // Everything the SUBCLASS owns: what `onloadImpl` adds, and what it adds later.\n  //\n  // A second wrapper rather than one, because the two tiers have opposite lifetimes. The universal\n  // Components have to OUTLIVE a lost dependency \u2014 they are what shows the notice naming the plugin that\n  // Went away and renders the button that brings it back \u2014 while the subclass's surface is exactly what\n  // Must stop running. Unloading one wrapper holding both would silence the plugin at the moment it most\n  // Needs to speak.\n  //\n  // Always present, never null, and REPLACED rather than emptied when the surface is torn down. That keeps\n  // `addChild` callable at every point in the plugin's life, exactly as it was before the tiers existed:\n  // A child added before the gate opens is queued and loaded when it does, which is what `ComponentEx`\n  // Already does for any child added to a not-yet-loaded component.\n  private gatedWrapperComponent = new ComponentEx();\n\n  // The payload broadcast when this plugin finished loading, kept so the matching unloaded broadcast\n  // Describes the same plugin without re-deriving it from a surface that has since been torn down. Null\n  // Whenever no loaded broadcast is outstanding, which is what keeps the two events paired.\n  private lifecycleEventPayload: null | PluginLifecycleEventPayload = null;\n\n  // The library's own components, which outlive any dependency.\n  private readonly universalWrapperComponent = new ComponentEx();\n\n  /**\n   * Adds a child component.\n   *\n   * The child is added to the internal wrapper holding the subclass's own surface, which {@link onload}\n   * creates and loads before calling {@link onloadImpl}. So a child added during {@link onloadImpl} is\n   * loaded immediately, children-first, and is usable by the time this method returns.\n   *\n   * That wrapper is torn down and rebuilt whenever the gate closes and opens again \u2014 a dependency declared\n   * by {@link getPluginDependencies} going away and coming back, or a conflict declared by\n   * {@link getPluginConflicts} appearing and being resolved \u2014 so a child added here lives exactly as long\n   * as the plugin's feature surface does. Adding one while the surface is down is still legitimate \u2014 it is\n   * queued and loaded when the surface next comes up, the way {@link ComponentEx.addChild} already queues\n   * a child added to a not-yet-loaded component.\n   *\n   * @typeParam TComponent - The type of component to add.\n   * @param component - The component instance to add.\n   * @returns The added component.\n   */\n  public override addChild<TComponent extends Component>(component: TComponent): TComponent {\n    return this.gatedWrapperComponent.addChild(component);\n  }\n\n  /**\n   * Called when the external settings change.\n   *\n   * Override in subclass if needed. Make sure to call `await super.onExternalSettingsChange()` first.\n   */\n  public override async onExternalSettingsChange(): Promise<void> {\n    await super.onExternalSettingsChange?.();\n    await this.triggerAsync('externalSettingsChange');\n  }\n\n  /**\n   * Called when the plugin is loaded.\n   *\n   * Orchestrates loading: registers the universal components, lets the subclass wire its own\n   * components via {@link onloadImpl}, then awaits the async tail of every load.\n   * Each component loads as it is added, children-first.\n   *\n   * Do NOT override this method. Override {@link onloadImpl} instead.\n   */\n  public override async onload(): Promise<void> {\n    try {\n      // The wrapper is attached and loaded before anything is wired up, so every `addChild` below\n      // Loads its child straight away rather than queuing it.\n      // That is what lets a command handler register its menu events from `onRegistered`, which\n      // `registerCommandHandlers` awaits and which a registrar refuses while unloaded.\n      // Attaching it up front also registers the wrapper for teardown before anything can throw.\n      // The load is explicit rather than left to `addChild`, which loads the child only when the\n      // Plugin itself is loaded \u2014 true when Obsidian calls `load()`, but not when a caller invokes\n      // `onload()` directly.\n      super.addChild(this.universalWrapperComponent);\n      this.universalWrapperComponent.load();\n\n      await initI18N(this.createTranslationsMap());\n      this.pluginContextComponent = this.addUniversalChild(\n        new PluginContextComponent({\n          app: this.app,\n          pluginId: this.manifest.id\n        })\n      );\n      this.pluginNoticeComponent = this.addUniversalChild(\n        new PluginNoticeComponent({\n          app: this.app,\n          pluginName: this.manifest.name\n        })\n      );\n      this.asyncErrorHandlerComponent = this.addUniversalChild(new AsyncErrorHandlerComponent(this.pluginNoticeComponent));\n      this.abortSignalComponent = this.addUniversalChild(new AbortSignalComponent(this.manifest.id));\n      this.consoleDebugComponent = this.addUniversalChild(new ConsoleDebugComponent(this.manifest.id));\n      this.resourceLockComponent = this.addUniversalChild(new ResourceLockComponent(this.app, this.manifest.id));\n      // Notebook Navigator draws its own file tree and never raises Obsidian's `file-menu` /\n      // `files-menu` events, so every plugin's context-menu items would vanish for anyone browsing\n      // Through it. Wired here rather than per-plugin: the bridge stays dormant when Notebook\n      // Navigator is not installed, and a plugin with no file/folder handlers contributes nothing.\n      const notebookNavigatorMenuEventRegistrarComponent = this.addUniversalChild(\n        new NotebookNavigatorMenuEventRegistrarComponent({\n          app: this.app,\n          pluginName: this.manifest.name,\n          submenuIcon: this.getNotebookNavigatorMenuSubmenuIcon()\n        })\n      );\n      this.commandHandlerComponent = this.addUniversalChild(\n        new CommandHandlerComponent({\n          activeFileProvider: new AppActiveFileProvider(this.app),\n          additionalMenuEventRegistrars: [notebookNavigatorMenuEventRegistrarComponent],\n          commandRegistrar: new PluginCommandRegistrar(this),\n          menuEventRegistrar: this.addUniversalChild(new MenuEventRegistrarComponent(this.app)),\n          pluginName: this.manifest.name\n        })\n      );\n      // Always available; the command's own `canExecute` hides it unless the active note is locked.\n      await this.commandHandlerComponent.registerCommandHandlers(() => [\n        new UnlockActiveNoteCommandHandler({\n          app: this.app,\n          resourceLockComponent: this.resourceLockComponent\n        })\n      ]);\n\n      this.pluginSettingsComponent = this.addUniversalChild(\n        new PluginSettingsComponentBase<object>({\n          dataHandler: new PluginDataHandler(this),\n          pluginEventSource: new PluginEventSourceImpl(this),\n          pluginSettingsClass: Object\n        })\n      );\n\n      // The gate. It loads the feature surface itself once every declared dependency is satisfied and no\n      // Declared conflict holds \u2014 which for a plugin declaring neither is immediately, synchronously,\n      // Before this line returns \u2014 and unloads it again if a dependency is later disabled or uninstalled,\n      // Or a conflicting plugin is enabled. A plugin that is blocked therefore reaches `loadWithPromises`\n      // Below having registered nothing of its own, with only the universal components above running to\n      // Explain why and to offer the repair.\n      this.pluginGateComponent = this.addUniversalChild(\n        new PluginGateComponent({\n          conflicts: this.getPluginConflicts(),\n          dependencies: this.getPluginDependencies(),\n          loadFeatureSurface: (): Promise<void> => this.loadFeatureSurface(),\n          plugin: this,\n          pluginNoticeComponent: this.pluginNoticeComponent,\n          unloadFeatureSurface: (): void => {\n            this.unloadFeatureSurface();\n          }\n        })\n      );\n\n      // Every child has already loaded as it was added; this awaits their accumulated async tails and\n      // Reports any failure as a single `AggregateError`.\n      await this.universalWrapperComponent.loadWithPromises();\n    } catch (error) {\n      printError(new Error(`Error loading plugin ${this.manifest.name} (${this.manifest.id})`, { cause: error }));\n      throw error;\n    }\n  }\n\n  /**\n   * Called when the plugin is unloaded.\n   *\n   * Announces the departure on `app.workspace` so anything depending on this plugin learns of it at the\n   * moment it happens, rather than discovering it later through behavior that quietly stopped.\n   *\n   * Do NOT override this method; put teardown on a component instead, which unloads with the plugin.\n   */\n  public override onunload(): void {\n    this.broadcastUnloaded();\n    super.onunload();\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    // Routed by ownership rather than by which tier `addChild` would have chosen, because the two do not\n    // Always agree: a universal component is parented directly on the universal wrapper, yet a subclass\n    // Replacing one goes through the same public `removeChild` as it would for its own children.\n    if (this.gatedWrapperComponent.hasChild(component)) {\n      return this.gatedWrapperComponent.removeChild(component);\n    }\n\n    return this.universalWrapperComponent.removeChild(component);\n  }\n\n  /**\n   * Provides the translations map used to initialize i18n during {@link onload}.\n   *\n   * Override in subclass to supply plugin-specific translations. The default returns the built-in\n   * `obsidian-dev-utils` translations.\n   *\n   * @returns The translations map.\n   */\n  protected createTranslationsMap(): TranslationsMap {\n    return defaultTranslationsMap;\n  }\n\n  /**\n   * Provides the icon shown on the plugin's parent entry in Notebook Navigator's context menus.\n   *\n   * Override in subclass to brand that entry; the default leaves it without an icon. The entry is\n   * titled with the plugin name and is added automatically \u2014 see\n   * {@link NotebookNavigatorMenuEventRegistrarComponent}.\n   *\n   * @returns The icon, or `''` for no icon.\n   */\n  protected getNotebookNavigatorMenuSubmenuIcon(): IconName {\n    return '';\n  }\n\n  /**\n   * Provides the APIs this plugin exposes to other plugins.\n   *\n   * Override in subclass to publish one. The default publishes none. Called after {@link onloadImpl}, so a\n   * declaration may reference anything it created; the returned declarations are published through\n   * `publishPluginApi` and revoked when the plugin's feature surface unloads.\n   *\n   * Returning a LIST rather than a single API is deliberate: the registry supports several contract\n   * versions published side by side, which is how a provider ships a breaking `2.0.0` without stranding\n   * consumers still pinned to `^1`.\n   *\n   * Every declaration here is published BEFORE the `obsidian-dev-utils:plugin-loaded` broadcast, which is\n   * what lets a listener call these APIs the moment it hears that event.\n   *\n   * @returns The API declarations.\n   */\n  protected getPluginApis(): PluginApiDeclaration[] {\n    return [];\n  }\n\n  /**\n   * Provides the plugins this one refuses, or warns about, running beside.\n   *\n   * Override in subclass to declare an overlap. The default declares none.\n   *\n   * A `Block` conflict is the mirror image of a dependency: while a conflicting plugin is enabled at a\n   * conflicting version, {@link onloadImpl} does not run at all and the plugin registers nothing. Declare\n   * it when both plugins acting on the same operation damages the vault \u2014 there is no reliable way to win\n   * that race, because whichever plugin loaded first keeps a hand on the wheel, so refusing deterministically\n   * beats competing unpredictably. A `Warn` conflict declares an overlap that is merely annoying, such as a\n   * duplicated command: both plugins keep running and the user is told.\n   *\n   * Unlike a dependency, a conflicting plugin need not publish anything \u2014 it is detected by reading its\n   * installed version, which is the only thing about another plugin that reads the same regardless of load\n   * order.\n   *\n   * @returns The declared conflicts.\n   */\n  protected getPluginConflicts(): PluginConflict[] {\n    return [];\n  }\n\n  /**\n   * Provides the plugins this one cannot work without.\n   *\n   * Override in subclass to declare a mandatory dependency. The default declares none, and such a plugin\n   * loads exactly as it always has.\n   *\n   * A declared dependency is MANDATORY, unlike the offer `PluginSuggestionComponent` makes: while one is\n   * missing, disabled, or too old, {@link onloadImpl} does not run at all and the plugin registers nothing\n   * \u2014 no commands, no handlers, no patches. It stays enabled in Obsidian's list rather than disabling\n   * itself, because the enabled set is the user's to change, and it explains itself through a notice and a\n   * settings banner that installs the missing plugin in one click. The load completes the moment the\n   * dependency arrives, with no restart.\n   *\n   * A dependency must publish an API through `publishPluginApi`, which is what makes its presence,\n   * absence, version and departure all observable through one mechanism. A plugin with nothing to expose\n   * can publish an empty API purely so it can be depended upon.\n   *\n   * @returns The declared dependencies.\n   */\n  protected getPluginDependencies(): PluginDependency[] {\n    return [];\n  }\n\n  /**\n   * Called during {@link onload} to wire plugin-specific child components.\n   *\n   * Override in subclass to add child components via {@link addChild}. The universal components are\n   * available here. Children are loaded sequentially in the order they are added (children-first).\n   *\n   * @returns A {@link Promise} that resolves when the subclass load logic is complete.\n   */\n  protected onloadImpl(): Promisable<void> {\n    return noopAsync();\n  }\n\n  /**\n   * Stores a universal component, unloading whichever component the key held before.\n   *\n   * Keyed by name rather than handed the previous value because `keyof this` excludes private\n   * members, so the components live in a single {@link PluginBaseComponents} bag whose keys ARE\n   * indexable.\n   *\n   * @typeParam TKey - The key of the component to store.\n   * @param key - The key of the component to store.\n   * @param value - The component to store.\n   */\n  /**\n   * Adds a component to the universal tier, which outlives any dependency.\n   *\n   * Private on purpose: only this class decides what is universal. A subclass adding one of its own goes\n   * through {@link addChild} and lands in the gated tier, where it belongs.\n   *\n   * @typeParam TComponent - The type of component to add.\n   * @param component - The component instance to add.\n   * @returns The added component.\n   */\n  private addUniversalChild<TComponent extends Component>(component: TComponent): TComponent {\n    return this.universalWrapperComponent.addChild(component);\n  }\n\n  /**\n   * Announces on `app.workspace` that this plugin is loaded and its APIs are callable.\n   */\n  private broadcastLoaded(): void {\n    this.lifecycleEventPayload = {\n      apiVersions: this.getPluginApis().map((declaration) => declaration.apiVersion),\n      dependencyPluginIds: this.getPluginDependencies().map((dependency) => dependency.pluginId),\n      pluginId: this.manifest.id,\n      pluginName: this.manifest.name,\n      pluginVersion: this.manifest.version\n    };\n\n    triggerPluginLifecycleEvent({\n      app: this.app,\n      name: PLUGIN_LOADED_EVENT_NAME,\n      payload: this.lifecycleEventPayload\n    });\n  }\n\n  /**\n   * Announces on `app.workspace` that this plugin's surface has gone away.\n   *\n   * Silent unless a loaded broadcast is outstanding, so the two events stay paired: a plugin that never\n   * got past its dependency gate never announced itself, and must not announce a departure either.\n   */\n  private broadcastUnloaded(): void {\n    const payload = this.lifecycleEventPayload;\n    if (!payload) {\n      return;\n    }\n\n    this.lifecycleEventPayload = null;\n    triggerPluginLifecycleEvent({\n      app: this.app,\n      name: PLUGIN_UNLOADED_EVENT_NAME,\n      payload\n    });\n  }\n\n  /**\n   * Builds and loads the subclass's feature surface, then publishes its APIs and announces itself.\n   *\n   * NOT idempotent, deliberately. `PluginGateComponent` owns the up/down state machine and calls\n   * this only on a real transition; a second guard here would be a second copy of that state, which is the\n   * kind of duplicate that drifts.\n   *\n   * @returns A {@link Promise} that resolves once the surface is loaded and the broadcast has been made.\n   */\n  private async loadFeatureSurface(): Promise<void> {\n    // Loaded explicitly for the same reason the universal wrapper is: `addChild` loads a child only once\n    // Its parent is loaded, and the surface has to be live before `onloadImpl` starts adding to it.\n    const gatedWrapperComponent = this.gatedWrapperComponent;\n    this.universalWrapperComponent.addChild(gatedWrapperComponent);\n    gatedWrapperComponent.load();\n\n    await this.onloadImpl();\n    await gatedWrapperComponent.loadWithPromises();\n\n    for (const declaration of this.getPluginApis()) {\n      publishPluginApi({\n        ...declaration,\n        // Revoked with the SURFACE, not with the plugin: a plugin whose dependency goes away keeps running\n        // Its universal components, and a consumer must not be left holding a handle into the half of it\n        // That was just torn down.\n        component: gatedWrapperComponent,\n        plugin: this\n      });\n    }\n\n    this.broadcastLoaded();\n  }\n\n  private setComponent<TKey extends keyof PluginBaseComponents>(key: TKey, value: NonNullable<PluginBaseComponents[TKey]>): void {\n    const oldComponent = this.components[key];\n    if (oldComponent) {\n      this.removeChild(oldComponent);\n    }\n    this.components[key] = value;\n  }\n\n  /**\n   * Tears the subclass's feature surface down, leaving the universal components running.\n   */\n  private unloadFeatureSurface(): void {\n    const gatedWrapperComponent = this.gatedWrapperComponent;\n\n    // Replaced BEFORE the old one is unloaded, so anything that resumes mid-teardown and calls `addChild`\n    // Parks its child on the fresh surface rather than on the one being torn down \u2014 where `ComponentEx`\n    // Would refuse it outright, since it refuses children added to an already-unloaded component.\n    this.gatedWrapperComponent = new ComponentEx();\n    this.universalWrapperComponent.removeChild(gatedWrapperComponent);\n\n    this.broadcastUnloaded();\n  }\n}\n\n/**\n * Reloads the specified plugin by disabling and then re-enabling it.\n *\n * @param plugin - The plugin to reload.\n * @returns A {@link Promise} that resolves when the plugin is reloaded.\n */\nexport async function reloadPlugin(plugin: Plugin): Promise<void> {\n  const plugins = plugin.app.plugins;\n  const pluginId = plugin.manifest.id;\n  await plugins.disablePlugin(pluginId);\n  await plugins.enablePlugin(pluginId);\n}\n\n/**\n * Displays an error message as a notice, logs it to the console, and disables the specified plugin.\n *\n * @param plugin - The plugin to disable.\n * @param message - The error message to display and log.\n * @returns A {@link Promise} that resolves when the plugin is disabled.\n */\nexport async function showErrorAndDisablePlugin(plugin: Plugin, message: string): Promise<void> {\n  const pluginNoticeComponent = new PluginNoticeComponent({\n    app: plugin.app,\n    pluginName: plugin.manifest.name\n  });\n  pluginNoticeComponent.showNotice(message);\n  printError(new Error(message));\n  await plugin.app.plugins.disablePlugin(plugin.manifest.id);\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/plugin/settings-migration-api.d.mts

@@ -0,0 +1,91 @@
+/// <reference path="../../library.d.mts" />
+/**
+ * @file
+ *
+ * The generic half of a settings HANDOVER contract: one plugin offers another the settings it used to own,
+ * and the plugin that owns them now decides what to do with the offer.
+ *
+ * The shape below is deliberately the *envelope* and nothing else. A handover has three parts, and only one
+ * of them is generic:
+ *
+ * - The **envelope** — a `migrateSettings` call, who is proposing, and whether the user applied it. Identical
+ *   for every pair of plugins, so it lives here.
+ * - The **payload** — which settings are being proposed. Entirely the pair's own business, so it stays a type
+ *   parameter and is never named here.
+ * - The **provider's identity** — its plugin id and display name. Also the pair's own business, and not
+ *   something this library has any standing to own.
+ *
+ * Why it is declared rather than imported. A provider is typically an Obsidian *plugin* repo, not an npm
+ * package, so a consumer has nothing to depend on and hand-writes its own copy of the contract. Five copies
+ * of one contract with no compiler link between them means drift is SILENT — every copy still compiles and
+ * the handover fails at runtime instead. Declaring the envelope here gives both ends one declaration to
+ * compile against; `watchPluginApi` still negotiates the version at runtime, because the two ends ship
+ * independently and always will.
+ *
+ * The provider publishes it:
+ *
+ * ```ts
+ * publishPluginApi<SettingsMigrationApi<MyMigratableSettings>>({
+ *   api: this.settingsMigrationApi,
+ *   apiVersion: '1.0.0',
+ *   contract: { migrateSettings: {} },
+ *   plugin: this
+ * });
+ * ```
+ *
+ * The consumer reaches it through {@link obsidian/components/settings-migration-component!SettingsMigrationComponent},
+ * which owns the whole offer-and-retire dance.
+ */
+/**
+ * Parameters for {@link SettingsMigrationApi.migrateSettings}.
+ *
+ * @typeParam TMigratableSettings - The settings the proposing plugin may hand over.
+ */
+export interface MigrateSettingsParams<TMigratableSettings extends object> {
+    /**
+     * The values the proposing plugin offers.
+     *
+     * Conventionally every member is optional, so a plugin proposes only what it actually held and a value the
+     * provider already owns is never overwritten by a default nobody chose. That convention belongs to the pair,
+     * though — this type imposes only the envelope.
+     */
+    readonly proposedSettings: TMigratableSettings;
+    /**
+     * The `manifest.id` of the plugin making the proposal, so the provider's dialog can say whose settings
+     * these are.
+     */
+    readonly sourcePluginId: string;
+}
+/**
+ * The outcome of {@link SettingsMigrationApi.migrateSettings}.
+ */
+export interface MigrateSettingsResult {
+    /**
+     * Whether the user approved the migration.
+     *
+     * `false` means they cancelled and nothing was written, so the proposing plugin must NOT record the
+     * migration as done — a cancel is not an answer, and the offer has to come back.
+     */
+    readonly isApplied: boolean;
+}
+/**
+ * The API a plugin publishes when it is willing to receive settings another plugin used to own.
+ *
+ * @typeParam TMigratableSettings - The settings this provider accepts.
+ *
+ * @remarks
+ * The provider owns the settings, so it owns the dialog: a proposing plugin never writes into another
+ * plugin's `data.json`. It proposes, and the user approves, edits or declines.
+ */
+export interface SettingsMigrationApi<TMigratableSettings extends object> {
+    /**
+     * Offers the user a set of settings values another plugin proposes, and applies what they approve.
+     *
+     * Resolves only once the dialog is closed, so the caller learns whether the migration actually happened and
+     * can retire — or withhold — its own pending values on that answer.
+     *
+     * @param params - The proposal.
+     * @returns What the user approved.
+     */
+    migrateSettings(params: MigrateSettingsParams<TMigratableSettings>): Promise<MigrateSettingsResult>;
+}