@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/components/plugin-settings-tab-component.d.mts

@@ -0,0 +1,39 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Component that registers a plugin settings tab with Obsidian.
+ * Also registers an "Open Settings" command automatically.
+ */
+import type { Plugin } from 'obsidian';
+import { PluginSettingTab } from 'obsidian';
+import { ComponentEx } from './component-ex.mjs';
+interface PluginSettingsTabComponentConstructorParams {
+    readonly plugin: Plugin;
+    readonly pluginSettingsTab: PluginSettingTab;
+}
+/**
+ * Wraps a {@link PluginSettingTab} and registers it with Obsidian on load.
+ * Also registers an "Open Settings" command to open the settings tab from the command palette.
+ */
+export declare class PluginSettingsTabComponent extends ComponentEx {
+    /**
+     * The plugin the settings tab is registered with.
+     */
+    protected readonly plugin: Plugin;
+    /**
+     * The plugin settings tab wrapped and registered with Obsidian on load.
+     */
+    protected readonly pluginSettingsTab: PluginSettingTab;
+    /**
+     * Creates a new plugin settings tab component.
+     *
+     * @param params - The plugin settings tab component constructor parameters.
+     */
+    constructor(params: PluginSettingsTabComponentConstructorParams);
+    /**
+     * Registers the settings tab and an "Open Settings" command with Obsidian.
+     */
+    onload(): void;
+}
+export {};

package/dist/lib/esm/components/plugin-settings-tab-component.mjs

