obsidian-dev-utils 101.5.0 → 101.7.0

package/dist/lib/esm/obsidian/plugin/plugin-install-state.mjs

@@ -0,0 +1,106 @@
+/*
+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();
+})();
+})();
+
+import {
+  enableCommunityPlugin,
+  installConfigureEnableCommunityPlugin
+} from "../community-plugins.mjs";
+import {
+  asCodeBlock,
+  createFragmentWithCodeBlocks
+} from "../html-element.mjs";
+import { t } from "../i18n/i18n.mjs";
+var InstalledPluginState = /* @__PURE__ */ ((InstalledPluginState2) => {
+  InstalledPluginState2["Enabled"] = "enabled";
+  InstalledPluginState2["InstalledButDisabled"] = "installedButDisabled";
+  InstalledPluginState2["NotInstalled"] = "notInstalled";
+  return InstalledPluginState2;
+})(InstalledPluginState || {});
+function getInstalledPluginState(params) {
+  const { app, pluginId } = params;
+  if (app.plugins.enabledPlugins.has(pluginId)) {
+    return "enabled" /* Enabled */;
+  }
+  return Object.hasOwn(app.plugins.manifests, pluginId) ? "installedButDisabled" /* InstalledButDisabled */ : "notInstalled" /* NotInstalled */;
+}
+function getInstalledPluginVersion(params) {
+  const { app, pluginId } = params;
+  if (!app.plugins.enabledPlugins.has(pluginId)) {
+    return null;
+  }
+  return app.plugins.manifests[pluginId]?.version ?? "";
+}
+async function installAndEnablePlugin(params) {
+  const {
+    app,
+    pluginId,
+    pluginName,
+    pluginNoticeComponent
+  } = params;
+  const state = getInstalledPluginState({ app, pluginId });
+  if (state === "enabled" /* Enabled */) {
+    return;
+  }
+  try {
+    if (state === "installedButDisabled" /* InstalledButDisabled */) {
+      await enableCommunityPlugin({ app, pluginId });
+    } else {
+      await installConfigureEnableCommunityPlugin({ app, pluginId });
+    }
+  } catch (error) {
+    pluginNoticeComponent.showNotice(createFragmentWithCodeBlocks(
+      t(($) => $.obsidianDevUtils.pluginSuggestion.installFailed, { pluginName: asCodeBlock(pluginName) })
+    ));
+    throw error;
+  }
+  pluginNoticeComponent.showNotice(createFragmentWithCodeBlocks(
+    t(($) => $.obsidianDevUtils.pluginSuggestion.installed, { pluginName: asCodeBlock(pluginName) })
+  ));
+}
+export {
+  InstalledPluginState,
+  getInstalledPluginState,
+  getInstalledPluginVersion,
+  installAndEnablePlugin
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/plugin/plugin-install-state.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * How another plugin is present in this vault, and the one-click path to making it present.\n *\n * Shared by the two components that ask a user to bring another plugin in: `PluginSuggestionComponent`,\n * which OFFERS one and keeps working without it, and `PluginGateComponent`, which REQUIRES one and\n * does nothing until it is there. The offer and the requirement differ in what they do about the answer,\n * not in how they read the state or how they install \u2014 so that part lives here rather than in both.\n */\n\nimport type { App } from 'obsidian';\n\nimport type { PluginNoticeComponent } from '../components/plugin-notice-component.ts';\n\nimport {\n  enableCommunityPlugin,\n  installConfigureEnableCommunityPlugin\n} from '../community-plugins.ts';\nimport {\n  asCodeBlock,\n  createFragmentWithCodeBlocks\n} from '../html-element.ts';\nimport { t } from '../i18n/i18n.ts';\n\n/**\n * How another plugin is currently present in the vault.\n */\nexport enum InstalledPluginState {\n  /**\n   * Installed and enabled \u2014 there is nothing to do.\n   */\n  Enabled = 'enabled',\n\n  /**\n   * Installed but disabled. Only an enable is needed, so no download happens.\n   */\n  InstalledButDisabled = 'installedButDisabled',\n\n  /**\n   * Not installed at all.\n   */\n  NotInstalled = 'notInstalled'\n}\n\n/**\n * Parameters for {@link getInstalledPluginState}.\n */\nexport interface GetInstalledPluginStateParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The `manifest.id` of the plugin to look for.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link getInstalledPluginVersion}.\n */\nexport interface GetInstalledPluginVersionParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The `manifest.id` of the plugin to look for.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link installAndEnablePlugin}.\n */\nexport interface InstallAndEnablePluginParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The `manifest.id` of the plugin to install and enable.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The display name of the plugin, shown to the user.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The notice component of the plugin doing the asking, used to report the outcome.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n}\n\n/**\n * Resolves how another plugin is currently present in the vault.\n *\n * @param params - The {@link GetInstalledPluginStateParams}.\n * @returns The {@link InstalledPluginState}.\n */\nexport function getInstalledPluginState(params: GetInstalledPluginStateParams): InstalledPluginState {\n  const { app, pluginId } = params;\n\n  if (app.plugins.enabledPlugins.has(pluginId)) {\n    return InstalledPluginState.Enabled;\n  }\n\n  return Object.hasOwn(app.plugins.manifests, pluginId)\n    ? InstalledPluginState.InstalledButDisabled\n    : InstalledPluginState.NotInstalled;\n}\n\n/**\n * Reads the version of another plugin as this vault has it installed, or `null` when it is not running.\n *\n * The version comes out of `app.plugins.manifests`, which is populated for every installed plugin at\n * startup \u2014 so, unlike anything a plugin REGISTERS, it answers the same way no matter which plugin loaded\n * first. That load-order independence is the whole reason a conflict is detected by version rather than by\n * asking a registry.\n *\n * `null` for a plugin that is not installed OR is installed but disabled: a disabled plugin registers\n * nothing, so for every question this answers the two cases are the same. An installed, enabled plugin\n * whose manifest somehow carries no version reads as an empty string rather than `null`, which keeps\n * \"running, version unknown\" distinguishable from \"not running\" \u2014 a caller comparing versions should fail\n * closed on it rather than treat it as absent.\n *\n * @param params - The {@link GetInstalledPluginVersionParams}.\n * @returns The installed version, or `null` when the plugin is not enabled.\n */\nexport function getInstalledPluginVersion(params: GetInstalledPluginVersionParams): null | string {\n  const { app, pluginId } = params;\n\n  if (!app.plugins.enabledPlugins.has(pluginId)) {\n    return null;\n  }\n\n  return app.plugins.manifests[pluginId]?.version ?? '';\n}\n\n/**\n * Installs (when needed) and enables another plugin, reporting the outcome as a notice.\n *\n * A no-op when the plugin is already enabled, so a caller reacting to a click need not check first.\n *\n * @param params - The {@link InstallAndEnablePluginParams}.\n * @returns A {@link Promise} that resolves once the plugin is enabled.\n * @throws Whatever the install or enable threw, after reporting it as a notice \u2014 the caller decides\n * whether a failure is worth more than the notice the user has already seen.\n */\nexport async function installAndEnablePlugin(params: InstallAndEnablePluginParams): Promise<void> {\n  const {\n    app,\n    pluginId,\n    pluginName,\n    pluginNoticeComponent\n  } = params;\n  const state = getInstalledPluginState({ app, pluginId });\n\n  if (state === InstalledPluginState.Enabled) {\n    return;\n  }\n\n  try {\n    if (state === InstalledPluginState.InstalledButDisabled) {\n      await enableCommunityPlugin({ app, pluginId });\n    } else {\n      await installConfigureEnableCommunityPlugin({ app, pluginId });\n    }\n  } catch (error) {\n    pluginNoticeComponent.showNotice(createFragmentWithCodeBlocks(\n      t(($) => $.obsidianDevUtils.pluginSuggestion.installFailed, { pluginName: asCodeBlock(pluginName) })\n    ));\n    throw error;\n  }\n\n  pluginNoticeComponent.showNotice(createFragmentWithCodeBlocks(\n    t(($) => $.obsidianDevUtils.pluginSuggestion.installed, { pluginName: asCodeBlock(pluginName) })\n  ));\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,SAAS;AAKX,IAAK,uBAAL,kBAAKA,0BAAL;AAIL,EAAAA,sBAAA,aAAU;AAKV,EAAAA,sBAAA,0BAAuB;AAKvB,EAAAA,sBAAA,kBAAe;AAdL,SAAAA;AAAA,GAAA;AA8EL,SAAS,wBAAwB,QAA6D;AACnG,QAAM,EAAE,KAAK,SAAS,IAAI;AAE1B,MAAI,IAAI,QAAQ,eAAe,IAAI,QAAQ,GAAG;AAC5C,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,OAAO,IAAI,QAAQ,WAAW,QAAQ,IAChD,oDACA;AACN;AAmBO,SAAS,0BAA0B,QAAwD;AAChG,QAAM,EAAE,KAAK,SAAS,IAAI;AAE1B,MAAI,CAAC,IAAI,QAAQ,eAAe,IAAI,QAAQ,GAAG;AAC7C,WAAO;AAAA,EACT;AAEA,SAAO,IAAI,QAAQ,UAAU,QAAQ,GAAG,WAAW;AACrD;AAYA,eAAsB,uBAAuB,QAAqD;AAChG,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AACJ,QAAM,QAAQ,wBAAwB,EAAE,KAAK,SAAS,CAAC;AAEvD,MAAI,UAAU,yBAA8B;AAC1C;AAAA,EACF;AAEA,MAAI;AACF,QAAI,UAAU,mDAA2C;AACvD,YAAM,sBAAsB,EAAE,KAAK,SAAS,CAAC;AAAA,IAC/C,OAAO;AACL,YAAM,sCAAsC,EAAE,KAAK,SAAS,CAAC;AAAA,IAC/D;AAAA,EACF,SAAS,OAAO;AACd,0BAAsB,WAAW;AAAA,MAC/B,EAAE,CAAC,MAAM,EAAE,iBAAiB,iBAAiB,eAAe,EAAE,YAAY,YAAY,UAAU,EAAE,CAAC;AAAA,IACrG,CAAC;AACD,UAAM;AAAA,EACR;AAEA,wBAAsB,WAAW;AAAA,IAC/B,EAAE,CAAC,MAAM,EAAE,iBAAiB,iBAAiB,WAAW,EAAE,YAAY,YAAY,UAAU,EAAE,CAAC;AAAA,EACjG,CAAC;AACH;",
  "names": ["InstalledPluginState"]
}


