obsidian-dev-utils 101.6.0 → 101.7.0

package/dist/lib/esm/obsidian/components/plugin-gate-component.mjs

@@ -0,0 +1,428 @@
+/*
+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 { satisfies as satisfiesVersion } from "compare-versions";
+import {
+  ButtonComponent,
+  PluginSettingTab
+} from "obsidian";
+import { convertAsyncToSync } from "../../async.mjs";
+import { disableCommunityPlugin } from "../community-plugins.mjs";
+import { CssClass } from "../css-class.mjs";
+import {
+  asCodeBlock,
+  createFragmentWithCodeBlocks
+} from "../html-element.mjs";
+import { t } from "../i18n/i18n.mjs";
+import { watchPluginApi } from "../plugin/plugin-api.mjs";
+import {
+  getInstalledPluginState,
+  getInstalledPluginVersion,
+  installAndEnablePlugin,
+  InstalledPluginState
+} from "../plugin/plugin-install-state.mjs";
+import {
+  PLUGIN_LOADED_EVENT_NAME,
+  PLUGIN_UNLOADED_EVENT_NAME
+} from "../plugin/plugin-lifecycle-events.mjs";
+import { registerAsyncEvent } from "./async-events-component.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+import { CallbackLayoutReadyComponent } from "./layout-ready-component.mjs";
+var PluginConflictSeverity = /* @__PURE__ */ ((PluginConflictSeverity2) => {
+  PluginConflictSeverity2["Block"] = "block";
+  PluginConflictSeverity2["Warn"] = "warn";
+  return PluginConflictSeverity2;
+})(PluginConflictSeverity || {});
+class BlockedPluginSettingTab extends PluginSettingTab {
+  renderBanner;
+  /**
+   * Creates an instance of {@link BlockedPluginSettingTab}.
+   *
+   * @param params - The constructor parameters.
+   */
+  constructor(params) {
+    super(params.plugin.app, params.plugin);
+    this.renderBanner = params.renderBanner;
+  }
+  /**
+   * Renders the tab.
+   */
+  display() {
+    this.containerEl.empty();
+    this.renderBanner(this.containerEl);
+  }
+}
+class PluginGateComponent extends ComponentEx {
+  announcedWarningPluginIds = /* @__PURE__ */ new Set();
+  apiRefs = /* @__PURE__ */ new Map();
+  blockedSettingTab = null;
+  conflicts;
+  dependencies;
+  hasAnnouncedBlocked = false;
+  isFeatureSurfaceLoaded = false;
+  isLayoutReady = false;
+  loadFeatureSurface;
+  plugin;
+  pluginNoticeComponent;
+  unloadFeatureSurface;
+  get app() {
+    return this.plugin.app;
+  }
+  /**
+   * Creates an instance of {@link PluginGateComponent}.
+   *
+   * @param params - The constructor parameters.
+   */
+  constructor(params) {
+    super();
+    this.conflicts = params.conflicts;
+    this.dependencies = params.dependencies;
+    this.loadFeatureSurface = params.loadFeatureSurface;
+    this.plugin = params.plugin;
+    this.pluginNoticeComponent = params.pluginNoticeComponent;
+    this.unloadFeatureSurface = params.unloadFeatureSurface;
+  }
+  /**
+   * Starts watching every declared dependency and conflict.
+   */
+  onload() {
+    for (const dependency of this.dependencies) {
+      const apiRef = watchPluginApi({
+        apiVersionRange: dependency.apiVersionRange,
+        app: this.app,
+        component: this,
+        pluginId: dependency.pluginId
+      });
+      registerAsyncEvent(
+        this,
+        apiRef.on("change", async () => {
+          await this.refresh();
+        })
+      );
+      this.apiRefs.set(dependency.pluginId, apiRef);
+    }
+    const lifecycleEventNames = [PLUGIN_LOADED_EVENT_NAME, PLUGIN_UNLOADED_EVENT_NAME];
+    for (const eventName of lifecycleEventNames) {
+      this.registerEvent(this.app.workspace.on(
+        eventName,
+        convertAsyncToSync(async (payload) => {
+          if (payload.pluginId === this.plugin.manifest.id) {
+            return;
+          }
+          await this.refresh();
+        })
+      ));
+    }
+    this.addChild(
+      new CallbackLayoutReadyComponent(this.app, () => {
+        this.isLayoutReady = true;
+        this.presentUnsatisfied(this.getUnsatisfiedDependencies(), this.getActiveConflicts("block" /* Block */));
+        this.announceWarnings();
+      })
+    );
+    this.register(() => {
+      this.hideBlockedSettingTab();
+    });
+  }
+  /**
+   * Evaluates the gate once the watches are in place, loading the feature surface if it is already open.
+   *
+   * @returns A {@link Promise} that resolves once the first evaluation is complete.
+   */
+  async onloadAsync() {
+    await this.refresh();
+  }
+  /**
+   * Renders a banner for every conflict the host is running alongside, so a plugin can put the overlap in
+   * its own settings tab.
+   *
+   * Consumer-invoked, exactly like `PluginSuggestionComponent.renderBanner`: the library registers the
+   * settings tab a BLOCKED plugin needs, because that plugin never got to register one of its own, but it
+   * has no hook into the tab a running plugin builds. Renders nothing when no warning conflict holds.
+   *
+   * @param containerEl - The element to render into.
+   */
+  renderConflictWarningBanner(containerEl) {
+    for (const conflict of this.getActiveConflicts("warn" /* Warn */)) {
+      this.renderConflictEntry(containerEl, conflict, this.createConflictWarningMessage(conflict));
+    }
+  }
+  announceWarnings() {
+    if (!this.isLayoutReady || !this.isFeatureSurfaceLoaded) {
+      return;
+    }
+    for (const conflict of this.getActiveConflicts("warn" /* Warn */)) {
+      if (this.announcedWarningPluginIds.has(conflict.pluginId)) {
+        continue;
+      }
+      this.announcedWarningPluginIds.add(conflict.pluginId);
+      this.pluginNoticeComponent.showNotice(this.createConflictWarningMessage(conflict));
+    }
+  }
+  createBlockedMessage(dependency) {
+    return createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginDependency.blockedNotice, {
+      dependencyPluginName: asCodeBlock(dependency.pluginName),
+      pluginName: asCodeBlock(this.plugin.manifest.name)
+    }));
+  }
+  createConflictAppearedMessage(conflict) {
+    return createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginConflict.conflictAppearedNotice, {
+      conflictingPluginName: asCodeBlock(conflict.pluginName),
+      pluginName: asCodeBlock(this.plugin.manifest.name)
+    }));
+  }
+  createConflictBlockedMessage(conflict) {
+    return createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginConflict.blockedNotice, {
+      conflictingPluginName: asCodeBlock(conflict.pluginName),
+      pluginName: asCodeBlock(this.plugin.manifest.name)
+    }));
+  }
+  createConflictWarningMessage(conflict) {
+    return createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginConflict.warningNotice, {
+      conflictingPluginName: asCodeBlock(conflict.pluginName),
+      pluginName: asCodeBlock(this.plugin.manifest.name)
+    }));
+  }
+  createDependencyLostMessage(dependency) {
+    return createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginDependency.dependencyLostNotice, {
+      dependencyPluginName: asCodeBlock(dependency.pluginName),
+      pluginName: asCodeBlock(this.plugin.manifest.name)
+    }));
+  }
+  /**
+   * Finds the declared conflicts of one severity that are currently in force.
+   *
+   * @param severity - The severity to select.
+   * @returns The conflicts holding right now, in the order they were declared.
+   */
+  getActiveConflicts(severity) {
+    return this.conflicts.filter((conflict) => conflict.severity === severity && this.isConflictActive(conflict));
+  }
+  getUnsatisfiedDependencies() {
+    return this.dependencies.filter((dependency) => !this.apiRefs.get(dependency.pluginId)?.value);
+  }
+  hideBlockedSettingTab() {
+    if (!this.blockedSettingTab) {
+      return;
+    }
+    this.app.setting.removeSettingTab(this.blockedSettingTab);
+    this.blockedSettingTab = null;
+  }
+  /**
+   * Decides whether one declared conflict is in force right now.
+   *
+   * Only an ENABLED plugin counts. One that is installed but switched off registers nothing, so it cannot
+   * collide, and acting on it would be an alarm the user can only answer by uninstalling something they
+   * have already turned off.
+   *
+   * @param conflict - The declared conflict.
+   * @returns Whether the conflicting plugin is enabled at a conflicting version.
+   */
+  isConflictActive(conflict) {
+    const installedVersion = getInstalledPluginVersion({
+      app: this.app,
+      pluginId: conflict.pluginId
+    });
+    if (installedVersion === null) {
+      return false;
+    }
+    try {
+      return satisfiesVersion(installedVersion, conflict.conflictingVersionRange);
+    } catch {
+      return true;
+    }
+  }
+  /**
+   * Says what is in the way, and puts the same explanation where the user will look for the plugin's
+   * settings.
+   *
+   * @param unsatisfiedDependencies - The dependencies that are not currently satisfied.
+   * @param blockingConflicts - The conflicts currently refusing the plugin the right to run.
+   */
+  presentUnsatisfied(unsatisfiedDependencies, blockingConflicts) {
+    if (!this.isLayoutReady || unsatisfiedDependencies.length === 0 && blockingConflicts.length === 0) {
+      return;
+    }
+    this.showBlockedSettingTab(unsatisfiedDependencies, blockingConflicts);
+    if (this.hasAnnouncedBlocked) {
+      return;
+    }
+    this.hasAnnouncedBlocked = true;
+    for (const dependency of unsatisfiedDependencies) {
+      this.pluginNoticeComponent.showNotice(this.createBlockedMessage(dependency));
+    }
+    for (const conflict of blockingConflicts) {
+      this.pluginNoticeComponent.showNotice(this.createConflictBlockedMessage(conflict));
+    }
+  }
+  /**
+   * Re-evaluates the gate and moves the feature surface to match.
+   *
+   * @returns A {@link Promise} that resolves once the surface matches the gate.
+   */
+  async refresh() {
+    const unsatisfiedDependencies = this.getUnsatisfiedDependencies();
+    const blockingConflicts = this.getActiveConflicts("block" /* Block */);
+    if (unsatisfiedDependencies.length === 0 && blockingConflicts.length === 0) {
+      this.hideBlockedSettingTab();
+      this.hasAnnouncedBlocked = false;
+      if (!this.isFeatureSurfaceLoaded) {
+        this.isFeatureSurfaceLoaded = true;
+        await this.loadFeatureSurface();
+      }
+      this.announceWarnings();
+      return;
+    }
+    if (this.isFeatureSurfaceLoaded) {
+      this.isFeatureSurfaceLoaded = false;
+      this.unloadFeatureSurface();
+      for (const dependency of unsatisfiedDependencies) {
+        this.pluginNoticeComponent.showNotice(this.createDependencyLostMessage(dependency));
+      }
+      for (const conflict of blockingConflicts) {
+        this.pluginNoticeComponent.showNotice(this.createConflictAppearedMessage(conflict));
+      }
+      this.hasAnnouncedBlocked = true;
+      this.showBlockedSettingTab(unsatisfiedDependencies, blockingConflicts);
+      return;
+    }
+    this.presentUnsatisfied(unsatisfiedDependencies, blockingConflicts);
+  }
+  /**
+   * Renders the blocked explanation into a settings-tab container: what is missing or in the way, why it
+   * matters, and the button that fixes it.
+   *
+   * @param containerEl - The element to render into.
+   * @param unsatisfiedDependencies - The dependencies that are not currently satisfied.
+   * @param blockingConflicts - The conflicts currently refusing the plugin the right to run.
+   */
+  renderBlockedBanner(containerEl, unsatisfiedDependencies, blockingConflicts) {
+    if (unsatisfiedDependencies.length > 0) {
+      containerEl.createEl("h2", { text: t(($) => $.obsidianDevUtils.pluginDependency.settingsHeading) });
+    }
+    for (const dependency of unsatisfiedDependencies) {
+      const bannerEl = containerEl.createDiv({
+        cls: [CssClass.LibraryName, CssClass.PluginDependencyBanner]
+      });
+      bannerEl.append(this.createBlockedMessage(dependency));
+      bannerEl.createDiv({ text: dependency.reason });
+      const state = getInstalledPluginState({
+        app: this.app,
+        pluginId: dependency.pluginId
+      });
+      new ButtonComponent(bannerEl).setButtonText(t(
+        ($) => state === InstalledPluginState.InstalledButDisabled ? $.obsidianDevUtils.pluginSuggestion.enable : $.obsidianDevUtils.pluginSuggestion.install
+      )).setCta().onClick(convertAsyncToSync(async () => {
+        await installAndEnablePlugin({
+          app: this.app,
+          pluginId: dependency.pluginId,
+          pluginName: dependency.pluginName,
+          pluginNoticeComponent: this.pluginNoticeComponent
+        });
+      }));
+      if (state !== InstalledPluginState.Enabled) {
+        continue;
+      }
+      this.renderOpenSettingsButton(bannerEl, dependency.pluginId, dependency.pluginName);
+    }
+    if (blockingConflicts.length === 0) {
+      return;
+    }
+    containerEl.createEl("h2", { text: t(($) => $.obsidianDevUtils.pluginConflict.settingsHeading) });
+    for (const conflict of blockingConflicts) {
+      this.renderConflictEntry(containerEl, conflict, this.createConflictBlockedMessage(conflict));
+    }
+  }
+  /**
+   * Renders one conflict: what it is, why it matters, and the two ways out of it.
+   *
+   * The repair is offered on the OTHER plugin — disabling it is the one thing this plugin can do in a
+   * click, since it cannot update someone else's plugin — and it is the persisted `disablePluginAndSave`
+   * rather than the transient disable, because the user asked for it by clicking.
+   *
+   * @param containerEl - The element to render into.
+   * @param conflict - The conflict to render.
+   * @param messageFragment - The sentence explaining the conflict.
+   */
+  renderConflictEntry(containerEl, conflict, messageFragment) {
+    const bannerEl = containerEl.createDiv({
+      cls: [CssClass.LibraryName, CssClass.PluginConflictBanner]
+    });
+    bannerEl.append(messageFragment);
+    bannerEl.createDiv({ text: conflict.reason });
+    new ButtonComponent(bannerEl).setButtonText(t(($) => $.obsidianDevUtils.pluginConflict.disable, { conflictingPluginName: conflict.pluginName })).setCta().onClick(convertAsyncToSync(async () => {
+      await disableCommunityPlugin({
+        app: this.app,
+        pluginId: conflict.pluginId
+      });
+      await this.refresh();
+    }));
+    this.renderOpenSettingsButton(bannerEl, conflict.pluginId, conflict.pluginName);
+  }
+  renderOpenSettingsButton(bannerEl, pluginId, pluginName) {
+    new ButtonComponent(bannerEl).setButtonText(t(($) => $.obsidianDevUtils.pluginDependency.openDependencySettings, {
+      dependencyPluginName: pluginName
+    })).onClick(() => {
+      this.app.setting.open();
+      this.app.setting.openTabById(pluginId);
+    });
+  }
+  showBlockedSettingTab(unsatisfiedDependencies, blockingConflicts) {
+    if (this.blockedSettingTab) {
+      return;
+    }
+    const blockedSettingTab = new BlockedPluginSettingTab({
+      plugin: this.plugin,
+      renderBanner: (containerEl) => {
+        this.renderBlockedBanner(containerEl, unsatisfiedDependencies, blockingConflicts);
+      }
+    });
+    this.app.setting.addSettingTab(blockedSettingTab);
+    this.blockedSettingTab = blockedSettingTab;
+  }
+}
+export {
+  PluginConflictSeverity,
+  PluginGateComponent
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/plugin-gate-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The gate on a plugin's feature surface: what must be PRESENT for it to run, and what must NOT be.\n *\n * Both halves answer the same question \u2014 may this plugin's `onloadImpl` run right now? \u2014 so they are one\n * component rather than two. A second, independent gate would double-load the surface and stack a second\n * \"blocked\" settings tab onto the same plugin, and neither could see the other's reason for refusing.\n *\n * ## Dependencies: a plugin declaring what it cannot work without\n *\n * This is the strict sibling of `PluginSuggestionComponent`, and the difference is the whole point. A\n * SUGGESTION is an offer \u2014 the host keeps working without it and simply cannot do one thing. A DEPENDENCY\n * is a requirement: `onloadImpl` never runs, no command is registered, no handler is installed, nothing is\n * patched. Reach for a suggestion when the other plugin adds something; reach for a dependency when the\n * host's advertised behavior is not there without it.\n *\n * Obsidian has no dependency field in a manifest, which is exactly the problem this closes. Without one,\n * a user meeting an unfamiliar plugin in their list months later has nothing telling them it is\n * load-bearing \u2014 they remove it, and the breakage surfaces weeks after that as damage they cannot connect\n * to anything they did. So the relationship is made visible from both ends and enforced while it holds:\n * the dependent explains itself where the user is looking, repairs itself in one click, and reacts the\n * INSTANT the dependency goes away rather than degrading quietly.\n *\n * Three choices are deliberate and worth stating, because each has an obvious-looking alternative:\n *\n * - **Blocked means enabled-but-inert, never self-disabled.** Calling `disablePluginAndSave` on itself\n *   would be the literal reading of \"refuses to load\", and it rewrites a config that belongs to the user \u2014\n *   who would then have to remember to re-enable it after fixing the dependency. Staying enabled and inert\n *   says the same thing to the user, changes nothing they own, and can undo itself.\n * - **Blocked is not an error.** Throwing from `onload` marks the plugin failed in Obsidian and hands the\n *   user a stack trace instead of a sentence and a button.\n * - **A dependency must publish an API.** That is what makes presence, absence, version and departure all\n *   observable through one mechanism \u2014 `watchPluginApi`'s reference is live, is revoked when the provider\n *   unloads, and already classifies not-installed against not-enabled against too-old. A provider with\n *   nothing to expose can publish an empty API purely so it can be depended upon; the alternative would be\n *   a second, weaker detection path to maintain beside it.\n *\n * ## Conflicts: a plugin declaring what it refuses to run beside\n *\n * The inverse relationship, and it needs its own detection path because the dependency one does not fit.\n * A conflicting plugin is typically an OLD version of some other plugin that still owns behavior this one\n * has taken over \u2014 it publishes no API at all, so there is no `apiVersionRange` to compare against.\n *\n * The argument for refusing rather than competing comes from the case this generalizes: two rename/delete\n * handlers acting on one rename corrupt links and move attachments twice, and there is no reliable way to\n * win that race \u2014 a handler is elected by registry order, but the patches that do the work sit outside\n * that election, so whichever plugin loaded first keeps a hand on the wheel. Every scheme for seizing\n * control from inside is load-order dependent. Refusing is deterministic where competing is not, and a\n * vault that briefly has no handler is a far better outcome than one with two.\n *\n * Two details of that detection carry over verbatim, because both are load-bearing:\n *\n * - **Versions are read, never the registry.** A plugin that has not loaded yet has registered nothing, so\n *   asking the registry gives a different answer depending on when it is asked. `app.plugins.manifests` is\n *   populated for every installed plugin at startup, whatever the load order turns out to be.\n * - **An unparseable version counts as conflicting.** Failing closed is the safe direction: a false alarm\n *   costs a notice, a false all-clear costs a vault.\n *\n * Not every overlap is that severe, which is why a conflict declares a {@link PluginConflictSeverity}.\n * Two plugins shipping the same command duplicate a palette entry and do the work twice \u2014 annoying, not\n * corrupting \u2014 and refusing to load over that would be a worse outcome than the overlap. Those declare\n * {@link PluginConflictSeverity.Warn} and both keep running.\n *\n * ## What this can and cannot see\n *\n * Obsidian raises no event when ANOTHER plugin is enabled or disabled (see `plugin-lifecycle-events.ts`),\n * so live conflict detection has a real ceiling and it is stated here rather than implied away. A\n * conflicting plugin built on this library announces itself through the lifecycle broadcast, and is\n * therefore caught the moment it is enabled or disabled. One that is not \u2014 an old release predating the\n * broadcast, or a plugin by another author entirely \u2014 is caught at the next load, which is when its\n * manifest is read.\n */\n\nimport type {\n  App,\n  Plugin\n} from 'obsidian';\n\nimport { satisfies as satisfiesVersion } from 'compare-versions';\nimport {\n  ButtonComponent,\n  PluginSettingTab\n} from 'obsidian';\n\nimport type { PluginApiRef } from '../plugin/plugin-api.ts';\nimport type {\n  PluginLifecycleEventName,\n  PluginLifecycleEventPayload\n} from '../plugin/plugin-lifecycle-events.ts';\nimport type { PluginNoticeComponent } from './plugin-notice-component.ts';\n\nimport { convertAsyncToSync } from '../../async.ts';\nimport { disableCommunityPlugin } from '../community-plugins.ts';\nimport { CssClass } from '../css-class.ts';\nimport {\n  asCodeBlock,\n  createFragmentWithCodeBlocks\n} from '../html-element.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { watchPluginApi } from '../plugin/plugin-api.ts';\nimport {\n  getInstalledPluginState,\n  getInstalledPluginVersion,\n  installAndEnablePlugin,\n  InstalledPluginState\n} from '../plugin/plugin-install-state.ts';\nimport {\n  PLUGIN_LOADED_EVENT_NAME,\n  PLUGIN_UNLOADED_EVENT_NAME\n} from '../plugin/plugin-lifecycle-events.ts';\nimport { registerAsyncEvent } from './async-events-component.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { CallbackLayoutReadyComponent } from './layout-ready-component.ts';\n\n/**\n * How badly two plugins running side by side goes wrong, and therefore what this one does about it.\n */\nexport enum PluginConflictSeverity {\n  /**\n   * The host refuses to run at all while the conflict holds: `onloadImpl` never runs, nothing is\n   * registered, and the plugin explains itself the way a missing dependency does.\n   *\n   * For an overlap where both plugins acting on the same operation damages the vault.\n   */\n  Block = 'block',\n\n  /**\n   * The host runs anyway and says the overlap is there.\n   *\n   * For an overlap that is annoying rather than destructive \u2014 duplicate commands, work done twice \u2014 where\n   * refusing to load would cost the user more than the overlap does.\n   */\n  Warn = 'warn'\n}\n\n/**\n * A plugin another plugin refuses to run beside, or warns about running beside.\n */\nexport interface PluginConflict {\n  /**\n   * The semver range of the OTHER plugin's versions that conflict, e.g. `'<12.0.0'` for \"every version\n   * before the one that gave this behavior up\".\n   *\n   * A range rather than a minimum, so an overlap confined to one major (`'>=3 <4'`) is expressible, and so\n   * is a plugin that conflicts at every version \u2014 spell that `'>=0.0.0'`, since `compare-versions` rejects\n   * a bare `*`. Evaluated against `manifest.version`; a version that cannot be parsed counts as\n   * conflicting.\n   */\n  readonly conflictingVersionRange: string;\n\n  /**\n   * The `manifest.id` of the conflicting plugin, as listed in Obsidian's community plugin registry.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The display name of the conflicting plugin, shown to the user.\n   */\n  readonly pluginName: string;\n\n  /**\n   * A localized sentence saying what goes wrong when both run, shown in the banner.\n   *\n   * The declaring plugin owns this string because only it knows what the two of them collide over, and a\n   * user being asked to disable something deserves to be told why.\n   */\n  readonly reason: string;\n\n  /**\n   * What this plugin does about the conflict.\n   */\n  readonly severity: PluginConflictSeverity;\n}\n\n/**\n * A plugin another plugin cannot work without.\n */\nexport interface PluginDependency {\n  /**\n   * The semver range of API contract versions the dependent compiled against, e.g. `'^2'`.\n   *\n   * A dependency whose published API falls outside the range counts as UNSATISFIED, which is what turns a\n   * silent behavioral mismatch between two independently released plugins into a visible \"update this\n   * one\" message. Spell \"any version\" as `'>=0.0.0'` \u2014 `compare-versions` rejects a bare `*`.\n   */\n  readonly apiVersionRange: string;\n\n  /**\n   * The `manifest.id` of the required plugin, as listed in Obsidian's community plugin registry.\n   */\n  readonly pluginId: string;\n\n  /**\n   * The display name of the required plugin, shown to the user.\n   */\n  readonly pluginName: string;\n\n  /**\n   * A localized sentence saying what the dependent does with this plugin, shown in the settings banner.\n   *\n   * The dependent owns this string because only it knows what it uses the other plugin for, and a user\n   * being asked to install something deserves to be told why.\n   */\n  readonly reason: string;\n}\n\n/**\n * Parameters for the {@link PluginGateComponent} constructor.\n */\nexport interface PluginGateComponentConstructorParams {\n  /**\n   * The conflicts to enforce. An empty list means the plugin refuses to run beside nothing.\n   */\n  readonly conflicts: readonly PluginConflict[];\n\n  /**\n   * The dependencies to enforce. An empty list means the plugin depends on nothing, and its feature\n   * surface loads immediately.\n   */\n  readonly dependencies: readonly PluginDependency[];\n\n  /**\n   * Loads the host plugin's feature surface. Called once every dependency is satisfied and no blocking\n   * conflict holds, and again after a gate that had closed opens back up.\n   *\n   * @returns A {@link Promise} that resolves once the surface is loaded.\n   */\n  loadFeatureSurface(this: void): Promise<void>;\n\n  /**\n   * The host plugin \u2014 the one declaring the dependencies and conflicts.\n   */\n  readonly plugin: Plugin;\n\n  /**\n   * The host plugin's notice component, used to say what is missing, what is in the way, and what changed.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * Unloads the host plugin's feature surface. Called when a gate that had been open closes.\n   */\n  unloadFeatureSurface(this: void): void;\n}\n\n/**\n * Parameters for the {@link BlockedPluginSettingTab} constructor.\n */\ninterface BlockedPluginSettingTabConstructorParams {\n  /**\n   * The blocked plugin.\n   */\n  readonly plugin: Plugin;\n\n  /**\n   * Renders the blocked explanation into the tab's container.\n   *\n   * @param containerEl - The tab's container element.\n   */\n  renderBanner(this: void, containerEl: HTMLElement): void;\n}\n\n/**\n * The settings tab a blocked plugin shows in place of the one it never got to register.\n *\n * A blocked plugin's `onloadImpl` never ran, so its real settings tab does not exist \u2014 and a user who goes\n * looking for the plugin's settings is precisely the user asking \"why isn't this doing anything?\". An\n * empty space is the worst possible answer to that question.\n */\n// eslint-disable-next-line obsidianmd/settings-tab/prefer-setting-definitions -- This tab has no settings to declare. It stands in for a settings tab that does not exist yet, carrying an explanation and a repair button, and the plugin's real settings appear the moment the gate opens.\nclass BlockedPluginSettingTab extends PluginSettingTab {\n  private readonly renderBanner: (containerEl: HTMLElement) => void;\n\n  /**\n   * Creates an instance of {@link BlockedPluginSettingTab}.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: BlockedPluginSettingTabConstructorParams) {\n    super(params.plugin.app, params.plugin);\n    this.renderBanner = params.renderBanner;\n  }\n\n  /**\n   * Renders the tab.\n   */\n  public override display(): void {\n    this.containerEl.empty();\n    this.renderBanner(this.containerEl);\n  }\n}\n\n/**\n * Enforces a plugin's mandatory dependencies and declared conflicts, gating its feature surface on both.\n */\nexport class PluginGateComponent extends ComponentEx {\n  private readonly announcedWarningPluginIds = new Set<string>();\n  private readonly apiRefs = new Map<string, PluginApiRef<object>>();\n  private blockedSettingTab: null | PluginSettingTab = null;\n  private readonly conflicts: readonly PluginConflict[];\n  private readonly dependencies: readonly PluginDependency[];\n  private hasAnnouncedBlocked = false;\n  private isFeatureSurfaceLoaded = false;\n  private isLayoutReady = false;\n  private readonly loadFeatureSurface: () => Promise<void>;\n  private readonly plugin: Plugin;\n  private readonly pluginNoticeComponent: PluginNoticeComponent;\n  private readonly unloadFeatureSurface: () => void;\n\n  private get app(): App {\n    return this.plugin.app;\n  }\n\n  /**\n   * Creates an instance of {@link PluginGateComponent}.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginGateComponentConstructorParams) {\n    super();\n    this.conflicts = params.conflicts;\n    this.dependencies = params.dependencies;\n    this.loadFeatureSurface = params.loadFeatureSurface;\n    this.plugin = params.plugin;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.unloadFeatureSurface = params.unloadFeatureSurface;\n  }\n\n  /**\n   * Starts watching every declared dependency and conflict.\n   */\n  public override onload(): void {\n    for (const dependency of this.dependencies) {\n      const apiRef = watchPluginApi<object>({\n        apiVersionRange: dependency.apiVersionRange,\n        app: this.app,\n        component: this,\n        pluginId: dependency.pluginId\n      });\n      registerAsyncEvent(\n        this,\n        apiRef.on('change', async () => {\n          await this.refresh();\n        })\n      );\n      this.apiRefs.set(dependency.pluginId, apiRef);\n    }\n\n    // A conflict has no API to watch \u2014 it is read out of the manifests \u2014 so the trigger to re-read is the\n    // Library's own lifecycle broadcast. It covers every conflicting plugin built on this library; one\n    // That is not is caught at the next load, as the file header says.\n    const lifecycleEventNames: PluginLifecycleEventName[] = [PLUGIN_LOADED_EVENT_NAME, PLUGIN_UNLOADED_EVENT_NAME];\n    for (const eventName of lifecycleEventNames) {\n      this.registerEvent(this.app.workspace.on(\n        eventName,\n        convertAsyncToSync(async (payload: PluginLifecycleEventPayload) => {\n          if (payload.pluginId === this.plugin.manifest.id) {\n            return;\n          }\n\n          await this.refresh();\n        })\n      ));\n    }\n\n    // Nothing is SAID about a missing dependency until the layout is ready. Plugins load in an unspecified\n    // Order, so a dependency that simply has not loaded yet is indistinguishable at this point from one\n    // That is not installed \u2014 announcing here would put a \"missing plugin\" notice on screen at every\n    // Startup and take it away a moment later. The gate itself does not wait: the surface loads the\n    // Instant the dependency is there, whenever that is.\n    this.addChild(\n      new CallbackLayoutReadyComponent(this.app, () => {\n        this.isLayoutReady = true;\n        this.presentUnsatisfied(this.getUnsatisfiedDependencies(), this.getActiveConflicts(PluginConflictSeverity.Block));\n        this.announceWarnings();\n      })\n    );\n\n    this.register(() => {\n      this.hideBlockedSettingTab();\n    });\n  }\n\n  /**\n   * Evaluates the gate once the watches are in place, loading the feature surface if it is already open.\n   *\n   * @returns A {@link Promise} that resolves once the first evaluation is complete.\n   */\n  public override async onloadAsync(): Promise<void> {\n    await this.refresh();\n  }\n\n  /**\n   * Renders a banner for every conflict the host is running alongside, so a plugin can put the overlap in\n   * its own settings tab.\n   *\n   * Consumer-invoked, exactly like `PluginSuggestionComponent.renderBanner`: the library registers the\n   * settings tab a BLOCKED plugin needs, because that plugin never got to register one of its own, but it\n   * has no hook into the tab a running plugin builds. Renders nothing when no warning conflict holds.\n   *\n   * @param containerEl - The element to render into.\n   */\n  public renderConflictWarningBanner(containerEl: HTMLElement): void {\n    for (const conflict of this.getActiveConflicts(PluginConflictSeverity.Warn)) {\n      this.renderConflictEntry(containerEl, conflict, this.createConflictWarningMessage(conflict));\n    }\n  }\n\n  private announceWarnings(): void {\n    // A warning describes two plugins that are both RUNNING, so it is pointless while this one is blocked\n    // \u2014 and it waits for layout-ready for the same reason the blocked notice does.\n    if (!this.isLayoutReady || !this.isFeatureSurfaceLoaded) {\n      return;\n    }\n\n    for (const conflict of this.getActiveConflicts(PluginConflictSeverity.Warn)) {\n      if (this.announcedWarningPluginIds.has(conflict.pluginId)) {\n        continue;\n      }\n\n      this.announcedWarningPluginIds.add(conflict.pluginId);\n      this.pluginNoticeComponent.showNotice(this.createConflictWarningMessage(conflict));\n    }\n  }\n\n  private createBlockedMessage(dependency: PluginDependency): DocumentFragment {\n    return createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginDependency.blockedNotice, {\n      dependencyPluginName: asCodeBlock(dependency.pluginName),\n      pluginName: asCodeBlock(this.plugin.manifest.name)\n    }));\n  }\n\n  private createConflictAppearedMessage(conflict: PluginConflict): DocumentFragment {\n    return createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginConflict.conflictAppearedNotice, {\n      conflictingPluginName: asCodeBlock(conflict.pluginName),\n      pluginName: asCodeBlock(this.plugin.manifest.name)\n    }));\n  }\n\n  private createConflictBlockedMessage(conflict: PluginConflict): DocumentFragment {\n    return createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginConflict.blockedNotice, {\n      conflictingPluginName: asCodeBlock(conflict.pluginName),\n      pluginName: asCodeBlock(this.plugin.manifest.name)\n    }));\n  }\n\n  private createConflictWarningMessage(conflict: PluginConflict): DocumentFragment {\n    return createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginConflict.warningNotice, {\n      conflictingPluginName: asCodeBlock(conflict.pluginName),\n      pluginName: asCodeBlock(this.plugin.manifest.name)\n    }));\n  }\n\n  private createDependencyLostMessage(dependency: PluginDependency): DocumentFragment {\n    return createFragmentWithCodeBlocks(t(($) => $.obsidianDevUtils.pluginDependency.dependencyLostNotice, {\n      dependencyPluginName: asCodeBlock(dependency.pluginName),\n      pluginName: asCodeBlock(this.plugin.manifest.name)\n    }));\n  }\n\n  /**\n   * Finds the declared conflicts of one severity that are currently in force.\n   *\n   * @param severity - The severity to select.\n   * @returns The conflicts holding right now, in the order they were declared.\n   */\n  private getActiveConflicts(severity: PluginConflictSeverity): PluginConflict[] {\n    return this.conflicts.filter((conflict) => conflict.severity === severity && this.isConflictActive(conflict));\n  }\n\n  private getUnsatisfiedDependencies(): PluginDependency[] {\n    return this.dependencies.filter((dependency) => !this.apiRefs.get(dependency.pluginId)?.value);\n  }\n\n  private hideBlockedSettingTab(): void {\n    if (!this.blockedSettingTab) {\n      return;\n    }\n\n    this.app.setting.removeSettingTab(this.blockedSettingTab);\n    this.blockedSettingTab = null;\n  }\n\n  /**\n   * Decides whether one declared conflict is in force right now.\n   *\n   * Only an ENABLED plugin counts. One that is installed but switched off registers nothing, so it cannot\n   * collide, and acting on it would be an alarm the user can only answer by uninstalling something they\n   * have already turned off.\n   *\n   * @param conflict - The declared conflict.\n   * @returns Whether the conflicting plugin is enabled at a conflicting version.\n   */\n  private isConflictActive(conflict: PluginConflict): boolean {\n    const installedVersion = getInstalledPluginVersion({\n      app: this.app,\n      pluginId: conflict.pluginId\n    });\n\n    if (installedVersion === null) {\n      return false;\n    }\n\n    try {\n      return satisfiesVersion(installedVersion, conflict.conflictingVersionRange);\n    } catch {\n      return true;\n    }\n  }\n\n  /**\n   * Says what is in the way, and puts the same explanation where the user will look for the plugin's\n   * settings.\n   *\n   * @param unsatisfiedDependencies - The dependencies that are not currently satisfied.\n   * @param blockingConflicts - The conflicts currently refusing the plugin the right to run.\n   */\n  private presentUnsatisfied(\n    unsatisfiedDependencies: readonly PluginDependency[],\n    blockingConflicts: readonly PluginConflict[]\n  ): void {\n    if (!this.isLayoutReady || (unsatisfiedDependencies.length === 0 && blockingConflicts.length === 0)) {\n      return;\n    }\n\n    this.showBlockedSettingTab(unsatisfiedDependencies, blockingConflicts);\n\n    if (this.hasAnnouncedBlocked) {\n      return;\n    }\n\n    this.hasAnnouncedBlocked = true;\n    for (const dependency of unsatisfiedDependencies) {\n      this.pluginNoticeComponent.showNotice(this.createBlockedMessage(dependency));\n    }\n\n    for (const conflict of blockingConflicts) {\n      this.pluginNoticeComponent.showNotice(this.createConflictBlockedMessage(conflict));\n    }\n  }\n\n  /**\n   * Re-evaluates the gate and moves the feature surface to match.\n   *\n   * @returns A {@link Promise} that resolves once the surface matches the gate.\n   */\n  private async refresh(): Promise<void> {\n    const unsatisfiedDependencies = this.getUnsatisfiedDependencies();\n    const blockingConflicts = this.getActiveConflicts(PluginConflictSeverity.Block);\n\n    if (unsatisfiedDependencies.length === 0 && blockingConflicts.length === 0) {\n      this.hideBlockedSettingTab();\n      this.hasAnnouncedBlocked = false;\n\n      if (!this.isFeatureSurfaceLoaded) {\n        this.isFeatureSurfaceLoaded = true;\n        await this.loadFeatureSurface();\n      }\n\n      this.announceWarnings();\n      return;\n    }\n\n    if (this.isFeatureSurfaceLoaded) {\n      this.isFeatureSurfaceLoaded = false;\n      this.unloadFeatureSurface();\n\n      // A gate that closes while the plugin is RUNNING is the case worth being loud about: the user just\n      // Did something, and the consequence is immediate and invisible without this. Announced regardless\n      // Of layout readiness, because a running plugin means the layout is long since ready.\n      for (const dependency of unsatisfiedDependencies) {\n        this.pluginNoticeComponent.showNotice(this.createDependencyLostMessage(dependency));\n      }\n\n      for (const conflict of blockingConflicts) {\n        this.pluginNoticeComponent.showNotice(this.createConflictAppearedMessage(conflict));\n      }\n\n      this.hasAnnouncedBlocked = true;\n      this.showBlockedSettingTab(unsatisfiedDependencies, blockingConflicts);\n      return;\n    }\n\n    this.presentUnsatisfied(unsatisfiedDependencies, blockingConflicts);\n  }\n\n  /**\n   * Renders the blocked explanation into a settings-tab container: what is missing or in the way, why it\n   * matters, and the button that fixes it.\n   *\n   * @param containerEl - The element to render into.\n   * @param unsatisfiedDependencies - The dependencies that are not currently satisfied.\n   * @param blockingConflicts - The conflicts currently refusing the plugin the right to run.\n   */\n  private renderBlockedBanner(\n    containerEl: HTMLElement,\n    unsatisfiedDependencies: readonly PluginDependency[],\n    blockingConflicts: readonly PluginConflict[]\n  ): void {\n    if (unsatisfiedDependencies.length > 0) {\n      containerEl.createEl('h2', { text: t(($) => $.obsidianDevUtils.pluginDependency.settingsHeading) });\n    }\n\n    for (const dependency of unsatisfiedDependencies) {\n      const bannerEl = containerEl.createDiv({\n        cls: [CssClass.LibraryName, CssClass.PluginDependencyBanner]\n      });\n      bannerEl.append(this.createBlockedMessage(dependency));\n      bannerEl.createDiv({ text: dependency.reason });\n\n      const state = getInstalledPluginState({\n        app: this.app,\n        pluginId: dependency.pluginId\n      });\n\n      new ButtonComponent(bannerEl)\n        .setButtonText(t(($) =>\n          state === InstalledPluginState.InstalledButDisabled\n            ? $.obsidianDevUtils.pluginSuggestion.enable\n            : $.obsidianDevUtils.pluginSuggestion.install\n        ))\n        .setCta()\n        .onClick(convertAsyncToSync(async () => {\n          await installAndEnablePlugin({\n            app: this.app,\n            pluginId: dependency.pluginId,\n            pluginName: dependency.pluginName,\n            pluginNoticeComponent: this.pluginNoticeComponent\n          });\n        }));\n\n      // The link OUT to the dependency's own settings, shown only once it is installed and enabled \u2014 the\n      // Other half of the relationship being visible from both ends. It is what stops \"configure one\n      // Operation across two plugins\" from meaning \"go and find the other plugin yourself\".\n      if (state !== InstalledPluginState.Enabled) {\n        continue;\n      }\n\n      this.renderOpenSettingsButton(bannerEl, dependency.pluginId, dependency.pluginName);\n    }\n\n    if (blockingConflicts.length === 0) {\n      return;\n    }\n\n    containerEl.createEl('h2', { text: t(($) => $.obsidianDevUtils.pluginConflict.settingsHeading) });\n\n    for (const conflict of blockingConflicts) {\n      this.renderConflictEntry(containerEl, conflict, this.createConflictBlockedMessage(conflict));\n    }\n  }\n\n  /**\n   * Renders one conflict: what it is, why it matters, and the two ways out of it.\n   *\n   * The repair is offered on the OTHER plugin \u2014 disabling it is the one thing this plugin can do in a\n   * click, since it cannot update someone else's plugin \u2014 and it is the persisted `disablePluginAndSave`\n   * rather than the transient disable, because the user asked for it by clicking.\n   *\n   * @param containerEl - The element to render into.\n   * @param conflict - The conflict to render.\n   * @param messageFragment - The sentence explaining the conflict.\n   */\n  private renderConflictEntry(containerEl: HTMLElement, conflict: PluginConflict, messageFragment: DocumentFragment): void {\n    const bannerEl = containerEl.createDiv({\n      cls: [CssClass.LibraryName, CssClass.PluginConflictBanner]\n    });\n    bannerEl.append(messageFragment);\n    bannerEl.createDiv({ text: conflict.reason });\n\n    new ButtonComponent(bannerEl)\n      .setButtonText(t(($) => $.obsidianDevUtils.pluginConflict.disable, { conflictingPluginName: conflict.pluginName }))\n      .setCta()\n      .onClick(convertAsyncToSync(async () => {\n        await disableCommunityPlugin({\n          app: this.app,\n          pluginId: conflict.pluginId\n        });\n        await this.refresh();\n      }));\n\n    this.renderOpenSettingsButton(bannerEl, conflict.pluginId, conflict.pluginName);\n  }\n\n  private renderOpenSettingsButton(bannerEl: HTMLElement, pluginId: string, pluginName: string): void {\n    new ButtonComponent(bannerEl)\n      .setButtonText(t(($) => $.obsidianDevUtils.pluginDependency.openDependencySettings, {\n        dependencyPluginName: pluginName\n      }))\n      .onClick(() => {\n        this.app.setting.open();\n        this.app.setting.openTabById(pluginId);\n      });\n  }\n\n  private showBlockedSettingTab(\n    unsatisfiedDependencies: readonly PluginDependency[],\n    blockingConflicts: readonly PluginConflict[]\n  ): void {\n    if (this.blockedSettingTab) {\n      return;\n    }\n\n    // Added through `app.setting` rather than `plugin.addSettingTab`, because this tab has to come back\n    // OFF again the moment the gate opens \u2014 otherwise the plugin's own settings tab, registered by\n    // `onloadImpl`, would appear beside a stale \"required plugin missing\" one. `plugin.addSettingTab`\n    // Only ever removes at plugin unload.\n    const blockedSettingTab = new BlockedPluginSettingTab({\n      plugin: this.plugin,\n      renderBanner: (containerEl): void => {\n        this.renderBlockedBanner(containerEl, unsatisfiedDependencies, blockingConflicts);\n      }\n    });\n    this.app.setting.addSettingTab(blockedSettingTab);\n    this.blockedSettingTab = blockedSettingTab;\n  }\n}\n"],
  "mappings": "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",
  "names": ["PluginConflictSeverity"]
}


