obsidian-dev-utils 101.5.0 → 101.7.0

package/dist/lib/cjs/obsidian/components/plugin-gate-component.d.cts

@@ -0,0 +1,299 @@
+/// <reference path="../../library.d.cts" />
+/**
+ * @file
+ *
+ * The gate on a plugin's feature surface: what must be PRESENT for it to run, and what must NOT be.
+ *
+ * Both halves answer the same question — may this plugin's `onloadImpl` run right now? — so they are one
+ * component rather than two. A second, independent gate would double-load the surface and stack a second
+ * "blocked" settings tab onto the same plugin, and neither could see the other's reason for refusing.
+ *
+ * ## Dependencies: a plugin declaring what it cannot work without
+ *
+ * This is the strict sibling of `PluginSuggestionComponent`, and the difference is the whole point. A
+ * SUGGESTION is an offer — the host keeps working without it and simply cannot do one thing. A DEPENDENCY
+ * is a requirement: `onloadImpl` never runs, no command is registered, no handler is installed, nothing is
+ * patched. Reach for a suggestion when the other plugin adds something; reach for a dependency when the
+ * host's advertised behavior is not there without it.
+ *
+ * Obsidian has no dependency field in a manifest, which is exactly the problem this closes. Without one,
+ * a user meeting an unfamiliar plugin in their list months later has nothing telling them it is
+ * load-bearing — they remove it, and the breakage surfaces weeks after that as damage they cannot connect
+ * to anything they did. So the relationship is made visible from both ends and enforced while it holds:
+ * the dependent explains itself where the user is looking, repairs itself in one click, and reacts the
+ * INSTANT the dependency goes away rather than degrading quietly.
+ *
+ * Three choices are deliberate and worth stating, because each has an obvious-looking alternative:
+ *
+ * - **Blocked means enabled-but-inert, never self-disabled.** Calling `disablePluginAndSave` on itself
+ *   would be the literal reading of "refuses to load", and it rewrites a config that belongs to the user —
+ *   who would then have to remember to re-enable it after fixing the dependency. Staying enabled and inert
+ *   says the same thing to the user, changes nothing they own, and can undo itself.
+ * - **Blocked is not an error.** Throwing from `onload` marks the plugin failed in Obsidian and hands the
+ *   user a stack trace instead of a sentence and a button.
+ * - **A dependency must publish an API.** That is what makes presence, absence, version and departure all
+ *   observable through one mechanism — `watchPluginApi`'s reference is live, is revoked when the provider
+ *   unloads, and already classifies not-installed against not-enabled against too-old. A provider with
+ *   nothing to expose can publish an empty API purely so it can be depended upon; the alternative would be
+ *   a second, weaker detection path to maintain beside it.
+ *
+ * ## Conflicts: a plugin declaring what it refuses to run beside
+ *
+ * The inverse relationship, and it needs its own detection path because the dependency one does not fit.
+ * A conflicting plugin is typically an OLD version of some other plugin that still owns behavior this one
+ * has taken over — it publishes no API at all, so there is no `apiVersionRange` to compare against.
+ *
+ * The argument for refusing rather than competing comes from the case this generalizes: two rename/delete
+ * handlers acting on one rename corrupt links and move attachments twice, and there is no reliable way to
+ * win that race — a handler is elected by registry order, but the patches that do the work sit outside
+ * that election, so whichever plugin loaded first keeps a hand on the wheel. Every scheme for seizing
+ * control from inside is load-order dependent. Refusing is deterministic where competing is not, and a
+ * vault that briefly has no handler is a far better outcome than one with two.
+ *
+ * Two details of that detection carry over verbatim, because both are load-bearing:
+ *
+ * - **Versions are read, never the registry.** A plugin that has not loaded yet has registered nothing, so
+ *   asking the registry gives a different answer depending on when it is asked. `app.plugins.manifests` is
+ *   populated for every installed plugin at startup, whatever the load order turns out to be.
+ * - **An unparseable version counts as conflicting.** Failing closed is the safe direction: a false alarm
+ *   costs a notice, a false all-clear costs a vault.
+ *
+ * Not every overlap is that severe, which is why a conflict declares a {@link PluginConflictSeverity}.
+ * Two plugins shipping the same command duplicate a palette entry and do the work twice — annoying, not
+ * corrupting — and refusing to load over that would be a worse outcome than the overlap. Those declare
+ * {@link PluginConflictSeverity.Warn} and both keep running.
+ *
+ * ## What this can and cannot see
+ *
+ * Obsidian raises no event when ANOTHER plugin is enabled or disabled (see `plugin-lifecycle-events.ts`),
+ * so live conflict detection has a real ceiling and it is stated here rather than implied away. A
+ * conflicting plugin built on this library announces itself through the lifecycle broadcast, and is
+ * therefore caught the moment it is enabled or disabled. One that is not — an old release predating the
+ * broadcast, or a plugin by another author entirely — is caught at the next load, which is when its
+ * manifest is read.
+ */
+import type { Plugin } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { PluginNoticeComponent } from './plugin-notice-component.cjs';
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * How badly two plugins running side by side goes wrong, and therefore what this one does about it.
+ */
+export declare enum PluginConflictSeverity {
+    /**
+     * The host refuses to run at all while the conflict holds: `onloadImpl` never runs, nothing is
+     * registered, and the plugin explains itself the way a missing dependency does.
+     *
+     * For an overlap where both plugins acting on the same operation damages the vault.
+     */
+    Block = "block",
+    /**
+     * The host runs anyway and says the overlap is there.
+     *
+     * For an overlap that is annoying rather than destructive — duplicate commands, work done twice — where
+     * refusing to load would cost the user more than the overlap does.
+     */
+    Warn = "warn"
+}
+/**
+ * A plugin another plugin refuses to run beside, or warns about running beside.
+ */
+export interface PluginConflict {
+    /**
+     * The semver range of the OTHER plugin's versions that conflict, e.g. `'<12.0.0'` for "every version
+     * before the one that gave this behavior up".
+     *
+     * A range rather than a minimum, so an overlap confined to one major (`'>=3 <4'`) is expressible, and so
+     * is a plugin that conflicts at every version — spell that `'>=0.0.0'`, since `compare-versions` rejects
+     * a bare `*`. Evaluated against `manifest.version`; a version that cannot be parsed counts as
+     * conflicting.
+     */
+    readonly conflictingVersionRange: string;
+    /**
+     * The `manifest.id` of the conflicting plugin, as listed in Obsidian's community plugin registry.
+     */
+    readonly pluginId: string;
+    /**
+     * The display name of the conflicting plugin, shown to the user.
+     */
+    readonly pluginName: string;
+    /**
+     * A localized sentence saying what goes wrong when both run, shown in the banner.
+     *
+     * The declaring plugin owns this string because only it knows what the two of them collide over, and a
+     * user being asked to disable something deserves to be told why.
+     */
+    readonly reason: string;
+    /**
+     * What this plugin does about the conflict.
+     */
+    readonly severity: PluginConflictSeverity;
+}
+/**
+ * A plugin another plugin cannot work without.
+ */
+export interface PluginDependency {
+    /**
+     * The semver range of API contract versions the dependent compiled against, e.g. `'^2'`.
+     *
+     * A dependency whose published API falls outside the range counts as UNSATISFIED, which is what turns a
+     * silent behavioral mismatch between two independently released plugins into a visible "update this
+     * one" message. Spell "any version" as `'>=0.0.0'` — `compare-versions` rejects a bare `*`.
+     */
+    readonly apiVersionRange: string;
+    /**
+     * The `manifest.id` of the required plugin, as listed in Obsidian's community plugin registry.
+     */
+    readonly pluginId: string;
+    /**
+     * The display name of the required plugin, shown to the user.
+     */
+    readonly pluginName: string;
+    /**
+     * A localized sentence saying what the dependent does with this plugin, shown in the settings banner.
+     *
+     * The dependent owns this string because only it knows what it uses the other plugin for, and a user
+     * being asked to install something deserves to be told why.
+     */
+    readonly reason: string;
+}
+/**
+ * Parameters for the {@link PluginGateComponent} constructor.
+ */
+export interface PluginGateComponentConstructorParams {
+    /**
+     * The conflicts to enforce. An empty list means the plugin refuses to run beside nothing.
+     */
+    readonly conflicts: readonly PluginConflict[];
+    /**
+     * The dependencies to enforce. An empty list means the plugin depends on nothing, and its feature
+     * surface loads immediately.
+     */
+    readonly dependencies: readonly PluginDependency[];
+    /**
+     * Loads the host plugin's feature surface. Called once every dependency is satisfied and no blocking
+     * conflict holds, and again after a gate that had closed opens back up.
+     *
+     * @returns A {@link Promise} that resolves once the surface is loaded.
+     */
+    loadFeatureSurface(this: void): Promise<void>;
+    /**
+     * The host plugin — the one declaring the dependencies and conflicts.
+     */
+    readonly plugin: Plugin;
+    /**
+     * The host plugin's notice component, used to say what is missing, what is in the way, and what changed.
+     */
+    readonly pluginNoticeComponent: PluginNoticeComponent;
+    /**
+     * Unloads the host plugin's feature surface. Called when a gate that had been open closes.
+     */
+    unloadFeatureSurface(this: void): void;
+}
+/**
+ * Enforces a plugin's mandatory dependencies and declared conflicts, gating its feature surface on both.
+ */
+export declare class PluginGateComponent extends ComponentEx {
+    private readonly announcedWarningPluginIds;
+    private readonly apiRefs;
+    private blockedSettingTab;
+    private readonly conflicts;
+    private readonly dependencies;
+    private hasAnnouncedBlocked;
+    private isFeatureSurfaceLoaded;
+    private isLayoutReady;
+    private readonly loadFeatureSurface;
+    private readonly plugin;
+    private readonly pluginNoticeComponent;
+    private readonly unloadFeatureSurface;
+    private get app();
+    /**
+     * Creates an instance of {@link PluginGateComponent}.
+     *
+     * @param params - The constructor parameters.
+     */
+    constructor(params: PluginGateComponentConstructorParams);
+    /**
+     * Starts watching every declared dependency and conflict.
+     */
+    onload(): void;
+    /**
+     * 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.
+     */
+    onloadAsync(): Promise<void>;
+    /**
+     * 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: HTMLElement): void;
+    private announceWarnings;
+    private createBlockedMessage;
+    private createConflictAppearedMessage;
+    private createConflictBlockedMessage;
+    private createConflictWarningMessage;
+    private createDependencyLostMessage;
+    /**
+     * 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.
+     */
+    private getActiveConflicts;
+    private getUnsatisfiedDependencies;
+    private hideBlockedSettingTab;
+    /**
+     * 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.
+     */
+    private isConflictActive;
+    /**
+     * 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.
+     */
+    private presentUnsatisfied;
+    /**
+     * Re-evaluates the gate and moves the feature surface to match.
+     *
+     * @returns A {@link Promise} that resolves once the surface matches the gate.
+     */
+    private refresh;
+    /**
+     * 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.
+     */
+    private renderBlockedBanner;
+    /**
+     * 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.
+     */
+    private renderConflictEntry;
+    private renderOpenSettingsButton;
+    private showBlockedSettingTab;
+}