@@ -0,0 +1,81 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { PluginSettingTab } from "obsidian";
+import { ComponentEx } from "./component-ex.mjs";
+class PluginSettingsTabComponent extends ComponentEx {
+  /**
+   * The plugin the settings tab is registered with.
+   */
+  plugin;
+  /**
+   * The plugin settings tab wrapped and registered with Obsidian on load.
+   */
+  pluginSettingsTab;
+  /**
+   * Creates a new plugin settings tab component.
+   *
+   * @param params - The plugin settings tab component constructor parameters.
+   */
+  constructor(params) {
+    super();
+    this.plugin = params.plugin;
+    this.pluginSettingsTab = params.pluginSettingsTab;
+  }
+  /**
+   * Registers the settings tab and an "Open Settings" command with Obsidian.
+   */
+  onload() {
+    this.plugin.addSettingTab(this.pluginSettingsTab);
+  }
+}
+export {
+  PluginSettingsTabComponent
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,162 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * 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 — 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
+ * settings you came looking for live in another plugin"). Declining silences only the notice — a user
+ * who opens the settings tab is asking about the feature right then, so the banner stays.
+ */
+import type { App } from 'obsidian';
+import type { Promisable } from 'type-fest';
+import type { PluginNoticeComponent } from './plugin-notice-component.mjs';
+import type { PluginSettingsComponentBase } from './plugin-settings-component.mjs';
+import { InstalledPluginState } from '../plugin/plugin-install-state.mjs';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * How the suggested plugin is currently present in the vault.
+ *
+ * The same three states a mandatory dependency is in, so this is {@link InstalledPluginState} under the
+ * name this component has always used — one enum, so a caller holding a state from either component can
+ * compare it against either name.
+ */
+export declare const SuggestedPluginState: typeof InstalledPluginState;
+/**
+ * Parameters for the {@link PluginSuggestionComponent} constructor.
+ */
+export interface PluginSuggestionComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * Whether the user has already declined this suggestion.
+     *
+     * Storage belongs to the host plugin (typically one of its settings), because this component has no
+     * `data.json` of its own and a decline has to outlive a reload.
+     *
+     * Only ever called once {@link pluginSettingsComponent} reports its settings loaded, so an implementation
+     * reading a setting is guaranteed to read the stored value rather than its default.
+     *
+     * @returns `true` when the suggestion has been declined.
+     */
+    readonly isSuggestionDeclined: () => boolean;
+    /**
+     * The notice component of the plugin making the suggestion, used to show the suggestion and its
+     * outcome.
+     */
+    readonly pluginNoticeComponent: PluginNoticeComponent;
+    /**
+     * The settings component holding whatever {@link isSuggestionDeclined} reads.
+     *
+     * Taken as a whole component rather than as a bare "ready" flag so the host cannot forget to wire the
+     * wait: the notice is decided only after this component has read `data.json`. See
+     * {@link PluginSettingsComponentBase.whenLoadedFromFile} for why the read cannot simply happen at
+     * layout-ready.
+     */
+    readonly pluginSettingsComponent: PluginSettingsComponentBase<object>;
+    /**
+     * The localized sentence explaining what the host plugin cannot do without the suggested plugin. The
+     * host plugin owns this string: only it knows which of its features are affected.
+     */
+    readonly reason: string;
+    /**
+     * Records the user's answer to the suggestion.
+     *
+     * @param isDeclined - `true` when the user declined.
+     * @returns A {@link Promise} that resolves once the answer is persisted.
+     */
+    readonly setSuggestionDeclined: (isDeclined: boolean) => Promisable<void>;
+    /**
+     * The id of the suggested plugin, as listed in Obsidian's community plugin registry.
+     */
+    readonly suggestedPluginId: string;
+    /**
+     * The display name of the suggested plugin, shown to the user.
+     */
+    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.
+ */
+export declare class PluginSuggestionComponent extends ComponentEx {
+    private readonly app;
+    private readonly isSuggestionDeclined;
+    private readonly pluginNoticeComponent;
+    private readonly pluginSettingsComponent;
+    private readonly reason;
+    private readonly setSuggestionDeclined;
+    private readonly suggestedPluginId;
+    private readonly suggestedPluginName;
+    /**
+     * Creates an instance of {@link PluginSuggestionComponent}.
+     *
+     * @param params - The constructor parameters.
+     */
+    constructor(params: PluginSuggestionComponentConstructorParams);
+    /**
+     * Resolves how the suggested plugin is currently present in the vault.
+     *
+     * @returns The {@link SuggestedPluginState}.
+     */
+    getSuggestedPluginState(): SuggestedPluginState;
+    /**
+     * Installs (when needed) and enables the suggested plugin, reporting the outcome as a notice.
+     *
+     * @returns A {@link Promise} that resolves once the plugin is enabled, or once the failure has been
+     * reported.
+     */
+    installAndEnableSuggestedPlugin(): Promise<void>;
+    /**
+     * Loads the component, showing the suggestion notice once the layout is ready AND the host's settings
+     * have been read from disk.
+     *
+     * Both waits matter, and neither implies the other:
+     *
+     * - Layout-ready, because plugins load in an unspecified order, so the suggested plugin may well be
+     *   enabled a moment after this one. Checking earlier would suggest installing something the user
+     *   already has.
+     * - Settings-loaded, because {@link PluginSuggestionComponentConstructorParams.isSuggestionDeclined}
+     *   reads a setting of the host, and the host's settings component is a SIBLING whose own async load is
+     *   still in flight here. On a layout that is already ready — a runtime enable from the Community
+     *   Plugins tab, or a re-enable after an update — the layout-ready callback fires immediately, so the
+     *   read would see the default `false` and ask again a user who has already declined.
+     */
+    onload(): void;
+    /**
+     * Renders the suggestion banner into a settings-tab container, with a button that installs and enables
+     * the suggested plugin.
+     *
+     * Renders nothing when the suggested plugin is already enabled. Unlike the notice, the banner ignores a
+     * previous decline — the user is looking at these settings right now, which is a fresher signal than an
+     * answer they gave earlier.
+     *
+     * @param containerEl - The element to render the banner into.
+     */
+    renderBanner(containerEl: HTMLElement): void;
+    private getActionButtonText;
+    private showSuggestionNotice;
+}

package/dist/lib/esm/components/plugin-suggestion-component.mjs

@@ -0,0 +1,192 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { convertAsyncToSync } from "@mnaoumov/typescript-lib/async";
+import { ButtonComponent } from "obsidian";
+import { CssClass } from "../css-class.mjs";
+import { t } from "../i18n/i18n.mjs";
+import {
+  getInstalledPluginState,
+  installAndEnablePlugin,
+  InstalledPluginState
+} from "../plugin/plugin-install-state.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+import { CallbackLayoutReadyComponent } from "./layout-ready-component.mjs";
+const SuggestedPluginState = InstalledPluginState;
+class PluginSuggestionComponent extends ComponentEx {
+  app;
+  isSuggestionDeclined;
+  pluginNoticeComponent;
+  pluginSettingsComponent;
+  reason;
+  setSuggestionDeclined;
+  suggestedPluginId;
+  suggestedPluginName;
+  /**
+   * Creates an instance of {@link PluginSuggestionComponent}.
+   *
+   * @param params - The constructor parameters.
+   */
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.pluginNoticeComponent = params.pluginNoticeComponent;
+    this.pluginSettingsComponent = params.pluginSettingsComponent;
+    this.reason = params.reason;
+    this.suggestedPluginId = params.suggestedPluginId;
+    this.suggestedPluginName = params.suggestedPluginName;
+    this.isSuggestionDeclined = params.isSuggestionDeclined;
+    this.setSuggestionDeclined = params.setSuggestionDeclined;
+  }
+  /**
+   * Resolves how the suggested plugin is currently present in the vault.
+   *
+   * @returns The {@link SuggestedPluginState}.
+   */
+  getSuggestedPluginState() {
+    return getInstalledPluginState({
+      app: this.app,
+      pluginId: this.suggestedPluginId
+    });
+  }
+  /**
+   * Installs (when needed) and enables the suggested plugin, reporting the outcome as a notice.
+   *
+   * @returns A {@link Promise} that resolves once the plugin is enabled, or once the failure has been
+   * reported.
+   */
+  async installAndEnableSuggestedPlugin() {
+    if (this.getSuggestedPluginState() === SuggestedPluginState.Enabled) {
+      return;
+    }
+    await installAndEnablePlugin({
+      app: this.app,
+      pluginId: this.suggestedPluginId,
+      pluginName: this.suggestedPluginName,
+      pluginNoticeComponent: this.pluginNoticeComponent
+    });
+    await this.setSuggestionDeclined(false);
+  }
+  /**
+   * Loads the component, showing the suggestion notice once the layout is ready AND the host's settings
+   * have been read from disk.
+   *
+   * Both waits matter, and neither implies the other:
+   *
+   * - Layout-ready, because plugins load in an unspecified order, so the suggested plugin may well be
+   *   enabled a moment after this one. Checking earlier would suggest installing something the user
+   *   already has.
+   * - Settings-loaded, because {@link PluginSuggestionComponentConstructorParams.isSuggestionDeclined}
+   *   reads a setting of the host, and the host's settings component is a SIBLING whose own async load is
+   *   still in flight here. On a layout that is already ready — a runtime enable from the Community
+   *   Plugins tab, or a re-enable after an update — the layout-ready callback fires immediately, so the
+   *   read would see the default `false` and ask again a user who has already declined.
+   */
+  onload() {
+    this.addChild(
+      new CallbackLayoutReadyComponent(this.app, async () => {
+        await this.pluginSettingsComponent.whenLoadedFromFile();
+        if (this.isUnloaded()) {
+          return;
+        }
+        this.showSuggestionNotice();
+      })
+    );
+  }
+  /**
+   * Renders the suggestion banner into a settings-tab container, with a button that installs and enables
+   * the suggested plugin.
+   *
+   * Renders nothing when the suggested plugin is already enabled. Unlike the notice, the banner ignores a
+   * previous decline — the user is looking at these settings right now, which is a fresher signal than an
+   * answer they gave earlier.
+   *
+   * @param containerEl - The element to render the banner into.
+   */
+  renderBanner(containerEl) {
+    const state = this.getSuggestedPluginState();
+    if (state === SuggestedPluginState.Enabled) {
+      return;
+    }
+    const bannerEl = containerEl.createDiv({
+      cls: [CssClass.LibraryName, CssClass.PluginSuggestionBanner]
+    });
+    bannerEl.createDiv({ text: this.reason });
+    new ButtonComponent(bannerEl).setButtonText(this.getActionButtonText(state)).setCta().onClick(convertAsyncToSync(async () => {
+      await this.installAndEnableSuggestedPlugin();
+    }));
+  }
+  getActionButtonText(state) {
+    return t(
+      ($) => state === SuggestedPluginState.InstalledButDisabled ? $.obsidianDevUtils.pluginSuggestion.enable : $.obsidianDevUtils.pluginSuggestion.install
+    );
+  }
+  showSuggestionNotice() {
+    const state = this.getSuggestedPluginState();
+    if (state === SuggestedPluginState.Enabled || this.isSuggestionDeclined()) {
+      return;
+    }
+    const fragment = createFragment((fragmentEl) => {
+      fragmentEl.createDiv({ text: this.reason });
+      const buttonsEl = fragmentEl.createDiv();
+      new ButtonComponent(buttonsEl).setButtonText(this.getActionButtonText(state)).setCta().onClick(convertAsyncToSync(async () => {
+        await this.installAndEnableSuggestedPlugin();
+      }));
+      new ButtonComponent(buttonsEl).setButtonText(t(($) => $.obsidianDevUtils.pluginSuggestion.notNow)).onClick(convertAsyncToSync(async () => {
+        await this.setSuggestionDeclined(true);
+      }));
+    });
+    this.pluginNoticeComponent.showNotice(fragment, { shouldHideOnClick: false });
+  }
+}
+export {
+  PluginSuggestionComponent,
+  SuggestedPluginState
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/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 { convertAsyncToSync } from '@mnaoumov/typescript-lib/async';\nimport { ButtonComponent } from 'obsidian';\n\nimport type { PluginNoticeComponent } from './plugin-notice-component.ts';\nimport type { PluginSettingsComponentBase } from './plugin-settings-component.ts';\n\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  readonly isSuggestionDeclined: () => 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  readonly setSuggestionDeclined: (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/esm/components/pointer-position-component.d.mts

@@ -0,0 +1,29 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Remembers where the last pointer gesture happened, so UI can be anchored there.
+ *
+ * A context menu is the reason this exists: Obsidian's `file-menu` / `url-menu` events carry the
+ * target file or url but no event and no DOM element, and by the time a menu item's callback runs the
+ * menu is closing — so there is nothing left to measure. The right-click (or long-press) that raised
+ * the menu is, however, exactly where the user is looking, and it always precedes the menu.
+ */
+import type { PopoverAnchor } from '../popovers/popover-anchor.mjs';
+import { AllWindowsEventComponent } from './all-windows-event-component.mjs';
+/**
+ * Records the position of the last pointer gesture in any window.
+ */
+export declare class PointerPositionComponent extends AllWindowsEventComponent {
+    private lastAnchor;
+    /**
+     * The anchor for the last pointer gesture.
+     *
+     * @returns The anchor, or `null` when no pointer gesture has happened yet.
+     */
+    getLastPointerAnchor(): null | PopoverAnchor;
+    /**
+     * Starts recording pointer gestures in every window.
+     */
+    onload(): void;
+}

package/dist/lib/esm/components/pointer-position-component.mjs

@@ -0,0 +1,77 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { createAnchorFromPoint } from "../popovers/popover-anchor.mjs";
+import { AllWindowsEventComponent } from "./all-windows-event-component.mjs";
+class PointerPositionComponent extends AllWindowsEventComponent {
+  lastAnchor = null;
+  /**
+   * The anchor for the last pointer gesture.
+   *
+   * @returns The anchor, or `null` when no pointer gesture has happened yet.
+   */
+  getLastPointerAnchor() {
+    return this.lastAnchor;
+  }
+  /**
+   * Starts recording pointer gestures in every window.
+   */
+  onload() {
+    super.onload();
+    this.registerAllWindowsHandler((win) => {
+      this.registerDomEvent(win.document, "pointerdown", ($event) => {
+        this.lastAnchor = createAnchorFromPoint($event.clientX, $event.clientY, win.document);
+      }, { capture: true });
+    });
+  }
+}
+export {
+  PointerPositionComponent
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2NvbXBvbmVudHMvcG9pbnRlci1wb3NpdGlvbi1jb21wb25lbnQudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBSZW1lbWJlcnMgd2hlcmUgdGhlIGxhc3QgcG9pbnRlciBnZXN0dXJlIGhhcHBlbmVkLCBzbyBVSSBjYW4gYmUgYW5jaG9yZWQgdGhlcmUuXG4gKlxuICogQSBjb250ZXh0IG1lbnUgaXMgdGhlIHJlYXNvbiB0aGlzIGV4aXN0czogT2JzaWRpYW4ncyBgZmlsZS1tZW51YCAvIGB1cmwtbWVudWAgZXZlbnRzIGNhcnJ5IHRoZVxuICogdGFyZ2V0IGZpbGUgb3IgdXJsIGJ1dCBubyBldmVudCBhbmQgbm8gRE9NIGVsZW1lbnQsIGFuZCBieSB0aGUgdGltZSBhIG1lbnUgaXRlbSdzIGNhbGxiYWNrIHJ1bnMgdGhlXG4gKiBtZW51IGlzIGNsb3NpbmcgXHUyMDE0IHNvIHRoZXJlIGlzIG5vdGhpbmcgbGVmdCB0byBtZWFzdXJlLiBUaGUgcmlnaHQtY2xpY2sgKG9yIGxvbmctcHJlc3MpIHRoYXQgcmFpc2VkXG4gKiB0aGUgbWVudSBpcywgaG93ZXZlciwgZXhhY3RseSB3aGVyZSB0aGUgdXNlciBpcyBsb29raW5nLCBhbmQgaXQgYWx3YXlzIHByZWNlZGVzIHRoZSBtZW51LlxuICovXG5cbmltcG9ydCB0eXBlIHsgUG9wb3ZlckFuY2hvciB9IGZyb20gJy4uL3BvcG92ZXJzL3BvcG92ZXItYW5jaG9yLnRzJztcblxuaW1wb3J0IHsgY3JlYXRlQW5jaG9yRnJvbVBvaW50IH0gZnJvbSAnLi4vcG9wb3ZlcnMvcG9wb3Zlci1hbmNob3IudHMnO1xuaW1wb3J0IHsgQWxsV2luZG93c0V2ZW50Q29tcG9uZW50IH0gZnJvbSAnLi9hbGwtd2luZG93cy1ldmVudC1jb21wb25lbnQudHMnO1xuXG4vKipcbiAqIFJlY29yZHMgdGhlIHBvc2l0aW9uIG9mIHRoZSBsYXN0IHBvaW50ZXIgZ2VzdHVyZSBpbiBhbnkgd2luZG93LlxuICovXG5leHBvcnQgY2xhc3MgUG9pbnRlclBvc2l0aW9uQ29tcG9uZW50IGV4dGVuZHMgQWxsV2luZG93c0V2ZW50Q29tcG9uZW50IHtcbiAgcHJpdmF0ZSBsYXN0QW5jaG9yOiBudWxsIHwgUG9wb3ZlckFuY2hvciA9IG51bGw7XG5cbiAgLyoqXG4gICAqIFRoZSBhbmNob3IgZm9yIHRoZSBsYXN0IHBvaW50ZXIgZ2VzdHVyZS5cbiAgICpcbiAgICogQHJldHVybnMgVGhlIGFuY2hvciwgb3IgYG51bGxgIHdoZW4gbm8gcG9pbnRlciBnZXN0dXJlIGhhcyBoYXBwZW5lZCB5ZXQuXG4gICAqL1xuICBwdWJsaWMgZ2V0TGFzdFBvaW50ZXJBbmNob3IoKTogbnVsbCB8IFBvcG92ZXJBbmNob3Ige1xuICAgIHJldHVybiB0aGlzLmxhc3RBbmNob3I7XG4gIH1cblxuICAvKipcbiAgICogU3RhcnRzIHJlY29yZGluZyBwb2ludGVyIGdlc3R1cmVzIGluIGV2ZXJ5IHdpbmRvdy5cbiAgICovXG4gIHB1YmxpYyBvdmVycmlkZSBvbmxvYWQoKTogdm9pZCB7XG4gICAgc3VwZXIub25sb2FkKCk7XG5cbiAgICAvKlxuICAgICAqIFJlZ2lzdGVyZWQgcGVyIHdpbmRvdyByYXRoZXIgdGhhbiB0aHJvdWdoIGByZWdpc3RlckFsbERvY3VtZW50c0RvbUV2ZW50YCBzbyB0aGUgZG9jdW1lbnQgaXNcbiAgICAgKiB0YWtlbiBmcm9tIHRoZSB3aW5kb3cgdGhlIGxpc3RlbmVyIGJlbG9uZ3MgdG8uIERlcml2aW5nIGl0IGZyb20gdGhlIGV2ZW50IHRhcmdldCBpbnN0ZWFkIHdvdWxkXG4gICAgICogYWRkIGEgYnJhbmNoIHRoYXQgYSBkb2N1bWVudC1sZXZlbCBsaXN0ZW5lciBjYW4gbmV2ZXIgdGFrZS5cbiAgICAgKlxuICAgICAqIGBwb2ludGVyZG93bmAgcmF0aGVyIHRoYW4gYGNsaWNrYCAvIGBjb250ZXh0bWVudWA6IGl0IGZpcmVzIGZvciBldmVyeSBidXR0b24gYW5kIGZvciB0b3VjaCwgc29cbiAgICAgKiBvbmUgbGlzdGVuZXIgY292ZXJzIGEgZGVza3RvcCByaWdodC1jbGljayBhbmQgYSBtb2JpbGUgbG9uZy1wcmVzcyBhbGlrZSwgYW5kIGl0IGFsd2F5cyBydW5zXG4gICAgICogYmVmb3JlIHRoZSBtZW51IG9wZW5zLlxuICAgICAqL1xuICAgIHRoaXMucmVnaXN0ZXJBbGxXaW5kb3dzSGFuZGxlcigod2luKSA9PiB7XG4gICAgICB0aGlzLnJlZ2lzdGVyRG9tRXZlbnQod2luLmRvY3VtZW50LCAncG9pbnRlcmRvd24nLCAoJGV2ZW50KSA9PiB7XG4gICAgICAgIHRoaXMubGFzdEFuY2hvciA9IGNyZWF0ZUFuY2hvckZyb21Qb2ludCgkZXZlbnQuY2xpZW50WCwgJGV2ZW50LmNsaWVudFksIHdpbi5kb2N1bWVudCk7XG4gICAgICB9LCB7IGNhcHR1cmU6IHRydWUgfSk7XG4gICAgfSk7XG4gIH1cbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFhQSxTQUFTLDZCQUE2QjtBQUN0QyxTQUFTLGdDQUFnQztBQUtsQyxNQUFNLGlDQUFpQyx5QkFBeUI7QUFBQSxFQUM3RCxhQUFtQztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQU9wQyx1QkFBNkM7QUFDbEQsV0FBTyxLQUFLO0FBQUEsRUFDZDtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBS2dCLFNBQWU7QUFDN0IsVUFBTSxPQUFPO0FBV2IsU0FBSywwQkFBMEIsQ0FBQyxRQUFRO0FBQ3RDLFdBQUssaUJBQWlCLElBQUksVUFBVSxlQUFlLENBQUMsV0FBVztBQUM3RCxhQUFLLGFBQWEsc0JBQXNCLE9BQU8sU0FBUyxPQUFPLFNBQVMsSUFBSSxRQUFRO0FBQUEsTUFDdEYsR0FBRyxFQUFFLFNBQVMsS0FBSyxDQUFDO0FBQUEsSUFDdEIsQ0FBQztBQUFBLEVBQ0g7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/components/registry-component.d.mts

@@ -0,0 +1,37 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * {@link RegistryComponent}.
+ */
+import type { Constructor } from 'type-fest';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * A component that keeps registry of its children.
+ */
+export declare class RegistryComponent extends ComponentEx {
+    /**
+     * Get the single child of the given type.
+     *
+     * @typeParam TComponent - The type of component to get.
+     * @param componentClass - The class of the component to get.
+     * @returns The single registered child of the given type.
+     */
+    getChild<TComponent>(componentClass: Constructor<TComponent>): TComponent;
+    /**
+     * Get the single child of the given type.
+     *
+     * @typeParam TComponent - The type of component to get.
+     * @param componentClass - The class of the component to get.
+     * @returns The single registered child of the given type, or `null` if none are registered.
+     */
+    getChildOrNull<TComponent>(componentClass: Constructor<TComponent>): null | TComponent;
+    /**
+     * Get all children of the given type.
+     *
+     * @typeParam TComponent - The type of component to get.
+     * @param componentClass - The class of the component to get.
+     * @returns All registered children of the given type.
+     */
+    getChildren<TComponent>(componentClass: Constructor<TComponent>): TComponent[];
+}