package/dist/lib/esm/obsidian/components/plugin-suggestion-component.d.mts

@@ -5,10 +5,21 @@
  * Component that suggests installing another community plugin the host plugin needs in order to offer
  * some of its behavior.
  *
- * A suggestion is not a dependency. Obsidian has no mechanism for one community plugin to require
- * another, and inventing one by refusing to load would punish the user for something they never agreed
- * to. So the host plugin keeps working without the suggested plugin — it simply cannot offer whatever
- * that plugin owns — and this component asks, once, whether the user would like it installed.
+ * A suggestion is not a dependency — but a dependency is now a thing this library HAS, so the choice
+ * between them is a real one. Use a suggestion when the other plugin ADDS something: the host keeps
+ * working without it, simply unable to offer whatever that plugin owns, and this component asks once
+ * whether the user would like it installed. Use `PluginGateComponent` when the host's advertised
+ * behavior is not there at all without the other plugin.
+ *
+ * This file used to argue the stronger position — that requiring another plugin should not exist, because
+ * "inventing one by refusing to load would punish the user for something they never agreed to". That was
+ * wrong about which option punishes the user, and the counter-case is worth keeping rather than quietly
+ * deleting. A load-bearing plugin the user cannot identify is not a neutral outcome: months later they
+ * meet it in their plugin list, nothing in Obsidian's manifest format says anything depends on it, they
+ * remove it, and the damage surfaces weeks after that with no way to connect the two. Beside that, a
+ * mandatory dependency that stays enabled-but-inert, names what it is waiting for, installs it in one
+ * click and resumes without a restart is not a punishment — it is the same information, delivered while
+ * the user can still act on it.
  *
  * The ask is surfaced twice, deliberately, because the two placements answer different questions:
  * a notice on load ("you are missing something you probably want") and a settings-tab banner ("the
@@ -19,24 +30,16 @@ import type { App } from 'obsidian';
 import type { Promisable } from 'type-fest';
 import type { PluginNoticeComponent } from './plugin-notice-component.mjs';
 import type { PluginSettingsComponentBase } from './plugin-settings-component.mjs';
+import { InstalledPluginState } from '../plugin/plugin-install-state.mjs';
 import { ComponentEx } from './component-ex.mjs';
 /**
  * How the suggested plugin is currently present in the vault.
+ *
+ * The same three states a mandatory dependency is in, so this is {@link InstalledPluginState} under the
+ * name this component has always used — one enum, so a caller holding a state from either component can
+ * compare it against either name.
  */
-export declare enum SuggestedPluginState {
-    /**
-     * Installed and enabled — there is nothing to suggest.
-     */
-    Enabled = "enabled",
-    /**
-     * Installed but disabled. Only an enable is needed, so no download happens.
-     */
-    InstalledButDisabled = "installedButDisabled",
-    /**
-     * Not installed at all.
-     */
-    NotInstalled = "notInstalled"
-}
+export declare const SuggestedPluginState: typeof InstalledPluginState;
 /**
  * Parameters for the {@link PluginSuggestionComponent} constructor.
  */
@@ -92,6 +95,10 @@ export interface PluginSuggestionComponentConstructorParams {
      */
     readonly suggestedPluginName: string;
 }
+/**
+ * How the suggested plugin is currently present in the vault.
+ */
+export type SuggestedPluginState = InstalledPluginState;
 /**
  * Suggests installing another community plugin, via a load-time notice and a settings-tab banner.
  */