obsidian-dev-utils 101.6.0 → 101.7.0

package/dist/lib/esm/obsidian/plugin/plugin-lifecycle-events.mjs

@@ -0,0 +1,54 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureBrowserProcess();
+})();
+})();
+
+const PLUGIN_LOADED_EVENT_NAME = "obsidian-dev-utils:plugin-loaded";
+const PLUGIN_UNLOADED_EVENT_NAME = "obsidian-dev-utils:plugin-unloaded";
+function triggerPluginLifecycleEvent(params) {
+  params.app.workspace.trigger(params.name, params.payload);
+}
+export {
+  PLUGIN_LOADED_EVENT_NAME,
+  PLUGIN_UNLOADED_EVENT_NAME,
+  triggerPluginLifecycleEvent
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/plugin-lifecycle-events.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The lifecycle broadcast every {@link PluginBase} makes: `obsidian-dev-utils:plugin-loaded` when it has\n * finished loading and `obsidian-dev-utils:plugin-unloaded` when it goes away.\n *\n * Obsidian gives a plugin no way to learn that ANOTHER plugin was enabled or disabled \u2014 there is no such\n * event on `app.plugins`, and a plugin's own `Events` source cannot help a listener that does not yet hold\n * the instance. So the broadcast goes through `app.workspace`, which is one object every plugin in the\n * vault can reach. Deliberately NOT the `globalThis.__obsidianDevUtils` bag the rest of the library shares\n * its state through: a listener there needs its own copy of this library, and these events are meant to be\n * consumable by any plugin at all.\n *\n * The names are past tense because a broadcast states something that has already happened. `loaded` in\n * particular carries a guarantee: it is triggered only after every API the plugin declares has been\n * published, so a listener may call them immediately.\n *\n * Both the event names and {@link PluginLifecycleEventPayload} are a CROSS-VERSION CONTRACT. Copies of\n * this library at different versions publish and consume them side by side in one vault, so neither may\n * change incompatibly: plain data only, and new payload fields only ever added.\n */\n\nimport type { App } from 'obsidian';\n\n/**\n * The name of either lifecycle event.\n */\nexport type PluginLifecycleEventName = typeof PLUGIN_LOADED_EVENT_NAME | typeof PLUGIN_UNLOADED_EVENT_NAME;\n\n/**\n * The payload of {@link PLUGIN_LOADED_EVENT_NAME} and {@link PLUGIN_UNLOADED_EVENT_NAME}.\n *\n * Plain data by design \u2014 no class instances and no types owned by this library \u2014 because it crosses\n * between independently bundled copies of it, and between plugins that do not use it at all.\n */\nexport interface PluginLifecycleEventPayload {\n  /**\n   * The contract versions the plugin published, empty when it publishes no API.\n   *\n   * An array rather than a single version because a provider may publish several contract versions side by\n   * side, so consumers pinned to an older range keep working across a breaking change.\n   *\n   * The API objects themselves are deliberately NOT here. A handle delivered by a one-shot event is a\n   * probe: it answers \"now\" and never says when \"now\" changed, and one that outlives the provider is\n   * exactly the stale handle the plugin-api registry's revocable handles exist to prevent. Reach the API\n   * through `watchPluginApi` instead, whose reference stays correct across unload and re-enable.\n   */\n  readonly apiVersions: readonly string[];\n\n  /**\n   * The ids of the plugins this one declares as mandatory dependencies, empty when it declares none.\n   *\n   * Present so the relationship can be read from the OTHER end: a provider has no way to ask who depends\n   * on it \u2014 the registry only answers consumer-to-provider \u2014 and \"which installed plugins need this one\"\n   * is what lets a provider's settings tab tell the user why it is in their vault at all.\n   */\n  readonly dependencyPluginIds: readonly string[];\n\n  /**\n   * The plugin's `manifest.id`.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The plugin's `manifest.name`, for display.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The plugin's `manifest.version`.\n   */\n  readonly pluginVersion: string;\n}\n\n/**\n * Parameters for {@link triggerPluginLifecycleEvent}.\n */\nexport interface TriggerPluginLifecycleEventParams {\n  /**\n   * The Obsidian app instance whose workspace carries the broadcast.\n   */\n  readonly app: App;\n\n  /**\n   * The event to trigger.\n   */\n  readonly name: PluginLifecycleEventName;\n\n  /**\n   * The payload describing the plugin.\n   */\n  readonly payload: PluginLifecycleEventPayload;\n}\n\n/**\n * Triggered once a plugin has finished loading AND published every API it declares, so a listener may call\n * those APIs immediately.\n *\n * Namespaced by the package name rather than by an abbreviation of it: the event is global to the vault\n * and aimed at plugin authors who have never heard of this library, so the prefix has to identify itself.\n */\nexport const PLUGIN_LOADED_EVENT_NAME = 'obsidian-dev-utils:plugin-loaded';\n\n/**\n * Triggered as a plugin unloads \u2014 whether the user disabled it, uninstalled it, or Obsidian is shutting\n * down. Its APIs are revoked by the time a listener runs.\n */\nexport const PLUGIN_UNLOADED_EVENT_NAME = 'obsidian-dev-utils:plugin-unloaded';\n\ndeclare module 'obsidian' {\n  interface Workspace {\n    /**\n     * Subscribes to a plugin finishing its load, or to one unloading.\n     *\n     * @param name - Should be {@link PLUGIN_LOADED_EVENT_NAME} or {@link PLUGIN_UNLOADED_EVENT_NAME}.\n     * @param callback - The callback receiving the plugin's payload.\n     * @param context - The context passed as `this` to the `callback` function.\n     * @returns The event reference.\n     */\n    on(name: PluginLifecycleEventName, callback: (payload: PluginLifecycleEventPayload) => unknown, context?: unknown): EventRef;\n  }\n}\n\n/**\n * Triggers one of the two lifecycle events on the app's workspace.\n *\n * A thin typed wrapper over `Workspace.trigger`, which accepts any event name and any arguments, so that\n * the one place a payload is constructed is checked against {@link PluginLifecycleEventPayload}.\n *\n * @param params - The {@link TriggerPluginLifecycleEventParams}.\n */\nexport function triggerPluginLifecycleEvent(params: TriggerPluginLifecycleEventParams): void {\n  params.app.workspace.trigger(params.name, params.payload);\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqGO,MAAM,2BAA2B;AAMjC,MAAM,6BAA6B;AAwBnC,SAAS,4BAA4B,QAAiD;AAC3F,SAAO,IAAI,UAAU,QAAQ,OAAO,MAAM,OAAO,OAAO;AAC1D;",
  "names": []
}