package/dist/lib/cjs/obsidian/components/plugin-suggestion-component.cjs

@@ -148,17 +148,12 @@ __export(plugin_suggestion_component_exports, {
 module.exports = __toCommonJS(plugin_suggestion_component_exports);
 var import_obsidian = require('obsidian');
 var import_async = require('../../async.cjs');
-var import_community_plugins = require('../community-plugins.cjs');
 var import_css_class = require('../css-class.cjs');
 var import_i18n = require('../i18n/i18n.cjs');
+var import_plugin_install_state = require('../plugin/plugin-install-state.cjs');
 var import_component_ex = require('./component-ex.cjs');
 var import_layout_ready_component = require('./layout-ready-component.cjs');
-var SuggestedPluginState = /* @__PURE__ */ ((SuggestedPluginState2) => {
-  SuggestedPluginState2["Enabled"] = "enabled";
-  SuggestedPluginState2["InstalledButDisabled"] = "installedButDisabled";
-  SuggestedPluginState2["NotInstalled"] = "notInstalled";
-  return SuggestedPluginState2;
-})(SuggestedPluginState || {});
+const SuggestedPluginState = import_plugin_install_state.InstalledPluginState;
 class PluginSuggestionComponent extends import_component_ex.ComponentEx {
   app;
   isSuggestionDeclined;
@@ -190,10 +185,10 @@ class PluginSuggestionComponent extends import_component_ex.ComponentEx {
    * @returns The {@link SuggestedPluginState}.
    */
   getSuggestedPluginState() {
-    if (this.app.plugins.enabledPlugins.has(this.suggestedPluginId)) {
-      return "enabled" /* Enabled */;
-    }
-    return Object.hasOwn(this.app.plugins.manifests, this.suggestedPluginId) ? "installedButDisabled" /* InstalledButDisabled */ : "notInstalled" /* NotInstalled */;
+    return (0, import_plugin_install_state.getInstalledPluginState)({
+      app: this.app,
+      pluginId: this.suggestedPluginId
+    });
   }
   /**
    * Installs (when needed) and enables the suggested plugin, reporting the outcome as a notice.
@@ -202,32 +197,16 @@ class PluginSuggestionComponent extends import_component_ex.ComponentEx {
    * reported.
    */
   async installAndEnableSuggestedPlugin() {
-    const state = this.getSuggestedPluginState();
-    if (state === "enabled" /* Enabled */) {
+    if (this.getSuggestedPluginState() === SuggestedPluginState.Enabled) {
       return;
     }
-    try {
-      if (state === "installedButDisabled" /* InstalledButDisabled */) {
-        await (0, import_community_plugins.enableCommunityPlugin)({
-          app: this.app,
-          pluginId: this.suggestedPluginId
-        });
-      } else {
-        await (0, import_community_plugins.installConfigureEnableCommunityPlugin)({
-          app: this.app,
-          pluginId: this.suggestedPluginId
-        });
-      }
-    } catch (error) {
-      this.pluginNoticeComponent.showNotice((0, import_i18n.t)(($) => $.obsidianDevUtils.pluginSuggestion.installFailed, {
-        pluginName: this.suggestedPluginName
-      }));
-      throw error;
-    }
+    await (0, import_plugin_install_state.installAndEnablePlugin)({
+      app: this.app,
+      pluginId: this.suggestedPluginId,
+      pluginName: this.suggestedPluginName,
+      pluginNoticeComponent: this.pluginNoticeComponent
+    });
     await this.setSuggestionDeclined(false);
-    this.pluginNoticeComponent.showNotice((0, import_i18n.t)(($) => $.obsidianDevUtils.pluginSuggestion.installed, {
-      pluginName: this.suggestedPluginName
-    }));
   }
   /**
    * Loads the component, showing the suggestion notice once the layout is ready AND the host's settings
@@ -267,7 +246,7 @@ class PluginSuggestionComponent extends import_component_ex.ComponentEx {
    */
   renderBanner(containerEl) {
     const state = this.getSuggestedPluginState();
-    if (state === "enabled" /* Enabled */) {
+    if (state === SuggestedPluginState.Enabled) {
       return;
     }
     const bannerEl = containerEl.createDiv({
@@ -280,12 +259,12 @@ class PluginSuggestionComponent extends import_component_ex.ComponentEx {
   }
   getActionButtonText(state) {
     return (0, import_i18n.t)(
-      ($) => state === "installedButDisabled" /* InstalledButDisabled */ ? $.obsidianDevUtils.pluginSuggestion.enable : $.obsidianDevUtils.pluginSuggestion.install
+      ($) => state === SuggestedPluginState.InstalledButDisabled ? $.obsidianDevUtils.pluginSuggestion.enable : $.obsidianDevUtils.pluginSuggestion.install
     );
   }
   showSuggestionNotice() {
     const state = this.getSuggestedPluginState();
-    if (state === "enabled" /* Enabled */ || this.isSuggestionDeclined()) {
+    if (state === SuggestedPluginState.Enabled || this.isSuggestionDeclined()) {
       return;
     }
     const fragment = createFragment((fragmentEl) => {
@@ -306,4 +285,4 @@ class PluginSuggestionComponent extends import_component_ex.ComponentEx {
   PluginSuggestionComponent,
   SuggestedPluginState
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/plugin-suggestion-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that suggests installing another community plugin the host plugin needs in order to offer\n * some of its behavior.\n *\n * A suggestion is not a dependency. Obsidian has no mechanism for one community plugin to require\n * another, and inventing one by refusing to load would punish the user for something they never agreed\n * to. So the host plugin keeps working without the suggested plugin \u2014 it simply cannot offer whatever\n * that plugin owns \u2014 and this component asks, once, whether the user would like it installed.\n *\n * The ask is surfaced twice, deliberately, because the two placements answer different questions:\n * a notice on load (\"you are missing something you probably want\") and a settings-tab banner (\"the\n * settings you came looking for live in another plugin\"). Declining silences only the notice \u2014 a user\n * who opens the settings tab is asking about the feature right then, so the banner stays.\n */\n\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { ButtonComponent } from 'obsidian';\n\nimport type { PluginNoticeComponent } from './plugin-notice-component.ts';\nimport type { PluginSettingsComponentBase } from './plugin-settings-component.ts';\n\nimport { convertAsyncToSync } from '../../async.ts';\nimport {\n  enableCommunityPlugin,\n  installConfigureEnableCommunityPlugin\n} from '../community-plugins.ts';\nimport { CssClass } from '../css-class.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { CallbackLayoutReadyComponent } from './layout-ready-component.ts';\n\n/**\n * How the suggested plugin is currently present in the vault.\n */\nexport enum SuggestedPluginState {\n  /**\n   * Installed and enabled \u2014 there is nothing to suggest.\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 the {@link PluginSuggestionComponent} constructor.\n */\nexport interface PluginSuggestionComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Whether the user has already declined this suggestion.\n   *\n   * Storage belongs to the host plugin (typically one of its settings), because this component has no\n   * `data.json` of its own and a decline has to outlive a reload.\n   *\n   * Only ever called once {@link pluginSettingsComponent} reports its settings loaded, so an implementation\n   * reading a setting is guaranteed to read the stored value rather than its default.\n   *\n   * @returns `true` when the suggestion has been declined.\n   */\n  isSuggestionDeclined(this: void): boolean;\n\n  /**\n   * The notice component of the plugin making the suggestion, used to show the suggestion and its\n   * outcome.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * The settings component holding whatever {@link isSuggestionDeclined} reads.\n   *\n   * Taken as a whole component rather than as a bare \"ready\" flag so the host cannot forget to wire the\n   * wait: the notice is decided only after this component has read `data.json`. See\n   * {@link PluginSettingsComponentBase.whenLoadedFromFile} for why the read cannot simply happen at\n   * layout-ready.\n   */\n  readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n\n  /**\n   * The localized sentence explaining what the host plugin cannot do without the suggested plugin. The\n   * host plugin owns this string: only it knows which of its features are affected.\n   */\n  readonly reason: string;\n\n  /**\n   * Records the user's answer to the suggestion.\n   *\n   * @param isDeclined - `true` when the user declined.\n   * @returns A {@link Promise} that resolves once the answer is persisted.\n   */\n  setSuggestionDeclined(this: void, isDeclined: boolean): Promisable<void>;\n\n  /**\n   * The id of the suggested plugin, as listed in Obsidian's community plugin registry.\n   */\n  readonly suggestedPluginId: string;\n\n  /**\n   * The display name of the suggested plugin, shown to the user.\n   */\n  readonly suggestedPluginName: string;\n}\n\n/**\n * Suggests installing another community plugin, via a load-time notice and a settings-tab banner.\n */\nexport class PluginSuggestionComponent extends ComponentEx {\n  private readonly app: App;\n  private readonly isSuggestionDeclined: () => boolean;\n  private readonly pluginNoticeComponent: PluginNoticeComponent;\n  private readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n  private readonly reason: string;\n  private readonly setSuggestionDeclined: (isDeclined: boolean) => Promisable<void>;\n  private readonly suggestedPluginId: string;\n  private readonly suggestedPluginName: string;\n\n  /**\n   * Creates an instance of {@link PluginSuggestionComponent}.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginSuggestionComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.pluginSettingsComponent = params.pluginSettingsComponent;\n    this.reason = params.reason;\n    this.suggestedPluginId = params.suggestedPluginId;\n    this.suggestedPluginName = params.suggestedPluginName;\n    this.isSuggestionDeclined = params.isSuggestionDeclined;\n    this.setSuggestionDeclined = params.setSuggestionDeclined;\n  }\n\n  /**\n   * Resolves how the suggested plugin is currently present in the vault.\n   *\n   * @returns The {@link SuggestedPluginState}.\n   */\n  public getSuggestedPluginState(): SuggestedPluginState {\n    if (this.app.plugins.enabledPlugins.has(this.suggestedPluginId)) {\n      return SuggestedPluginState.Enabled;\n    }\n\n    return Object.hasOwn(this.app.plugins.manifests, this.suggestedPluginId)\n      ? SuggestedPluginState.InstalledButDisabled\n      : SuggestedPluginState.NotInstalled;\n  }\n\n  /**\n   * Installs (when needed) and enables the suggested plugin, reporting the outcome as a notice.\n   *\n   * @returns A {@link Promise} that resolves once the plugin is enabled, or once the failure has been\n   * reported.\n   */\n  public async installAndEnableSuggestedPlugin(): Promise<void> {\n    const state = this.getSuggestedPluginState();\n    if (state === SuggestedPluginState.Enabled) {\n      return;\n    }\n\n    try {\n      if (state === SuggestedPluginState.InstalledButDisabled) {\n        await enableCommunityPlugin({\n          app: this.app,\n          pluginId: this.suggestedPluginId\n        });\n      } else {\n        await installConfigureEnableCommunityPlugin({\n          app: this.app,\n          pluginId: this.suggestedPluginId\n        });\n      }\n    } catch (error) {\n      this.pluginNoticeComponent.showNotice(t(($) => $.obsidianDevUtils.pluginSuggestion.installFailed, {\n        pluginName: this.suggestedPluginName\n      }));\n      throw error;\n    }\n\n    await this.setSuggestionDeclined(false);\n    this.pluginNoticeComponent.showNotice(t(($) => $.obsidianDevUtils.pluginSuggestion.installed, {\n      pluginName: this.suggestedPluginName\n    }));\n  }\n\n  /**\n   * Loads the component, showing the suggestion notice once the layout is ready AND the host's settings\n   * have been read from disk.\n   *\n   * Both waits matter, and neither implies the other:\n   *\n   * - Layout-ready, because plugins load in an unspecified order, so the suggested plugin may well be\n   *   enabled a moment after this one. Checking earlier would suggest installing something the user\n   *   already has.\n   * - Settings-loaded, because {@link PluginSuggestionComponentConstructorParams.isSuggestionDeclined}\n   *   reads a setting of the host, and the host's settings component is a SIBLING whose own async load is\n   *   still in flight here. On a layout that is already ready \u2014 a runtime enable from the Community\n   *   Plugins tab, or a re-enable after an update \u2014 the layout-ready callback fires immediately, so the\n   *   read would see the default `false` and ask again a user who has already declined.\n   */\n  public override onload(): void {\n    this.addChild(\n      new CallbackLayoutReadyComponent(this.app, async () => {\n        await this.pluginSettingsComponent.whenLoadedFromFile();\n        if (this.isUnloaded()) {\n          return;\n        }\n\n        this.showSuggestionNotice();\n      })\n    );\n  }\n\n  /**\n   * Renders the suggestion banner into a settings-tab container, with a button that installs and enables\n   * the suggested plugin.\n   *\n   * Renders nothing when the suggested plugin is already enabled. Unlike the notice, the banner ignores a\n   * previous decline \u2014 the user is looking at these settings right now, which is a fresher signal than an\n   * answer they gave earlier.\n   *\n   * @param containerEl - The element to render the banner into.\n   */\n  public renderBanner(containerEl: HTMLElement): void {\n    const state = this.getSuggestedPluginState();\n    if (state === SuggestedPluginState.Enabled) {\n      return;\n    }\n\n    const bannerEl = containerEl.createDiv({\n      cls: [CssClass.LibraryName, CssClass.PluginSuggestionBanner]\n    });\n    bannerEl.createDiv({ text: this.reason });\n\n    new ButtonComponent(bannerEl)\n      .setButtonText(this.getActionButtonText(state))\n      .setCta()\n      .onClick(convertAsyncToSync(async () => {\n        await this.installAndEnableSuggestedPlugin();\n      }));\n  }\n\n  private getActionButtonText(state: SuggestedPluginState): string {\n    return t(($) =>\n      state === SuggestedPluginState.InstalledButDisabled\n        ? $.obsidianDevUtils.pluginSuggestion.enable\n        : $.obsidianDevUtils.pluginSuggestion.install\n    );\n  }\n\n  private showSuggestionNotice(): void {\n    const state = this.getSuggestedPluginState();\n    if (state === SuggestedPluginState.Enabled || this.isSuggestionDeclined()) {\n      return;\n    }\n\n    const fragment = createFragment((fragmentEl) => {\n      fragmentEl.createDiv({ text: this.reason });\n      const buttonsEl = fragmentEl.createDiv();\n\n      new ButtonComponent(buttonsEl)\n        .setButtonText(this.getActionButtonText(state))\n        .setCta()\n        .onClick(convertAsyncToSync(async () => {\n          await this.installAndEnableSuggestedPlugin();\n        }));\n\n      new ButtonComponent(buttonsEl)\n        .setButtonText(t(($) => $.obsidianDevUtils.pluginSuggestion.notNow))\n        .onClick(convertAsyncToSync(async () => {\n          await this.setSuggestionDeclined(true);\n        }));\n    });\n\n    this.pluginNoticeComponent.showNotice(fragment, { shouldHideOnClick: false });\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,sBAAgC;AAKhC,mBAAmC;AACnC,+BAGO;AACP,uBAAyB;AACzB,kBAAkB;AAClB,0BAA4B;AAC5B,oCAA6C;AAKtC,IAAK,uBAAL,kBAAKA,0BAAL;AAIL,EAAAA,sBAAA,aAAU;AAKV,EAAAA,sBAAA,0BAAuB;AAKvB,EAAAA,sBAAA,kBAAe;AAdL,SAAAA;AAAA,GAAA;AAmFL,MAAM,kCAAkC,gCAAY;AAAA,EACxC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOV,YAAY,QAAoD;AACrE,UAAM;AACN,SAAK,MAAM,OAAO;AAClB,SAAK,wBAAwB,OAAO;AACpC,SAAK,0BAA0B,OAAO;AACtC,SAAK,SAAS,OAAO;AACrB,SAAK,oBAAoB,OAAO;AAChC,SAAK,sBAAsB,OAAO;AAClC,SAAK,uBAAuB,OAAO;AACnC,SAAK,wBAAwB,OAAO;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,0BAAgD;AACrD,QAAI,KAAK,IAAI,QAAQ,eAAe,IAAI,KAAK,iBAAiB,GAAG;AAC/D,aAAO;AAAA,IACT;AAEA,WAAO,OAAO,OAAO,KAAK,IAAI,QAAQ,WAAW,KAAK,iBAAiB,IACnE,oDACA;AAAA,EACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,MAAa,kCAAiD;AAC5D,UAAM,QAAQ,KAAK,wBAAwB;AAC3C,QAAI,UAAU,yBAA8B;AAC1C;AAAA,IACF;AAEA,QAAI;AACF,UAAI,UAAU,mDAA2C;AACvD,kBAAM,gDAAsB;AAAA,UAC1B,KAAK,KAAK;AAAA,UACV,UAAU,KAAK;AAAA,QACjB,CAAC;AAAA,MACH,OAAO;AACL,kBAAM,gEAAsC;AAAA,UAC1C,KAAK,KAAK;AAAA,UACV,UAAU,KAAK;AAAA,QACjB,CAAC;AAAA,MACH;AAAA,IACF,SAAS,OAAO;AACd,WAAK,sBAAsB,eAAW,eAAE,CAAC,MAAM,EAAE,iBAAiB,iBAAiB,eAAe;AAAA,QAChG,YAAY,KAAK;AAAA,MACnB,CAAC,CAAC;AACF,YAAM;AAAA,IACR;AAEA,UAAM,KAAK,sBAAsB,KAAK;AACtC,SAAK,sBAAsB,eAAW,eAAE,CAAC,MAAM,EAAE,iBAAiB,iBAAiB,WAAW;AAAA,MAC5F,YAAY,KAAK;AAAA,IACnB,CAAC,CAAC;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBgB,SAAe;AAC7B,SAAK;AAAA,MACH,IAAI,2DAA6B,KAAK,KAAK,YAAY;AACrD,cAAM,KAAK,wBAAwB,mBAAmB;AACtD,YAAI,KAAK,WAAW,GAAG;AACrB;AAAA,QACF;AAEA,aAAK,qBAAqB;AAAA,MAC5B,CAAC;AAAA,IACH;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,aAAa,aAAgC;AAClD,UAAM,QAAQ,KAAK,wBAAwB;AAC3C,QAAI,UAAU,yBAA8B;AAC1C;AAAA,IACF;AAEA,UAAM,WAAW,YAAY,UAAU;AAAA,MACrC,KAAK,CAAC,0BAAS,aAAa,0BAAS,sBAAsB;AAAA,IAC7D,CAAC;AACD,aAAS,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;AAExC,QAAI,gCAAgB,QAAQ,EACzB,cAAc,KAAK,oBAAoB,KAAK,CAAC,EAC7C,OAAO,EACP,YAAQ,iCAAmB,YAAY;AACtC,YAAM,KAAK,gCAAgC;AAAA,IAC7C,CAAC,CAAC;AAAA,EACN;AAAA,EAEQ,oBAAoB,OAAqC;AAC/D,eAAO;AAAA,MAAE,CAAC,MACR,UAAU,oDACN,EAAE,iBAAiB,iBAAiB,SACpC,EAAE,iBAAiB,iBAAiB;AAAA,IAC1C;AAAA,EACF;AAAA,EAEQ,uBAA6B;AACnC,UAAM,QAAQ,KAAK,wBAAwB;AAC3C,QAAI,UAAU,2BAAgC,KAAK,qBAAqB,GAAG;AACzE;AAAA,IACF;AAEA,UAAM,WAAW,eAAe,CAAC,eAAe;AAC9C,iBAAW,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;AAC1C,YAAM,YAAY,WAAW,UAAU;AAEvC,UAAI,gCAAgB,SAAS,EAC1B,cAAc,KAAK,oBAAoB,KAAK,CAAC,EAC7C,OAAO,EACP,YAAQ,iCAAmB,YAAY;AACtC,cAAM,KAAK,gCAAgC;AAAA,MAC7C,CAAC,CAAC;AAEJ,UAAI,gCAAgB,SAAS,EAC1B,kBAAc,eAAE,CAAC,MAAM,EAAE,iBAAiB,iBAAiB,MAAM,CAAC,EAClE,YAAQ,iCAAmB,YAAY;AACtC,cAAM,KAAK,sBAAsB,IAAI;AAAA,MACvC,CAAC,CAAC;AAAA,IACN,CAAC;AAED,SAAK,sBAAsB,WAAW,UAAU,EAAE,mBAAmB,MAAM,CAAC;AAAA,EAC9E;AACF;",
  "names": ["SuggestedPluginState"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/plugin-suggestion-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that suggests installing another community plugin the host plugin needs in order to offer\n * some of its behavior.\n *\n * A suggestion is not a dependency \u2014 but a dependency is now a thing this library HAS, so the choice\n * between them is a real one. Use a suggestion when the other plugin ADDS something: the host keeps\n * working without it, simply unable to offer whatever that plugin owns, and this component asks once\n * whether the user would like it installed. Use `PluginGateComponent` when the host's advertised\n * behavior is not there at all without the other plugin.\n *\n * This file used to argue the stronger position \u2014 that requiring another plugin should not exist, because\n * \"inventing one by refusing to load would punish the user for something they never agreed to\". That was\n * wrong about which option punishes the user, and the counter-case is worth keeping rather than quietly\n * deleting. A load-bearing plugin the user cannot identify is not a neutral outcome: months later they\n * meet it in their plugin list, nothing in Obsidian's manifest format says anything depends on it, they\n * remove it, and the damage surfaces weeks after that with no way to connect the two. Beside that, a\n * mandatory dependency that stays enabled-but-inert, names what it is waiting for, installs it in one\n * click and resumes without a restart is not a punishment \u2014 it is the same information, delivered while\n * the user can still act on it.\n *\n * The ask is surfaced twice, deliberately, because the two placements answer different questions:\n * a notice on load (\"you are missing something you probably want\") and a settings-tab banner (\"the\n * settings you came looking for live in another plugin\"). Declining silences only the notice \u2014 a user\n * who opens the settings tab is asking about the feature right then, so the banner stays.\n */\n\nimport type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { ButtonComponent } from 'obsidian';\n\nimport type { PluginNoticeComponent } from './plugin-notice-component.ts';\nimport type { PluginSettingsComponentBase } from './plugin-settings-component.ts';\n\nimport { convertAsyncToSync } from '../../async.ts';\nimport { CssClass } from '../css-class.ts';\nimport { t } from '../i18n/i18n.ts';\nimport {\n  getInstalledPluginState,\n  installAndEnablePlugin,\n  InstalledPluginState\n} from '../plugin/plugin-install-state.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { CallbackLayoutReadyComponent } from './layout-ready-component.ts';\n\n/**\n * How the suggested plugin is currently present in the vault.\n *\n * The same three states a mandatory dependency is in, so this is {@link InstalledPluginState} under the\n * name this component has always used \u2014 one enum, so a caller holding a state from either component can\n * compare it against either name.\n */\nexport const SuggestedPluginState = InstalledPluginState;\n\n/**\n * Parameters for the {@link PluginSuggestionComponent} constructor.\n */\nexport interface PluginSuggestionComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Whether the user has already declined this suggestion.\n   *\n   * Storage belongs to the host plugin (typically one of its settings), because this component has no\n   * `data.json` of its own and a decline has to outlive a reload.\n   *\n   * Only ever called once {@link pluginSettingsComponent} reports its settings loaded, so an implementation\n   * reading a setting is guaranteed to read the stored value rather than its default.\n   *\n   * @returns `true` when the suggestion has been declined.\n   */\n  isSuggestionDeclined(this: void): boolean;\n\n  /**\n   * The notice component of the plugin making the suggestion, used to show the suggestion and its\n   * outcome.\n   */\n  readonly pluginNoticeComponent: PluginNoticeComponent;\n\n  /**\n   * The settings component holding whatever {@link isSuggestionDeclined} reads.\n   *\n   * Taken as a whole component rather than as a bare \"ready\" flag so the host cannot forget to wire the\n   * wait: the notice is decided only after this component has read `data.json`. See\n   * {@link PluginSettingsComponentBase.whenLoadedFromFile} for why the read cannot simply happen at\n   * layout-ready.\n   */\n  readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n\n  /**\n   * The localized sentence explaining what the host plugin cannot do without the suggested plugin. The\n   * host plugin owns this string: only it knows which of its features are affected.\n   */\n  readonly reason: string;\n\n  /**\n   * Records the user's answer to the suggestion.\n   *\n   * @param isDeclined - `true` when the user declined.\n   * @returns A {@link Promise} that resolves once the answer is persisted.\n   */\n  setSuggestionDeclined(this: void, isDeclined: boolean): Promisable<void>;\n\n  /**\n   * The id of the suggested plugin, as listed in Obsidian's community plugin registry.\n   */\n  readonly suggestedPluginId: string;\n\n  /**\n   * The display name of the suggested plugin, shown to the user.\n   */\n  readonly suggestedPluginName: string;\n}\n\n/**\n * How the suggested plugin is currently present in the vault.\n */\nexport type SuggestedPluginState = InstalledPluginState;\n\n/**\n * Suggests installing another community plugin, via a load-time notice and a settings-tab banner.\n */\nexport class PluginSuggestionComponent extends ComponentEx {\n  private readonly app: App;\n  private readonly isSuggestionDeclined: () => boolean;\n  private readonly pluginNoticeComponent: PluginNoticeComponent;\n  private readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;\n  private readonly reason: string;\n  private readonly setSuggestionDeclined: (isDeclined: boolean) => Promisable<void>;\n  private readonly suggestedPluginId: string;\n  private readonly suggestedPluginName: string;\n\n  /**\n   * Creates an instance of {@link PluginSuggestionComponent}.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginSuggestionComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.pluginNoticeComponent = params.pluginNoticeComponent;\n    this.pluginSettingsComponent = params.pluginSettingsComponent;\n    this.reason = params.reason;\n    this.suggestedPluginId = params.suggestedPluginId;\n    this.suggestedPluginName = params.suggestedPluginName;\n    this.isSuggestionDeclined = params.isSuggestionDeclined;\n    this.setSuggestionDeclined = params.setSuggestionDeclined;\n  }\n\n  /**\n   * Resolves how the suggested plugin is currently present in the vault.\n   *\n   * @returns The {@link SuggestedPluginState}.\n   */\n  public getSuggestedPluginState(): SuggestedPluginState {\n    return getInstalledPluginState({\n      app: this.app,\n      pluginId: this.suggestedPluginId\n    });\n  }\n\n  /**\n   * Installs (when needed) and enables the suggested plugin, reporting the outcome as a notice.\n   *\n   * @returns A {@link Promise} that resolves once the plugin is enabled, or once the failure has been\n   * reported.\n   */\n  public async installAndEnableSuggestedPlugin(): Promise<void> {\n    if (this.getSuggestedPluginState() === SuggestedPluginState.Enabled) {\n      return;\n    }\n\n    await installAndEnablePlugin({\n      app: this.app,\n      pluginId: this.suggestedPluginId,\n      pluginName: this.suggestedPluginName,\n      pluginNoticeComponent: this.pluginNoticeComponent\n    });\n\n    // Only after the install actually succeeded \u2014 `installAndEnablePlugin` rethrows on failure, so a\n    // Failed attempt leaves a previous decline standing rather than silently clearing it.\n    await this.setSuggestionDeclined(false);\n  }\n\n  /**\n   * Loads the component, showing the suggestion notice once the layout is ready AND the host's settings\n   * have been read from disk.\n   *\n   * Both waits matter, and neither implies the other:\n   *\n   * - Layout-ready, because plugins load in an unspecified order, so the suggested plugin may well be\n   *   enabled a moment after this one. Checking earlier would suggest installing something the user\n   *   already has.\n   * - Settings-loaded, because {@link PluginSuggestionComponentConstructorParams.isSuggestionDeclined}\n   *   reads a setting of the host, and the host's settings component is a SIBLING whose own async load is\n   *   still in flight here. On a layout that is already ready \u2014 a runtime enable from the Community\n   *   Plugins tab, or a re-enable after an update \u2014 the layout-ready callback fires immediately, so the\n   *   read would see the default `false` and ask again a user who has already declined.\n   */\n  public override onload(): void {\n    this.addChild(\n      new CallbackLayoutReadyComponent(this.app, async () => {\n        await this.pluginSettingsComponent.whenLoadedFromFile();\n        if (this.isUnloaded()) {\n          return;\n        }\n\n        this.showSuggestionNotice();\n      })\n    );\n  }\n\n  /**\n   * Renders the suggestion banner into a settings-tab container, with a button that installs and enables\n   * the suggested plugin.\n   *\n   * Renders nothing when the suggested plugin is already enabled. Unlike the notice, the banner ignores a\n   * previous decline \u2014 the user is looking at these settings right now, which is a fresher signal than an\n   * answer they gave earlier.\n   *\n   * @param containerEl - The element to render the banner into.\n   */\n  public renderBanner(containerEl: HTMLElement): void {\n    const state = this.getSuggestedPluginState();\n    if (state === SuggestedPluginState.Enabled) {\n      return;\n    }\n\n    const bannerEl = containerEl.createDiv({\n      cls: [CssClass.LibraryName, CssClass.PluginSuggestionBanner]\n    });\n    bannerEl.createDiv({ text: this.reason });\n\n    new ButtonComponent(bannerEl)\n      .setButtonText(this.getActionButtonText(state))\n      .setCta()\n      .onClick(convertAsyncToSync(async () => {\n        await this.installAndEnableSuggestedPlugin();\n      }));\n  }\n\n  private getActionButtonText(state: SuggestedPluginState): string {\n    return t(($) =>\n      state === SuggestedPluginState.InstalledButDisabled\n        ? $.obsidianDevUtils.pluginSuggestion.enable\n        : $.obsidianDevUtils.pluginSuggestion.install\n    );\n  }\n\n  private showSuggestionNotice(): void {\n    const state = this.getSuggestedPluginState();\n    if (state === SuggestedPluginState.Enabled || this.isSuggestionDeclined()) {\n      return;\n    }\n\n    const fragment = createFragment((fragmentEl) => {\n      fragmentEl.createDiv({ text: this.reason });\n      const buttonsEl = fragmentEl.createDiv();\n\n      new ButtonComponent(buttonsEl)\n        .setButtonText(this.getActionButtonText(state))\n        .setCta()\n        .onClick(convertAsyncToSync(async () => {\n          await this.installAndEnableSuggestedPlugin();\n        }));\n\n      new ButtonComponent(buttonsEl)\n        .setButtonText(t(($) => $.obsidianDevUtils.pluginSuggestion.notNow))\n        .onClick(convertAsyncToSync(async () => {\n          await this.setSuggestionDeclined(true);\n        }));\n    });\n\n    this.pluginNoticeComponent.showNotice(fragment, { shouldHideOnClick: false });\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/obsidian/components/plugin-suggestion-component.d.cts

@@ -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' with { 'resolution-mode': 'import' };
 import type { Promisable } from 'type-fest' with { 'resolution-mode': 'import' };
 import type { PluginNoticeComponent } from './plugin-notice-component.cjs';
 import type { PluginSettingsComponentBase } from './plugin-settings-component.cjs';
+import { InstalledPluginState } from '../plugin/plugin-install-state.cjs';
 import { ComponentEx } from './component-ex.cjs';
 /**
  * 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.
  */