package/dist/lib/esm/obsidian/plugin/plugin-lifecycle-events.d.mts

@@ -0,0 +1,119 @@
+/// <reference path="../../library.d.mts" />
+/**
+ * @file
+ *
+ * The lifecycle broadcast every {@link PluginBase} makes: `obsidian-dev-utils:plugin-loaded` when it has
+ * finished loading and `obsidian-dev-utils:plugin-unloaded` when it goes away.
+ *
+ * Obsidian gives a plugin no way to learn that ANOTHER plugin was enabled or disabled — there is no such
+ * event on `app.plugins`, and a plugin's own `Events` source cannot help a listener that does not yet hold
+ * the instance. So the broadcast goes through `app.workspace`, which is one object every plugin in the
+ * vault can reach. Deliberately NOT the `globalThis.__obsidianDevUtils` bag the rest of the library shares
+ * its state through: a listener there needs its own copy of this library, and these events are meant to be
+ * consumable by any plugin at all.
+ *
+ * The names are past tense because a broadcast states something that has already happened. `loaded` in
+ * particular carries a guarantee: it is triggered only after every API the plugin declares has been
+ * published, so a listener may call them immediately.
+ *
+ * Both the event names and {@link PluginLifecycleEventPayload} are a CROSS-VERSION CONTRACT. Copies of
+ * this library at different versions publish and consume them side by side in one vault, so neither may
+ * change incompatibly: plain data only, and new payload fields only ever added.
+ */
+import type { App } from 'obsidian';
+/**
+ * The name of either lifecycle event.
+ */
+export type PluginLifecycleEventName = typeof PLUGIN_LOADED_EVENT_NAME | typeof PLUGIN_UNLOADED_EVENT_NAME;
+/**
+ * The payload of {@link PLUGIN_LOADED_EVENT_NAME} and {@link PLUGIN_UNLOADED_EVENT_NAME}.
+ *
+ * Plain data by design — no class instances and no types owned by this library — because it crosses
+ * between independently bundled copies of it, and between plugins that do not use it at all.
+ */
+export interface PluginLifecycleEventPayload {
+    /**
+     * The contract versions the plugin published, empty when it publishes no API.
+     *
+     * An array rather than a single version because a provider may publish several contract versions side by
+     * side, so consumers pinned to an older range keep working across a breaking change.
+     *
+     * The API objects themselves are deliberately NOT here. A handle delivered by a one-shot event is a
+     * probe: it answers "now" and never says when "now" changed, and one that outlives the provider is
+     * exactly the stale handle the plugin-api registry's revocable handles exist to prevent. Reach the API
+     * through `watchPluginApi` instead, whose reference stays correct across unload and re-enable.
+     */
+    readonly apiVersions: readonly string[];
+    /**
+     * The ids of the plugins this one declares as mandatory dependencies, empty when it declares none.
+     *
+     * Present so the relationship can be read from the OTHER end: a provider has no way to ask who depends
+     * on it — the registry only answers consumer-to-provider — and "which installed plugins need this one"
+     * is what lets a provider's settings tab tell the user why it is in their vault at all.
+     */
+    readonly dependencyPluginIds: readonly string[];
+    /**
+     * The plugin's `manifest.id`.
+     */
+    readonly pluginId: string;
+    /**
+     * The plugin's `manifest.name`, for display.
+     */
+    readonly pluginName: string;
+    /**
+     * The plugin's `manifest.version`.
+     */
+    readonly pluginVersion: string;
+}
+/**
+ * Parameters for {@link triggerPluginLifecycleEvent}.
+ */
+export interface TriggerPluginLifecycleEventParams {
+    /**
+     * The Obsidian app instance whose workspace carries the broadcast.
+     */
+    readonly app: App;
+    /**
+     * The event to trigger.
+     */
+    readonly name: PluginLifecycleEventName;
+    /**
+     * The payload describing the plugin.
+     */
+    readonly payload: PluginLifecycleEventPayload;
+}
+/**
+ * Triggered once a plugin has finished loading AND published every API it declares, so a listener may call
+ * those APIs immediately.
+ *
+ * Namespaced by the package name rather than by an abbreviation of it: the event is global to the vault
+ * and aimed at plugin authors who have never heard of this library, so the prefix has to identify itself.
+ */
+export declare const PLUGIN_LOADED_EVENT_NAME = "obsidian-dev-utils:plugin-loaded";
+/**
+ * Triggered as a plugin unloads — whether the user disabled it, uninstalled it, or Obsidian is shutting
+ * down. Its APIs are revoked by the time a listener runs.
+ */
+export declare const PLUGIN_UNLOADED_EVENT_NAME = "obsidian-dev-utils:plugin-unloaded";
+declare module 'obsidian' {
+    interface Workspace {
+        /**
+         * Subscribes to a plugin finishing its load, or to one unloading.
+         *
+         * @param name - Should be {@link PLUGIN_LOADED_EVENT_NAME} or {@link PLUGIN_UNLOADED_EVENT_NAME}.
+         * @param callback - The callback receiving the plugin's payload.
+         * @param context - The context passed as `this` to the `callback` function.
+         * @returns The event reference.
+         */
+        on(name: PluginLifecycleEventName, callback: (payload: PluginLifecycleEventPayload) => unknown, context?: unknown): EventRef;
+    }
+}
+/**
+ * Triggers one of the two lifecycle events on the app's workspace.
+ *
+ * A thin typed wrapper over `Workspace.trigger`, which accepts any event name and any arguments, so that
+ * the one place a payload is constructed is checked against {@link PluginLifecycleEventPayload}.
+ *
+ * @param params - The {@link TriggerPluginLifecycleEventParams}.
+ */
+export declare function triggerPluginLifecycleEvent(params: TriggerPluginLifecycleEventParams): void;

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.