package/dist/lib/esm/obsidian/plugin/plugin.d.mts

@@ -9,13 +9,16 @@
 import type { Component, IconName } from 'obsidian';
 import type { Promisable } from 'type-fest';
 import { Plugin } from 'obsidian';
+import type { PluginConflict, PluginDependency } from '../components/plugin-gate-component.mjs';
 import type { TranslationsMap } from '../i18n/i18n.mjs';
+import type { PluginApiDeclaration } from './plugin-api.mjs';
 import type { PluginEventMap, PluginEventSource } from './plugin-event-source.mjs';
 import { CommandHandlerComponent } from '../command-handlers/command-handler-component.mjs';
 import { AbortSignalComponent } from '../components/abort-signal-component.mjs';
 import { AsyncErrorHandlerComponent } from '../components/async-error-handler-component.mjs';
 import { ConsoleDebugComponent } from '../components/console-debug-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 { ResourceLockComponent } from '../resource-lock.mjs';
@@ -90,6 +93,22 @@ export declare abstract class PluginBase extends PluginBase_base implements Plug
      * @param value - Plugin context component.
      */
     protected set pluginContextComponent(value: PluginContextComponent);
+    /**
+     * 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.
+     */
+    protected get pluginGateComponent(): PluginGateComponent;
+    /**
+     * Sets the plugin gate component.
+     *
+     * @param value - The plugin gate component.
+     */
+    protected set pluginGateComponent(value: PluginGateComponent);
     /**
      * Gets plugin notice component.
      *
@@ -128,13 +147,22 @@ export declare abstract class PluginBase extends PluginBase_base implements Plug
      */
     protected set resourceLockComponent(value: ResourceLockComponent);
     private readonly components;
-    private readonly wrapperComponent;
+    private gatedWrapperComponent;
+    private lifecycleEventPayload;
+    private readonly universalWrapperComponent;
     /**
      * 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.
@@ -157,6 +185,15 @@ export declare abstract class PluginBase extends PluginBase_base implements Plug
      * Do NOT override this method. Override {@link onloadImpl} instead.
      */
     onload(): Promise<void>;
+    /**
+     * 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(): void;
     /**
      * Removes a child component.
      *
@@ -184,6 +221,62 @@ export declare abstract class PluginBase extends PluginBase_base implements Plug
      * @returns The icon, or `''` for no icon.
      */
     protected getNotebookNavigatorMenuSubmenuIcon(): IconName;
+    /**
+     * 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.
+     */
+    protected getPluginApis(): PluginApiDeclaration[];
+    /**
+     * 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.
+     */
+    protected getPluginConflicts(): PluginConflict[];
+    /**
+     * 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.
+     */
+    protected getPluginDependencies(): PluginDependency[];
     /**
      * Called during {@link onload} to wire plugin-specific child components.
      *
@@ -204,7 +297,43 @@ export declare abstract class PluginBase extends PluginBase_base implements Plug
      * @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.
+     */
+    private addUniversalChild;
+    /**
+     * Announces on `app.workspace` that this plugin is loaded and its APIs are callable.
+     */
+    private broadcastLoaded;
+    /**
+     * 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.
+     */
+    private broadcastUnloaded;
+    /**
+     * 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.
+     */
+    private loadFeatureSurface;
     private setComponent;
+    /**
+     * Tears the subclass's feature surface down, leaving the universal components running.
+     */
+    private unloadFeatureSurface;
 }
 /**
  * Reloads the specified plugin by disabling and then re-enabling it.