@mnaoumov/obsidian-lib 10.10.0 → 10.12.0

package/dist/lib/esm/plugin/plugin-instance.mjs

@@ -0,0 +1,366 @@
+/*
+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"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    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;
+}
+
+ensureBrowserProcess();
+})();
+
+import { convertAsyncToSync } from "@mnaoumov/typescript-lib/async";
+import { castTo } from "@mnaoumov/typescript-lib/object-utils";
+import {
+  ButtonComponent,
+  Component
+} from "obsidian";
+import { PluginEnableRefusedError } from "../community-plugins.mjs";
+import { PluginNoticeMode } from "../components/plugin-notice-component.mjs";
+import { CssClass } from "../css-class.mjs";
+import {
+  asCodeBlock,
+  createFragmentWithCodeBlocks
+} from "../html-element.mjs";
+import { t } from "../i18n/i18n.mjs";
+import { openSettingTab } from "../settings-modal.mjs";
+import {
+  comparePluginVersionWithMinimum,
+  installAndEnablePlugin,
+  PluginVersionComparison,
+  updatePlugin
+} from "./plugin-install-state.mjs";
+import { PLUGIN_LOADED_EVENT_NAME } from "./plugin-lifecycle-events.mjs";
+const DEFAULT_WAIT_FOR_PLUGIN_TIMEOUT_IN_MILLISECONDS = 1e4;
+const PLUGINS_CHANGED_EVENT_NAME = "changed";
+const COMMUNITY_PLUGINS_SETTING_TAB_ID = "community-plugins";
+var PluginAvailability = /* @__PURE__ */ ((PluginAvailability2) => {
+  PluginAvailability2["Available"] = "available";
+  PluginAvailability2["InvalidVersion"] = "invalidVersion";
+  PluginAvailability2["Loading"] = "loading";
+  PluginAvailability2["NotEnabled"] = "notEnabled";
+  PluginAvailability2["NotInstalled"] = "notInstalled";
+  PluginAvailability2["NotLoaded"] = "notLoaded";
+  PluginAvailability2["Outdated"] = "outdated";
+  PluginAvailability2["ShapeMismatch"] = "shapeMismatch";
+  return PluginAvailability2;
+})(PluginAvailability || {});
+class PluginInstanceUnavailableError extends Error {
+  /**
+   * Why the plugin was unavailable when the wait gave up.
+   */
+  availability;
+  /**
+   * The `manifest.id` of the plugin.
+   */
+  pluginId;
+  /**
+   * Creates an instance of {@link PluginInstanceUnavailableError}.
+   *
+   * @param params - The constructor parameters.
+   */
+  constructor(params) {
+    super(`Plugin "${params.pluginId}" is not available: ${params.availability}.`);
+    this.name = "PluginInstanceUnavailableError";
+    this.availability = params.availability;
+    this.pluginId = params.pluginId;
+  }
+}
+function getLoadedPlugin(params) {
+  return getPluginAvailability(params) === "available" /* Available */ ? params.app.plugins.getPlugin(params.pluginId) : null;
+}
+function getPluginAvailability(params) {
+  const {
+    app,
+    isPlugin,
+    minPluginVersion,
+    pluginId
+  } = params;
+  const plugin = app.plugins.getPlugin(pluginId);
+  if (plugin === null) {
+    if (!Object.hasOwn(app.plugins.manifests, pluginId)) {
+      return "notInstalled" /* NotInstalled */;
+    }
+    return app.plugins.enabledPlugins.has(pluginId) ? "notLoaded" /* NotLoaded */ : "notEnabled" /* NotEnabled */;
+  }
+  if (app.plugins.loadingPluginId === pluginId) {
+    return "loading" /* Loading */;
+  }
+  if (minPluginVersion !== void 0) {
+    const comparison = comparePluginVersionWithMinimum(plugin.manifest.version, minPluginVersion);
+    if (comparison === PluginVersionComparison.BelowMinimum) {
+      return "outdated" /* Outdated */;
+    }
+    if (comparison === PluginVersionComparison.Invalid) {
+      return "invalidVersion" /* InvalidVersion */;
+    }
+  }
+  return isPlugin && !isPlugin(plugin) ? "shapeMismatch" /* ShapeMismatch */ : "available" /* Available */;
+}
+async function requirePlugin(params) {
+  const { app } = params;
+  let shownAvailability = null;
+  let latestAvailability = "loading" /* Loading */;
+  let hideNotice = null;
+  let isSettled = false;
+  function show(availability) {
+    if (isSettled || !app.workspace.layoutReady || availability === shownAvailability || availability === "loading" /* Loading */) {
+      return;
+    }
+    hideNotice?.();
+    shownAvailability = availability;
+    const notice = params.pluginNoticeComponent.showNotice(createRequirementFragment(params, availability), {
+      mode: PluginNoticeMode.Separate,
+      shouldHideOnClick: false
+    });
+    hideNotice = () => {
+      notice.hide();
+    };
+  }
+  if (!app.workspace.layoutReady) {
+    app.workspace.onLayoutReady(() => {
+      show(latestAvailability);
+    });
+  }
+  return await waitForAvailability({
+    ...params,
+    onSettled: () => {
+      isSettled = true;
+      hideNotice?.();
+    },
+    onUnavailable: (availability) => {
+      latestAvailability = availability;
+      show(availability);
+    },
+    resolvedTimeoutInMilliseconds: params.timeoutInMilliseconds ?? null
+  });
+}
+async function waitForPlugin(params) {
+  return await waitForAvailability({
+    ...params,
+    resolvedTimeoutInMilliseconds: params.timeoutInMilliseconds ?? DEFAULT_WAIT_FOR_PLUGIN_TIMEOUT_IN_MILLISECONDS
+  });
+}
+function createRequirementFragment(params, availability) {
+  const {
+    app,
+    minPluginVersion = "",
+    pluginId,
+    pluginName,
+    pluginNoticeComponent,
+    requestingPluginName
+  } = params;
+  const interpolation = {
+    minPluginVersion,
+    pluginName: asCodeBlock(requestingPluginName),
+    requiredPluginName: asCodeBlock(pluginName)
+  };
+  return createFragment((fragmentEl) => {
+    fragmentEl.append(createFragmentWithCodeBlocks(t(($) => {
+      switch (availability) {
+        case "invalidVersion" /* InvalidVersion */: {
+          return $.obsidianLib.pluginRequirement.invalidVersionNotice;
+        }
+        case "notEnabled" /* NotEnabled */: {
+          return $.obsidianLib.pluginRequirement.notEnabledNotice;
+        }
+        case "notInstalled" /* NotInstalled */: {
+          return $.obsidianLib.pluginRequirement.notInstalledNotice;
+        }
+        case "notLoaded" /* NotLoaded */: {
+          return $.obsidianLib.pluginRequirement.notLoadedNotice;
+        }
+        case "outdated" /* Outdated */: {
+          return $.obsidianLib.pluginRequirement.outdatedNotice;
+        }
+        default: {
+          return $.obsidianLib.pluginRequirement.shapeMismatchNotice;
+        }
+      }
+    }, interpolation)));
+    const buttonsEl = fragmentEl.createDiv({
+      cls: [CssClass.LibraryName, CssClass.PluginSuggestionNoticeButtons]
+    });
+    switch (availability) {
+      case "notEnabled" /* NotEnabled */:
+      case "notInstalled" /* NotInstalled */: {
+        new ButtonComponent(buttonsEl).setButtonText(t(
+          ($) => availability === "notEnabled" /* NotEnabled */ ? $.obsidianLib.pluginSuggestion.enable : $.obsidianLib.pluginSuggestion.install
+        )).setCta().onClick(convertAsyncToSync(async () => {
+          await runRepair(async () => {
+            await installAndEnablePlugin({
+              app,
+              pluginId,
+              pluginName,
+              pluginNoticeComponent
+            });
+          });
+        }));
+        break;
+      }
+      case "notLoaded" /* NotLoaded */: {
+        new ButtonComponent(buttonsEl).setButtonText(t(($) => $.obsidianLib.pluginRequirement.enable, { requiredPluginName: pluginName })).setCta().onClick(convertAsyncToSync(async () => {
+          await runRepair(async () => {
+            await loadEnabledPlugin(params);
+          });
+        }));
+        break;
+      }
+      default: {
+        new ButtonComponent(buttonsEl).setButtonText(t(($) => $.obsidianLib.pluginDependency.update, { dependencyPluginName: pluginName })).setCta().onClick(convertAsyncToSync(async () => {
+          await runRepair(async () => {
+            await updatePlugin({
+              app,
+              pluginId,
+              pluginName,
+              pluginNoticeComponent,
+              requestingPluginName
+            });
+          });
+        }));
+        break;
+      }
+    }
+    new ButtonComponent(buttonsEl).setButtonText(t(($) => $.obsidianLib.pluginRequirement.openCommunityPlugins)).onClick(() => {
+      openSettingTab({
+        app,
+        tabId: COMMUNITY_PLUGINS_SETTING_TAB_ID
+      });
+    });
+  });
+}
+async function loadEnabledPlugin(params) {
+  const {
+    app,
+    pluginId,
+    pluginName,
+    pluginNoticeComponent
+  } = params;
+  try {
+    if (!await app.plugins.enablePluginAndSave(pluginId)) {
+      throw new PluginEnableRefusedError(pluginId);
+    }
+  } catch (error) {
+    pluginNoticeComponent.showNotice(createFragmentWithCodeBlocks(
+      t(($) => $.obsidianLib.pluginRequirement.enableFailed, { requiredPluginName: asCodeBlock(pluginName) })
+    ));
+    throw error;
+  }
+}
+async function runRepair(repair) {
+  try {
+    await repair();
+  } catch (error) {
+    console.error(error);
+  }
+}
+async function waitForAvailability(params) {
+  const {
+    abortSignal,
+    app,
+    component,
+    onSettled,
+    onUnavailable,
+    pluginId,
+    resolvedTimeoutInMilliseconds
+  } = params;
+  abortSignal?.throwIfAborted();
+  return await new Promise((resolve, reject) => {
+    let isSettled = false;
+    let timeoutId = null;
+    let removeWaitComponent = null;
+    const eventRefs = [];
+    function cleanUp() {
+      isSettled = true;
+      removeWaitComponent?.();
+      removeWaitComponent = null;
+      for (const [source, eventRef] of eventRefs) {
+        source.offref(eventRef);
+      }
+      eventRefs.length = 0;
+      abortSignal?.removeEventListener("abort", handleAbort);
+      if (timeoutId !== null) {
+        window.clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      onSettled?.();
+    }
+    function fail(error) {
+      if (isSettled) {
+        return;
+      }
+      cleanUp();
+      reject(error);
+    }
+    function handleAbort($event) {
+      const reason = castTo($event.target).reason;
+      fail(reason instanceof Error ? reason : new Error(String(reason), { cause: reason }));
+    }
+    function check() {
+      const availability = getPluginAvailability(params);
+      if (availability === "available" /* Available */) {
+        const plugin = app.plugins.getPlugin(pluginId);
+        cleanUp();
+        resolve(plugin);
+        return;
+      }
+      onUnavailable?.(availability);
+    }
+    eventRefs.push(
+      [app.plugins, app.plugins.on(PLUGINS_CHANGED_EVENT_NAME, check)],
+      [app.workspace, app.workspace.on(PLUGIN_LOADED_EVENT_NAME, check)]
+    );
+    abortSignal?.addEventListener("abort", handleAbort);
+    if (component) {
+      const waitComponent = new Component();
+      waitComponent.register(() => {
+        fail(new Error(`The wait for plugin "${pluginId}" ended because its component unloaded.`));
+      });
+      component.addChild(waitComponent);
+      removeWaitComponent = () => {
+        component.removeChild(waitComponent);
+      };
+    }
+    if (resolvedTimeoutInMilliseconds !== null) {
+      timeoutId = window.setTimeout(() => {
+        fail(
+          new PluginInstanceUnavailableError({
+            availability: getPluginAvailability(params),
+            pluginId
+          })
+        );
+      }, resolvedTimeoutInMilliseconds);
+    }
+    check();
+  });
+}
+export {
+  PluginAvailability,
+  PluginInstanceUnavailableError,
+  getLoadedPlugin,
+  getPluginAvailability,
+  requirePlugin,
+  waitForPlugin
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/plugin/plugin-instance.ts"],"sourcesContent":["/**\n * @file\n *\n * Another plugin's INSTANCE: whether it is there, waiting for it, and asking the user to bring it in.\n *\n * This is the path for a plugin that publishes nothing through the library's registry, which is most of\n * them. A provider that does publish is better reached through `watchPluginApi` (`./plugin-api.ts`): its\n * reference is live, version-negotiated and revoked when the provider goes away, none of which a bare\n * instance offers. And a plugin that must STOP running when another one goes away declares it through\n * `PluginBase.getPluginDependencies()`, whose gate owns that teardown — {@link requirePlugin} is a one-shot\n * wait, not a second dependency system.\n *\n * What \"loaded\" can and cannot mean, read from Obsidian `1.15.1`:\n *\n * - `Plugins.loadPlugin` stores the instance in `app.plugins.plugins` BEFORE it awaits `plugin.load()`, and\n *   `Plugin.load` sets `_loaded` before it awaits `onload()`. So `app.plugins.getPlugin(id)` can return a\n *   plugin whose `onload` is still running, and `_loaded` cannot tell the two apart.\n *   `Plugins.enablePlugin` brackets the load with `loadingPluginId`, which is the one signal that does, so\n *   an instance whose id is `loadingPluginId` reads as {@link PluginAvailability.Loading}.\n * - `onload` having settled is the most anything can promise. A plugin that starts further work from\n *   `onload` without awaiting it, or waits for layout-ready, is \"loaded\" before that work is done, and\n *   Obsidian has no hook saying every plugin has finished initializing. A plugin built on this library\n *   says more through the `obsidian-lib:plugin-loaded` broadcast, which follows its published APIs.\n * - `app.plugins` is an `Events` source that triggers `changed`, debounced by one macrotask, after every\n *   enable, disable, install, uninstall and manifest reload. That is what a wait subscribes to, so nothing\n *   here polls. It fires after `enablePlugin` returned, when `loadingPluginId` is `null` again.\n *\n * A type argument alone is a caller's ASSERTION about the instance, not a check: nothing at runtime knows\n * what `TPlugin` is. Pass `isPlugin` to have the shape verified; an instance failing it reads as\n * {@link PluginAvailability.ShapeMismatch}, the usual sign of a release that renamed what the caller uses.\n */\n\nimport type {\n  App,\n  EventRef,\n  Events,\n  Plugin\n} from 'obsidian';\n\nimport { convertAsyncToSync } from '@mnaoumov/typescript-lib/async';\nimport { castTo } from '@mnaoumov/typescript-lib/object-utils';\nimport {\n  ButtonComponent,\n  Component\n} from 'obsidian';\n\nimport type { PluginNoticeComponent } from '../components/plugin-notice-component.ts';\n\nimport { PluginEnableRefusedError } from '../community-plugins.ts';\nimport { PluginNoticeMode } from '../components/plugin-notice-component.ts';\nimport { CssClass } from '../css-class.ts';\nimport {\n  asCodeBlock,\n  createFragmentWithCodeBlocks\n} from '../html-element.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { openSettingTab } from '../settings-modal.ts';\nimport {\n  comparePluginVersionWithMinimum,\n  installAndEnablePlugin,\n  PluginVersionComparison,\n  updatePlugin\n} from './plugin-install-state.ts';\nimport { PLUGIN_LOADED_EVENT_NAME } from './plugin-lifecycle-events.ts';\n\n/**\n * How long {@link waitForPlugin} waits by default before giving up.\n */\nconst DEFAULT_WAIT_FOR_PLUGIN_TIMEOUT_IN_MILLISECONDS = 10_000;\n\n/**\n * The event `app.plugins` triggers after every enable, disable, install, uninstall and manifest reload.\n */\nconst PLUGINS_CHANGED_EVENT_NAME = 'changed';\n\n/**\n * The id of Obsidian's community plugins settings tab.\n */\nconst COMMUNITY_PLUGINS_SETTING_TAB_ID = 'community-plugins';\n\n/**\n * Whether another plugin's instance can be used right now, and if not, why.\n */\nexport enum PluginAvailability {\n  /**\n   * Loaded, `onload` settled, and every declared requirement met.\n   */\n  Available = 'available',\n\n  /**\n   * Running at a release whose `manifest.version` cannot be parsed, while the caller declared a\n   * {@link GetPluginAvailabilityParams.minPluginVersion}. Counts as unavailable, because failing closed is the\n   * safe direction.\n   */\n  InvalidVersion = 'invalidVersion',\n\n  /**\n   * The instance exists but its `onload` has not settled yet.\n   */\n  Loading = 'loading',\n\n  /**\n   * Installed but neither enabled nor running.\n   */\n  NotEnabled = 'notEnabled',\n\n  /**\n   * Not installed in this vault.\n   */\n  NotInstalled = 'notInstalled',\n\n  /**\n   * Installed and enabled in the configuration, but no instance is running. At startup that is a plugin\n   * Obsidian has not reached yet; later it is one that failed to load, or one switched off by a disable that\n   * does not touch the configuration.\n   */\n  NotLoaded = 'notLoaded',\n\n  /**\n   * Running at a release older than the caller's {@link GetPluginAvailabilityParams.minPluginVersion}.\n   */\n  Outdated = 'outdated',\n\n  /**\n   * Running, but the caller's {@link GetPluginAvailabilityParams.isPlugin} rejected the instance.\n   */\n  ShapeMismatch = 'shapeMismatch'\n}\n\n/**\n * Parameters for {@link getLoadedPlugin}.\n *\n * @typeParam TPlugin - The plugin type the caller expects.\n */\nexport type GetLoadedPluginParams<TPlugin extends Plugin = Plugin> = GetPluginAvailabilityParams<TPlugin>;\n\n/**\n * Parameters for {@link getPluginAvailability}.\n *\n * @typeParam TPlugin - The plugin type the caller expects.\n */\nexport interface GetPluginAvailabilityParams<TPlugin extends Plugin = Plugin> {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Verifies that the running instance is the shape the caller uses. Without it, `TPlugin` is an\n   * assertion nothing checks.\n   *\n   * @param plugin - The running instance.\n   * @returns Whether the instance is a `TPlugin`.\n   */\n  readonly isPlugin?: (plugin: Plugin) => plugin is TPlugin;\n\n  /**\n   * The oldest release of the plugin the caller works with, compared with its `manifest.version`. This is\n   * a plugin RELEASE, never an API contract version: a provider publishing a versioned contract is reached\n   * through `watchPluginApi`'s `apiVersionRange` instead.\n   */\n  readonly minPluginVersion?: string;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for the {@link PluginInstanceUnavailableError} constructor.\n */\nexport interface PluginInstanceUnavailableErrorConstructorParams {\n  /**\n   * Why the plugin was unavailable when the wait gave up.\n   */\n  readonly availability: PluginAvailability;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * Parameters for {@link requirePlugin}.\n *\n * @typeParam TPlugin - The plugin type the caller expects.\n */\nexport interface RequirePluginParams<TPlugin extends Plugin = Plugin> extends GetPluginAvailabilityParams<TPlugin> {\n  /**\n   * Ends the wait early; the promise rejects with the signal's reason.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * The component owning the wait and its notice. Its unload ends both, rejecting the promise.\n   */\n  readonly component: Component;\n\n  /**\n   * The display name of the required plugin, shown to the user.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The asking plugin's notice component, which shows what is missing and the button that fixes it.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * The display name of the asking plugin, named in the notice.\n   */\n  readonly requestingPluginName: string;\n\n  /**\n   * How long to wait before giving up. By default the wait lasts until the user repairs the plugin, the\n   * {@link RequirePluginParams.abortSignal} aborts or the {@link RequirePluginParams.component} unloads.\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Parameters for {@link waitForPlugin}.\n *\n * @typeParam TPlugin - The plugin type the caller expects.\n */\nexport interface WaitForPluginParams<TPlugin extends Plugin = Plugin> extends GetPluginAvailabilityParams<TPlugin> {\n  /**\n   * Ends the wait early; the promise rejects with the signal's reason.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * A component whose unload ends the wait, rejecting the promise. Pass the waiting plugin, or the\n   * component that will use the instance, so a wait never outlives its consumer.\n   */\n  readonly component?: Component;\n\n  /**\n   * How long to wait before rejecting with a {@link PluginInstanceUnavailableError}.\n   *\n   * @default 10000\n   */\n  readonly timeoutInMilliseconds?: number;\n}\n\n/**\n * Parameters for the internal wait both public waits share.\n *\n * @typeParam TPlugin - The plugin type the caller expects.\n */\ninterface WaitForAvailabilityParams<TPlugin extends Plugin> extends WaitForPluginParams<TPlugin> {\n  /**\n   * Called once when the wait settles, either way, after every listener has been removed.\n   */\n  readonly onSettled?: () => void;\n\n  /**\n   * Called on every re-evaluation while the plugin is still unavailable, including the first.\n   *\n   * @param availability - The availability just read.\n   */\n  readonly onUnavailable?: (availability: PluginAvailability) => void;\n\n  /**\n   * The timeout, or `null` for none.\n   */\n  readonly resolvedTimeoutInMilliseconds: null | number;\n}\n\n/**\n * Thrown when a plugin did not become available before a wait gave up.\n */\nexport class PluginInstanceUnavailableError extends Error {\n  /**\n   * Why the plugin was unavailable when the wait gave up.\n   */\n  public readonly availability: PluginAvailability;\n\n  /**\n   * The `manifest.id` of the plugin.\n   */\n  public readonly pluginId: string;\n\n  /**\n   * Creates an instance of {@link PluginInstanceUnavailableError}.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginInstanceUnavailableErrorConstructorParams) {\n    super(`Plugin \"${params.pluginId}\" is not available: ${params.availability}.`);\n    this.name = 'PluginInstanceUnavailableError';\n    this.availability = params.availability;\n    this.pluginId = params.pluginId;\n  }\n}\n\n/**\n * Returns another plugin's instance when it is {@link PluginAvailability.Available}, and `null` otherwise.\n *\n * Unlike `app.plugins.getPlugin`, it never returns an instance whose `onload` is still running.\n *\n * @typeParam TPlugin - The plugin type the caller expects; checked only through `isPlugin`.\n * @param params - The {@link GetPluginAvailabilityParams}.\n * @returns The instance, or `null`.\n */\nexport function getLoadedPlugin<TPlugin extends Plugin = Plugin>(params: GetLoadedPluginParams<NoInfer<TPlugin>>): null | TPlugin {\n  return getPluginAvailability(params) === PluginAvailability.Available ? (params.app.plugins.getPlugin(params.pluginId) as TPlugin) : null;\n}\n\n/**\n * Reads whether another plugin's instance can be used right now, and if not, why.\n *\n * @typeParam TPlugin - The plugin type the caller expects.\n * @param params - The {@link GetPluginAvailabilityParams}.\n * @returns The {@link PluginAvailability}.\n */\nexport function getPluginAvailability<TPlugin extends Plugin = Plugin>(params: GetPluginAvailabilityParams<NoInfer<TPlugin>>): PluginAvailability {\n  const {\n    app,\n    isPlugin,\n    minPluginVersion,\n    pluginId\n  } = params;\n  const plugin = app.plugins.getPlugin(pluginId);\n\n  if (plugin === null) {\n    if (!Object.hasOwn(app.plugins.manifests, pluginId)) {\n      return PluginAvailability.NotInstalled;\n    }\n\n    return app.plugins.enabledPlugins.has(pluginId) ? PluginAvailability.NotLoaded : PluginAvailability.NotEnabled;\n  }\n\n  if (app.plugins.loadingPluginId === pluginId) {\n    return PluginAvailability.Loading;\n  }\n\n  if (minPluginVersion !== undefined) {\n    const comparison = comparePluginVersionWithMinimum(plugin.manifest.version, minPluginVersion);\n    if (comparison === PluginVersionComparison.BelowMinimum) {\n      return PluginAvailability.Outdated;\n    }\n\n    if (comparison === PluginVersionComparison.Invalid) {\n      return PluginAvailability.InvalidVersion;\n    }\n  }\n\n  return isPlugin && !isPlugin(plugin) ? PluginAvailability.ShapeMismatch : PluginAvailability.Available;\n}\n\n/**\n * Waits for another plugin to become {@link PluginAvailability.Available}, asking the user to repair it\n * while it is not.\n *\n * Resolves at once when it already is. Otherwise, once the workspace layout is ready — before that, a\n * plugin Obsidian has not loaded yet is indistinguishable from a missing one — a notice says what is wrong\n * and offers the matching repair: install, enable, or update, plus a way to the community plugins list.\n * The notice follows the state as it changes and goes away when the wait settles. A repair that fails is\n * reported and leaves the wait running, so the user can try again or fix it by hand.\n *\n * The promise settles ONCE. It does not watch the plugin afterwards: a consumer that must stop when the\n * plugin goes away declares a dependency through `PluginBase.getPluginDependencies()` instead.\n *\n * @typeParam TPlugin - The plugin type the caller expects; checked only through `isPlugin`.\n * @param params - The {@link RequirePluginParams}.\n * @returns A {@link Promise} resolving with the instance.\n * @throws The abort reason, or an error naming the unloaded component, when the wait is ended early.\n * @throws {@link PluginInstanceUnavailableError} When {@link RequirePluginParams.timeoutInMilliseconds} elapses.\n */\nexport async function requirePlugin<TPlugin extends Plugin = Plugin>(params: RequirePluginParams<NoInfer<TPlugin>>): Promise<TPlugin> {\n  const { app } = params;\n  let shownAvailability: null | PluginAvailability = null;\n  // `Loading` is never shown, so it stands in for \"not read yet\".\n  let latestAvailability = PluginAvailability.Loading;\n  let hideNotice: (() => void) | null = null;\n  let isSettled = false;\n\n  function show(availability: PluginAvailability): void {\n    if (isSettled || !app.workspace.layoutReady || availability === shownAvailability || availability === PluginAvailability.Loading) {\n      return;\n    }\n\n    hideNotice?.();\n    shownAvailability = availability;\n    const notice = params.pluginNoticeComponent.showNotice(createRequirementFragment(params, availability), {\n      mode: PluginNoticeMode.Separate,\n      shouldHideOnClick: false\n    });\n    hideNotice = (): void => {\n      notice.hide();\n    };\n  }\n\n  if (!app.workspace.layoutReady) {\n    app.workspace.onLayoutReady(() => {\n      show(latestAvailability);\n    });\n  }\n\n  return await waitForAvailability({\n    ...params,\n    onSettled: () => {\n      isSettled = true;\n      hideNotice?.();\n    },\n    onUnavailable: (availability) => {\n      latestAvailability = availability;\n      show(availability);\n    },\n    resolvedTimeoutInMilliseconds: params.timeoutInMilliseconds ?? null\n  });\n}\n\n/**\n * Waits for another plugin to become {@link PluginAvailability.Available}.\n *\n * Resolves at once when it already is, which covers a consumer reloaded after its dependency. Otherwise it\n * re-reads the state on every `app.plugins` `changed` and every `obsidian-lib:plugin-loaded` broadcast, so a\n * plugin enabled, updated or reloaded later is picked up with no polling. It subscribes before its first\n * read, so a change landing in between cannot be missed. Every listener and timer is removed when it settles.\n *\n * @typeParam TPlugin - The plugin type the caller expects; checked only through `isPlugin`.\n * @param params - The {@link WaitForPluginParams}.\n * @returns A {@link Promise} resolving with the instance.\n * @throws The abort reason, or an error naming the unloaded component, when the wait is ended early.\n * @throws {@link PluginInstanceUnavailableError} When the timeout elapses, carrying the availability at that moment.\n */\nexport async function waitForPlugin<TPlugin extends Plugin = Plugin>(params: WaitForPluginParams<NoInfer<TPlugin>>): Promise<TPlugin> {\n  return await waitForAvailability({\n    ...params,\n    resolvedTimeoutInMilliseconds: params.timeoutInMilliseconds ?? DEFAULT_WAIT_FOR_PLUGIN_TIMEOUT_IN_MILLISECONDS\n  });\n}\n\nfunction createRequirementFragment<TPlugin extends Plugin>(params: RequirePluginParams<TPlugin>, availability: PluginAvailability): DocumentFragment {\n  const {\n    app,\n    minPluginVersion = '',\n    pluginId,\n    pluginName,\n    pluginNoticeComponent,\n    requestingPluginName\n  } = params;\n  const interpolation = {\n    minPluginVersion,\n    pluginName: asCodeBlock(requestingPluginName),\n    requiredPluginName: asCodeBlock(pluginName)\n  };\n\n  return createFragment((fragmentEl) => {\n    fragmentEl.append(createFragmentWithCodeBlocks(t(($) => {\n      switch (availability) {\n        case PluginAvailability.InvalidVersion: {\n          return $.obsidianLib.pluginRequirement.invalidVersionNotice;\n        }\n        case PluginAvailability.NotEnabled: {\n          return $.obsidianLib.pluginRequirement.notEnabledNotice;\n        }\n        case PluginAvailability.NotInstalled: {\n          return $.obsidianLib.pluginRequirement.notInstalledNotice;\n        }\n        case PluginAvailability.NotLoaded: {\n          return $.obsidianLib.pluginRequirement.notLoadedNotice;\n        }\n        case PluginAvailability.Outdated: {\n          return $.obsidianLib.pluginRequirement.outdatedNotice;\n        }\n        default: {\n          return $.obsidianLib.pluginRequirement.shapeMismatchNotice;\n        }\n      }\n    }, interpolation)));\n\n    const buttonsEl = fragmentEl.createDiv({\n      cls: [CssClass.LibraryName, CssClass.PluginSuggestionNoticeButtons]\n    });\n\n    switch (availability) {\n      case PluginAvailability.NotEnabled:\n      case PluginAvailability.NotInstalled: {\n        new ButtonComponent(buttonsEl)\n          .setButtonText(t(($) =>\n            availability === PluginAvailability.NotEnabled\n              ? $.obsidianLib.pluginSuggestion.enable\n              : $.obsidianLib.pluginSuggestion.install\n          ))\n          .setCta()\n          .onClick(convertAsyncToSync(async () => {\n            await runRepair(async () => {\n              await installAndEnablePlugin({\n                app,\n                pluginId,\n                pluginName,\n                pluginNoticeComponent\n              });\n            });\n          }));\n        break;\n      }\n      case PluginAvailability.NotLoaded: {\n        new ButtonComponent(buttonsEl)\n          .setButtonText(t(($) => $.obsidianLib.pluginRequirement.enable, { requiredPluginName: pluginName }))\n          .setCta()\n          .onClick(convertAsyncToSync(async () => {\n            await runRepair(async () => {\n              await loadEnabledPlugin(params);\n            });\n          }));\n        break;\n      }\n      default: {\n        new ButtonComponent(buttonsEl)\n          .setButtonText(t(($) => $.obsidianLib.pluginDependency.update, { dependencyPluginName: pluginName }))\n          .setCta()\n          .onClick(convertAsyncToSync(async () => {\n            await runRepair(async () => {\n              await updatePlugin({\n                app,\n                pluginId,\n                pluginName,\n                pluginNoticeComponent,\n                requestingPluginName\n              });\n            });\n          }));\n        break;\n      }\n    }\n\n    new ButtonComponent(buttonsEl)\n      .setButtonText(t(($) => $.obsidianLib.pluginRequirement.openCommunityPlugins))\n      .onClick(() => {\n        openSettingTab({\n          app,\n          tabId: COMMUNITY_PLUGINS_SETTING_TAB_ID\n        });\n      });\n  });\n}\n\n/**\n * Loads a plugin that is enabled in the configuration but not running, the one case\n * `installAndEnablePlugin` treats as already done.\n *\n * @typeParam TPlugin - The plugin type the caller expects.\n * @param params - The requirement.\n * @returns A {@link Promise} that resolves once the plugin is loaded.\n */\nasync function loadEnabledPlugin<TPlugin extends Plugin>(params: RequirePluginParams<TPlugin>): Promise<void> {\n  const {\n    app,\n    pluginId,\n    pluginName,\n    pluginNoticeComponent\n  } = params;\n\n  try {\n    if (!await app.plugins.enablePluginAndSave(pluginId)) {\n      throw new PluginEnableRefusedError(pluginId);\n    }\n  } catch (error) {\n    pluginNoticeComponent.showNotice(createFragmentWithCodeBlocks(\n      t(($) => $.obsidianLib.pluginRequirement.enableFailed, { requiredPluginName: asCodeBlock(pluginName) })\n    ));\n    throw error;\n  }\n}\n\n/**\n * Runs a repair the user clicked. Its failure has already been shown as a notice, and the wait it belongs to\n * keeps running so the user can try again, so it is logged rather than rethrown into the click handler.\n *\n * @param repair - The repair.\n * @returns A {@link Promise} that resolves once the repair has run.\n */\nasync function runRepair(repair: () => Promise<void>): Promise<void> {\n  try {\n    await repair();\n  } catch (error) {\n    console.error(error);\n  }\n}\n\nasync function waitForAvailability<TPlugin extends Plugin>(params: WaitForAvailabilityParams<TPlugin>): Promise<TPlugin> {\n  const {\n    abortSignal,\n    app,\n    component,\n    onSettled,\n    onUnavailable,\n    pluginId,\n    resolvedTimeoutInMilliseconds\n  } = params;\n\n  abortSignal?.throwIfAborted();\n\n  return await new Promise<TPlugin>((resolve, reject) => {\n    let isSettled = false;\n    let timeoutId: null | number = null;\n    let removeWaitComponent: (() => void) | null = null;\n    const eventRefs: [Events, EventRef][] = [];\n\n    function cleanUp(): void {\n      isSettled = true;\n      removeWaitComponent?.();\n      removeWaitComponent = null;\n      for (const [source, eventRef] of eventRefs) {\n        source.offref(eventRef);\n      }\n      eventRefs.length = 0;\n      abortSignal?.removeEventListener('abort', handleAbort);\n      if (timeoutId !== null) {\n        window.clearTimeout(timeoutId);\n        timeoutId = null;\n      }\n      onSettled?.();\n    }\n\n    function fail(error: Error): void {\n      if (isSettled) {\n        return;\n      }\n\n      cleanUp();\n      reject(error);\n    }\n\n    function handleAbort($event: Event): void {\n      const reason: unknown = castTo<AbortSignal>($event.target).reason;\n      fail(reason instanceof Error ? reason : new Error(String(reason), { cause: reason }));\n    }\n\n    // No settled guard: settling removes both listeners, and nothing else calls this.\n    function check(): void {\n      const availability = getPluginAvailability(params);\n      if (availability === PluginAvailability.Available) {\n        const plugin = app.plugins.getPlugin(pluginId) as TPlugin;\n        cleanUp();\n        resolve(plugin);\n        return;\n      }\n\n      onUnavailable?.(availability);\n    }\n\n    // Subscribe BEFORE the first read, so a change landing between the read and the subscription cannot be\n    // missed.\n    eventRefs.push(\n      [app.plugins, app.plugins.on(PLUGINS_CHANGED_EVENT_NAME, check)],\n      [app.workspace, app.workspace.on(PLUGIN_LOADED_EVENT_NAME, check)]\n    );\n    abortSignal?.addEventListener('abort', handleAbort);\n\n    if (component) {\n      // A child rather than `component.register`, because a component cannot forget a registered callback:\n      // removing the child on settle is what keeps a long-lived consumer from collecting one per wait.\n      const waitComponent = new Component();\n      waitComponent.register(() => {\n        fail(new Error(`The wait for plugin \"${pluginId}\" ended because its component unloaded.`));\n      });\n      component.addChild(waitComponent);\n      removeWaitComponent = (): void => {\n        component.removeChild(waitComponent);\n      };\n    }\n\n    if (resolvedTimeoutInMilliseconds !== null) {\n      timeoutId = window.setTimeout(() => {\n        fail(\n          new PluginInstanceUnavailableError({\n            availability: getPluginAvailability(params),\n            pluginId\n          })\n        );\n      }, resolvedTimeoutInMilliseconds);\n    }\n\n    check();\n  });\n}\n"],"mappings":"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","names":["PluginAvailability"]}

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

@@ -352,6 +352,13 @@ export declare abstract class PluginBase extends PluginBase_base implements Plug
      * got past its dependency gate never announced itself, and must not announce a departure either.
      */
     private broadcastUnloaded;
+    /**
+     * Checks whether a feature surface whose load is in progress has since been torn down or replaced.
+     *
+     * @param gatedWrapperComponent - The surface being loaded.
+     * @returns `true` when the surface is no longer the plugin's live one.
+     */
+    private isFeatureSurfaceGone;
     /**
      * Builds and loads the subclass's feature surface, then publishes its APIs and announces itself.
      *