@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/components/plugin-gate-component.cjs

@@ -0,0 +1,548 @@
+/*
+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 ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plugin_gate_component_exports = {};
+__export(plugin_gate_component_exports, {
+  PluginConflictSeverity: () => PluginConflictSeverity,
+  PluginGateComponent: () => PluginGateComponent
+});
+module.exports = __toCommonJS(plugin_gate_component_exports);
+var import_async = require('@mnaoumov/typescript-lib/async');
+var import_compare_versions = require('compare-versions');
+var import_obsidian = require('obsidian');
+var import_community_plugins = require('../community-plugins.cjs');
+var import_css_class = require('../css-class.cjs');
+var import_html_element = require('../html-element.cjs');
+var import_i18n = require('../i18n/i18n.cjs');
+var import_plugin_api = require('../plugin/plugin-api.cjs');
+var import_plugin_install_state = require('../plugin/plugin-install-state.cjs');
+var import_plugin_lifecycle_events = require('../plugin/plugin-lifecycle-events.cjs');
+var import_async_events_component = require('./async-events-component.cjs');
+var import_component_ex = require('./component-ex.cjs');
+var import_layout_ready_component = require('./layout-ready-component.cjs');
+const LOSS_ANNOUNCEMENT_GRACE_PERIOD_IN_MILLISECONDS = 5e3;
+var PluginConflictSeverity = /* @__PURE__ */ ((PluginConflictSeverity2) => {
+  PluginConflictSeverity2["Block"] = "block";
+  PluginConflictSeverity2["Warn"] = "warn";
+  return PluginConflictSeverity2;
+})(PluginConflictSeverity || {});
+class BlockedPluginSettingTab extends import_obsidian.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 import_component_ex.ComponentEx {
+  announcedWarningPluginIds = /* @__PURE__ */ new Set();
+  apiRefs = /* @__PURE__ */ new Map();
+  blockedSettingTab = null;
+  conflicts;
+  dependencies;
+  hasAnnouncedBlocked = false;
+  isFeatureSurfaceLoaded = false;
+  isLayoutReady = false;
+  loadFeatureSurface;
+  lossAnnouncementTimerId = null;
+  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;
+  }
+  /**
+   * Says whether any warning conflict is in force right now.
+   *
+   * The predicate a declarative settings tab needs, and the counterpart to
+   * `PluginSuggestionComponent.getSuggestedPluginState`. Such a tab decides whether a row exists
+   * BEFORE it renders anything into it, so {@link renderConflictWarningBanner} writing nothing cannot
+   * answer the question for it — a row that renders empty is still a row, with the divider and padding
+   * every other setting has.
+   *
+   * @returns Whether at least one declared warning conflict holds.
+   */
+  hasActiveWarningConflicts() {
+    return this.getActiveConflicts("warn" /* Warn */).length > 0;
+  }
+  /**
+   * Starts watching every declared dependency and conflict.
+   */
+  onload() {
+    for (const dependency of this.dependencies) {
+      const apiRef = (0, import_plugin_api.watchPluginApi)({
+        apiVersionRange: dependency.apiVersionRange,
+        app: this.app,
+        component: this,
+        pluginId: dependency.pluginId
+      });
+      (0, import_async_events_component.registerAsyncEvent)(
+        this,
+        apiRef.on("change", async () => {
+          await this.refresh();
+        })
+      );
+      this.apiRefs.set(dependency.pluginId, apiRef);
+    }
+    const lifecycleEventNames = [import_plugin_lifecycle_events.PLUGIN_LOADED_EVENT_NAME, import_plugin_lifecycle_events.PLUGIN_UNLOADED_EVENT_NAME];
+    for (const eventName of lifecycleEventNames) {
+      this.registerEvent(this.app.workspace.on(
+        eventName,
+        (0, import_async.convertAsyncToSync)(async (payload) => {
+          if (payload.pluginId === this.plugin.manifest.id) {
+            return;
+          }
+          await this.refresh();
+        })
+      ));
+    }
+    this.addChild(
+      new import_layout_ready_component.CallbackLayoutReadyComponent(this.app, () => {
+        this.isLayoutReady = true;
+        this.presentUnsatisfied(this.getUnsatisfiedDependencies(), this.getActiveConflicts("block" /* Block */));
+        this.announceWarnings();
+      })
+    );
+    this.register(() => {
+      this.cancelLossAnnouncement();
+      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));
+    }
+  }
+  /**
+   * Says what went away while the plugin was running, now that the grace period is over.
+   *
+   * Re-reads the gate rather than trusting what closed it, so a dependency that went away during the
+   * window is announced with the rest. One that came back in time never gets here: the gate reopening
+   * cancels the timer.
+   */
+  announceLoss() {
+    this.lossAnnouncementTimerId = null;
+    for (const dependency of this.getUnsatisfiedDependencies()) {
+      this.pluginNoticeComponent.showNotice(this.createDependencyLostMessage(dependency));
+    }
+    for (const conflict of this.getActiveConflicts("block" /* Block */)) {
+      this.pluginNoticeComponent.showNotice(this.createConflictAppearedMessage(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));
+    }
+  }
+  cancelLossAnnouncement() {
+    if (this.lossAnnouncementTimerId === null) {
+      return;
+    }
+    window.clearTimeout(this.lossAnnouncementTimerId);
+    this.lossAnnouncementTimerId = null;
+  }
+  createBlockedMessage(dependency) {
+    return (0, import_html_element.createFragmentWithCodeBlocks)((0, import_i18n.t)(($) => $.obsidianDevUtils.pluginDependency.blockedNotice, {
+      dependencyPluginName: (0, import_html_element.asCodeBlock)(dependency.pluginName),
+      pluginName: (0, import_html_element.asCodeBlock)(this.plugin.manifest.name)
+    }));
+  }
+  createConflictAppearedMessage(conflict) {
+    return (0, import_html_element.createFragmentWithCodeBlocks)((0, import_i18n.t)(($) => $.obsidianDevUtils.pluginConflict.conflictAppearedNotice, {
+      conflictingPluginName: (0, import_html_element.asCodeBlock)(conflict.pluginName),
+      pluginName: (0, import_html_element.asCodeBlock)(this.plugin.manifest.name)
+    }));
+  }
+  createConflictBlockedMessage(conflict) {
+    return (0, import_html_element.createFragmentWithCodeBlocks)((0, import_i18n.t)(($) => $.obsidianDevUtils.pluginConflict.blockedNotice, {
+      conflictingPluginName: (0, import_html_element.asCodeBlock)(conflict.pluginName),
+      pluginName: (0, import_html_element.asCodeBlock)(this.plugin.manifest.name)
+    }));
+  }
+  createConflictWarningMessage(conflict) {
+    return (0, import_html_element.createFragmentWithCodeBlocks)((0, import_i18n.t)(($) => $.obsidianDevUtils.pluginConflict.warningNotice, {
+      conflictingPluginName: (0, import_html_element.asCodeBlock)(conflict.pluginName),
+      pluginName: (0, import_html_element.asCodeBlock)(this.plugin.manifest.name)
+    }));
+  }
+  createDependencyLostMessage(dependency) {
+    return (0, import_html_element.createFragmentWithCodeBlocks)((0, import_i18n.t)(($) => $.obsidianDevUtils.pluginDependency.dependencyLostNotice, {
+      dependencyPluginName: (0, import_html_element.asCodeBlock)(dependency.pluginName),
+      pluginName: (0, import_html_element.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 = (0, import_plugin_install_state.getInstalledPluginVersion)({
+      app: this.app,
+      pluginId: conflict.pluginId
+    });
+    if (installedVersion === null) {
+      return false;
+    }
+    try {
+      return (0, import_compare_versions.satisfies)(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.cancelLossAnnouncement();
+      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();
+      this.lossAnnouncementTimerId = window.setTimeout(() => {
+        this.announceLoss();
+      }, LOSS_ANNOUNCEMENT_GRACE_PERIOD_IN_MILLISECONDS);
+      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: (0, import_i18n.t)(($) => $.obsidianDevUtils.pluginDependency.settingsHeading) });
+    }
+    for (const dependency of unsatisfiedDependencies) {
+      const bannerEl = containerEl.createDiv({
+        cls: [import_css_class.CssClass.LibraryName, import_css_class.CssClass.PluginDependencyBanner]
+      });
+      bannerEl.append(this.createBlockedMessage(dependency));
+      bannerEl.createDiv({ text: dependency.reason });
+      const state = (0, import_plugin_install_state.getInstalledPluginState)({
+        app: this.app,
+        pluginId: dependency.pluginId
+      });
+      new import_obsidian.ButtonComponent(bannerEl).setButtonText((0, import_i18n.t)(
+        ($) => state === import_plugin_install_state.InstalledPluginState.InstalledButDisabled ? $.obsidianDevUtils.pluginSuggestion.enable : $.obsidianDevUtils.pluginSuggestion.install
+      )).setCta().onClick((0, import_async.convertAsyncToSync)(async () => {
+        await (0, import_plugin_install_state.installAndEnablePlugin)({
+          app: this.app,
+          pluginId: dependency.pluginId,
+          pluginName: dependency.pluginName,
+          pluginNoticeComponent: this.pluginNoticeComponent
+        });
+      }));
+      if (state !== import_plugin_install_state.InstalledPluginState.Enabled) {
+        continue;
+      }
+      this.renderOpenSettingsButton(bannerEl, dependency.pluginId, dependency.pluginName);
+    }
+    if (blockingConflicts.length === 0) {
+      return;
+    }
+    containerEl.createEl("h2", { text: (0, import_i18n.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: [import_css_class.CssClass.LibraryName, import_css_class.CssClass.PluginConflictBanner]
+    });
+    bannerEl.append(messageFragment);
+    bannerEl.createDiv({ text: conflict.reason });
+    new import_obsidian.ButtonComponent(bannerEl).setButtonText((0, import_i18n.t)(($) => $.obsidianDevUtils.pluginConflict.disable, { conflictingPluginName: conflict.pluginName })).setCta().onClick((0, import_async.convertAsyncToSync)(async () => {
+      await (0, import_community_plugins.disableCommunityPlugin)({
+        app: this.app,
+        pluginId: conflict.pluginId
+      });
+      await this.refresh();
+    }));
+    this.renderOpenSettingsButton(bannerEl, conflict.pluginId, conflict.pluginName);
+  }
+  renderOpenSettingsButton(bannerEl, pluginId, pluginName) {
+    new import_obsidian.ButtonComponent(bannerEl).setButtonText((0, import_i18n.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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginConflictSeverity,
+  PluginGateComponent
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/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 * ## Why a loss is announced late\n *\n * Obsidian updates an enabled plugin by reloading it: the old copy unloads, the new one loads. For the\n * moment in between the provider's API is revoked, so every dependent sees its dependency go away and\n * come back. The feature surface still comes down at once \u2014 the dependency really is gone for that\n * moment \u2014 but the notice waits {@link LOSS_ANNOUNCEMENT_GRACE_PERIOD_IN_MILLISECONDS}, and a loss that\n * healed in the meantime is never announced. Without that, updating one plugin put a \"no longer\n * available\" notice on screen in every plugin depending on it, describing a state that no longer held by\n * the time the user read it. A loss the user caused on purpose \u2014 disabling or uninstalling the\n * dependency \u2014 outlasts the window and is announced as before, only a few seconds later.\n */\n\nimport type {\n  App,\n  Plugin\n} from 'obsidian';\n\nimport { convertAsyncToSync } from '@mnaoumov/typescript-lib/async';\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 { 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 long a gate that closed while the plugin was running waits before saying so.\n *\n * Long enough to cover Obsidian reloading a plugin to apply its update, short enough that a user who\n * disabled the dependency by hand still connects the notice to what they just did.\n */\nconst LOSS_ANNOUNCEMENT_GRACE_PERIOD_IN_MILLISECONDS = 5000;\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  readonly loadFeatureSurface: () => 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  readonly unloadFeatureSurface: () => 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  readonly renderBanner: (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 lossAnnouncementTimerId: null | number = null;\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   * Says whether any warning conflict is in force right now.\n   *\n   * The predicate a declarative settings tab needs, and the counterpart to\n   * `PluginSuggestionComponent.getSuggestedPluginState`. Such a tab decides whether a row exists\n   * BEFORE it renders anything into it, so {@link renderConflictWarningBanner} writing nothing cannot\n   * answer the question for it \u2014 a row that renders empty is still a row, with the divider and padding\n   * every other setting has.\n   *\n   * @returns Whether at least one declared warning conflict holds.\n   */\n  public hasActiveWarningConflicts(): boolean {\n    return this.getActiveConflicts(PluginConflictSeverity.Warn).length > 0;\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.cancelLossAnnouncement();\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  /**\n   * Says what went away while the plugin was running, now that the grace period is over.\n   *\n   * Re-reads the gate rather than trusting what closed it, so a dependency that went away during the\n   * window is announced with the rest. One that came back in time never gets here: the gate reopening\n   * cancels the timer.\n   */\n  private announceLoss(): void {\n    this.lossAnnouncementTimerId = null;\n\n    for (const dependency of this.getUnsatisfiedDependencies()) {\n      this.pluginNoticeComponent.showNotice(this.createDependencyLostMessage(dependency));\n    }\n\n    for (const conflict of this.getActiveConflicts(PluginConflictSeverity.Block)) {\n      this.pluginNoticeComponent.showNotice(this.createConflictAppearedMessage(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 cancelLossAnnouncement(): void {\n    if (this.lossAnnouncementTimerId === null) {\n      return;\n    }\n\n    window.clearTimeout(this.lossAnnouncementTimerId);\n    this.lossAnnouncementTimerId = null;\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.cancelLossAnnouncement();\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 \u2014 but only\n      // once the grace period has shown the loss is not an update reloading the provider (see the file\n      // header).\n      this.lossAnnouncementTimerId = window.setTimeout(() => {\n        this.announceLoss();\n      }, LOSS_ANNOUNCEMENT_GRACE_PERIOD_IN_MILLISECONDS);\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", "satisfiesVersion"]
}
