obsidian-dev-utils 83.2.0 → 84.0.0

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

@@ -5,7 +5,50 @@
  * Component that manages displaying notices to the user.
  */
 import { Notice } from 'obsidian';
+import type { ValueProvider } from '../../value-provider.mjs';
 import { ComponentEx } from './component-ex.mjs';
+/**
+ * A handle to a delayed notice created by {@link PluginNoticeComponent.showNoticeAfterDelay}. It is a
+ * {@link Disposable} (so it can be used with `using`) that also lets the content be updated while the
+ * notice is shown.
+ */
+export interface PluginNoticeComponentDelayedNotice extends Disposable {
+    /**
+     * Replaces the notice content, re-applying the plugin-name prefix, the interactive-click guard, and
+     * the Cancel button. Useful for reporting progress. If the delay has not elapsed yet, the new content
+     * becomes what is shown once it does.
+     *
+     * @param content - The new notice content.
+     */
+    setContent(content: DocumentFragment | string): void;
+}
+/**
+ * Parameters for {@link PluginNoticeComponent.showNoticeAfterDelay}.
+ */
+export interface PluginNoticeComponentShowNoticeAfterDelayParams {
+    /**
+     * When provided, a Cancel button is appended to the notice; clicking it aborts this controller. When
+     * omitted, no Cancel button is shown.
+     */
+    readonly abortController?: AbortController;
+    /**
+     * The text of the Cancel button shown when {@link PluginNoticeComponentShowNoticeAfterDelayParams.abortController}
+     * is provided. When omitted, the localized `Cancel` label is used.
+     */
+    readonly cancelButtonText?: string;
+    /**
+     * The notice content, resolved lazily only if the delay elapses — so an operation that finishes
+     * sooner never builds it.
+     */
+    readonly content: ValueProvider<DocumentFragment | string>;
+    /**
+     * How long the operation must run before the notice is shown. Operations that finish sooner never
+     * show a notice, avoiding a distracting flash.
+     *
+     * @default `500`
+     */
+    readonly delayInMilliseconds?: number;
+}
 /**
  * Options for {@link PluginNoticeComponent.showNotice}.
  */
@@ -28,6 +71,7 @@ export interface PluginNoticeComponentShowNoticeOptions {
 export declare class PluginNoticeComponent extends ComponentEx {
     private readonly pluginName;
     private notice;
+    private readonly pendingTimerCancellations;
     /**
      * Creates a new plugin notice component.
      *
@@ -50,6 +94,46 @@ export declare class PluginNoticeComponent extends ComponentEx {
      * @returns The notice object.
      */
     showNotice(message: DocumentFragment | string, options?: PluginNoticeComponentShowNoticeOptions): Notice;
+    /**
+     * Shows a notice describing a long-running operation, but only once the operation has run for longer
+     * than {@link PluginNoticeComponentShowNoticeAfterDelayParams.delayInMilliseconds} — so operations
+     * that finish sooner never flash a notice. The notice stays until the returned {@link Disposable} is
+     * disposed (which also cancels the pending timer if it has not fired yet), so it can be used with
+     * `using`. When an {@link PluginNoticeComponentShowNoticeAfterDelayParams.abortController} is given, a
+     * Cancel button that aborts it is appended (and, being interactive, does not dismiss the notice).
+     *
+     * @example
+     * ```ts
+     * using _notice = pluginNoticeComponent.showNoticeAfterDelay({
+     *   abortController,
+     *   content: () => buildProgressFragment()
+     * });
+     * await runOperation(abortController.signal);
+     * ```
+     *
+     * @param params - The parameters.
+     * @returns A {@link PluginNoticeComponentDelayedNotice} that hides the notice (or cancels the pending
+     * timer) when disposed and lets the content be updated while it is shown.
+     */
+    showNoticeAfterDelay(params: PluginNoticeComponentShowNoticeAfterDelayParams): PluginNoticeComponentDelayedNotice;
+    /**
+     * Builds the message for a delayed notice: the resolved content, optionally followed by a Cancel
+     * button that aborts the provided controller when clicked.
+     *
+     * @param params - The parameters.
+     * @returns A {@link DocumentFragment} holding the content and, if requested, a Cancel button.
+     */
+    private buildDelayedNoticeMessage;
+    /**
+     * Builds the notice content wrapped in a container that keeps the notice open when an interactive
+     * element inside it is clicked. Obsidian dismisses a notice on any click that bubbles up to its
+     * element; the container intercepts clicks originating on an interactive element (a link, button,
+     * input, etc.) and stops them there, so the element's own handler still runs but the notice stays.
+     *
+     * @param message - The message to display after the plugin name prefix.
+     * @returns A {@link DocumentFragment} holding the wrapped, prefixed notice content.
+     */
+    private buildNoticeContent;
     /**
      * Builds the notice content, prefixing the message with the plugin name in a styled element so it is
      * visually distinguished from the message body.
@@ -61,4 +145,14 @@ export declare class PluginNoticeComponent extends ComponentEx {
     private getPermanentNotice;
     private getPermanentNotices;
     private setPermanentNotice;
+    /**
+     * Shows a notice with the given duration, replacing the current notice, and optionally registers it
+     * as this plugin's permanent notice.
+     *
+     * @param message - The message to display.
+     * @param durationInMilliseconds - The notice duration; `0` keeps it until it is hidden explicitly.
+     * @param shouldRegisterAsPermanent - Whether to track the notice as this plugin's permanent notice.
+     * @returns The created notice.
+     */
+    private showNoticeWithDuration;
 }

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

@@ -21,13 +21,22 @@ if you want to view the source, please visit the github repository of this plugi
   globalThis.process = browserProcess;
 })();
 
-import { Notice } from "obsidian";
+import {
+  ButtonComponent,
+  Notice
+} from "obsidian";
+import { invokeAsyncSafely } from "../../async.mjs";
+import { normalizeOptionalProperties } from "../../object-utils.mjs";
 import { getObsidianDevUtilsState } from "../../obsidian-dev-utils-state.mjs";
+import { resolveValue } from "../../value-provider.mjs";
 import { CssClass } from "../css-class.mjs";
+import { t } from "../i18n/i18n.mjs";
 import { addPluginCssClasses } from "../plugin/plugin-context.mjs";
 import { ComponentEx } from "./component-ex.mjs";
 const PERMANENT_NOTICES_STATE_KEY = "plugin-notice-component:permanent-notices";
 const PERMANENT_NOTICE_DURATION_IN_MILLISECONDS = 0;
+const DEFAULT_DELAY_BEFORE_SHOW_IN_MILLISECONDS = 500;
+const INTERACTIVE_ELEMENT_SELECTOR = 'a, button, input, select, textarea, label, [contenteditable="true"], [role="button"], [role="link"], [role="checkbox"], [role="tab"], [role="menuitem"]';
 class PluginNoticeComponent extends ComponentEx {
   /**
    * Creates a new plugin notice component.
@@ -40,6 +49,7 @@ class PluginNoticeComponent extends ComponentEx {
   }
   pluginName;
   notice = null;
+  pendingTimerCancellations = /* @__PURE__ */ new Set();
   /**
    * Dismisses the permanent notice left over from a previous load (e.g. a previous plugin session) on load.
    */
@@ -53,6 +63,9 @@ class PluginNoticeComponent extends ComponentEx {
    * Hides the current notice on unload, unless it is the permanent notice (which is meant to outlive the plugin).
    */
   onunload() {
+    for (const cancelPendingTimer of [...this.pendingTimerCancellations]) {
+      cancelPendingTimer();
+    }
     if (this.getPermanentNotice() !== this.notice) {
       this.notice?.hide();
     }
@@ -65,15 +78,116 @@ class PluginNoticeComponent extends ComponentEx {
    * @returns The notice object.
    */
   showNotice(message, options) {
-    this.notice?.hide();
-    const prefixedMessage = this.buildPrefixedMessage(message);
-    this.notice = new Notice(prefixedMessage, options?.isPermanent ? PERMANENT_NOTICE_DURATION_IN_MILLISECONDS : void 0);
-    if (options?.isPermanent) {
-      this.setPermanentNotice(this.notice);
+    const isPermanent = options?.isPermanent ?? false;
+    return this.showNoticeWithDuration(message, isPermanent ? PERMANENT_NOTICE_DURATION_IN_MILLISECONDS : void 0, isPermanent);
+  }
+  /**
+   * Shows a notice describing a long-running operation, but only once the operation has run for longer
+   * than {@link PluginNoticeComponentShowNoticeAfterDelayParams.delayInMilliseconds} — so operations
+   * that finish sooner never flash a notice. The notice stays until the returned {@link Disposable} is
+   * disposed (which also cancels the pending timer if it has not fired yet), so it can be used with
+   * `using`. When an {@link PluginNoticeComponentShowNoticeAfterDelayParams.abortController} is given, a
+   * Cancel button that aborts it is appended (and, being interactive, does not dismiss the notice).
+   *
+   * @example
+   * ```ts
+   * using _notice = pluginNoticeComponent.showNoticeAfterDelay({
+   *   abortController,
+   *   content: () => buildProgressFragment()
+   * });
+   * await runOperation(abortController.signal);
+   * ```
+   *
+   * @param params - The parameters.
+   * @returns A {@link PluginNoticeComponentDelayedNotice} that hides the notice (or cancels the pending
+   * timer) when disposed and lets the content be updated while it is shown.
+   */
+  showNoticeAfterDelay(params) {
+    let shownNotice = null;
+    let isDisposed = false;
+    let timerId = 0;
+    let currentContent = params.content;
+    const cancelPendingTimer = () => {
+      window.clearTimeout(timerId);
+      this.pendingTimerCancellations.delete(cancelPendingTimer);
+    };
+    const buildDelayedMessage = (content) => this.buildDelayedNoticeMessage(normalizeOptionalProperties({
+      abortController: params.abortController,
+      cancelButtonText: params.cancelButtonText,
+      content
+    }));
+    timerId = window.setTimeout(() => {
+      cancelPendingTimer();
+      invokeAsyncSafely(async () => {
+        const resolvedContent = await resolveValue(currentContent, {});
+        if (isDisposed) {
+          return;
+        }
+        shownNotice = this.showNoticeWithDuration(buildDelayedMessage(resolvedContent), PERMANENT_NOTICE_DURATION_IN_MILLISECONDS, false);
+      });
+    }, params.delayInMilliseconds ?? DEFAULT_DELAY_BEFORE_SHOW_IN_MILLISECONDS);
+    this.pendingTimerCancellations.add(cancelPendingTimer);
+    return {
+      setContent: (content) => {
+        currentContent = content;
+        shownNotice?.setMessage(this.buildNoticeContent(buildDelayedMessage(content)));
+      },
+      [Symbol.dispose]: () => {
+        isDisposed = true;
+        cancelPendingTimer();
+        shownNotice?.hide();
+        if (this.notice === shownNotice) {
+          this.notice = null;
+        }
+      }
+    };
+  }
+  /**
+   * Builds the message for a delayed notice: the resolved content, optionally followed by a Cancel
+   * button that aborts the provided controller when clicked.
+   *
+   * @param params - The parameters.
+   * @returns A {@link DocumentFragment} holding the content and, if requested, a Cancel button.
+   */
+  buildDelayedNoticeMessage(params) {
+    const { abortController, cancelButtonText, content } = params;
+    const fragment = createFragment();
+    if (typeof content === "string") {
+      fragment.appendText(content);
     } else {
-      this.setPermanentNotice(null);
+      fragment.appendChild(content);
     }
-    return this.notice;
+    if (abortController) {
+      const cancelButton = new ButtonComponent(createDiv());
+      cancelButton.setButtonText(cancelButtonText ?? t(($) => $.obsidianDevUtils.buttons.cancel));
+      addPluginCssClasses(cancelButton.buttonEl, CssClass.CancelButton);
+      cancelButton.buttonEl.addEventListener("click", () => {
+        abortController.abort();
+      });
+      fragment.appendChild(cancelButton.buttonEl);
+    }
+    return fragment;
+  }
+  /**
+   * Builds the notice content wrapped in a container that keeps the notice open when an interactive
+   * element inside it is clicked. Obsidian dismisses a notice on any click that bubbles up to its
+   * element; the container intercepts clicks originating on an interactive element (a link, button,
+   * input, etc.) and stops them there, so the element's own handler still runs but the notice stays.
+   *
+   * @param message - The message to display after the plugin name prefix.
+   * @returns A {@link DocumentFragment} holding the wrapped, prefixed notice content.
+   */
+  buildNoticeContent(message) {
+    const fragment = createFragment();
+    const contentEl = fragment.createDiv();
+    addPluginCssClasses(contentEl, CssClass.PluginNoticeContent);
+    contentEl.appendChild(this.buildPrefixedMessage(message));
+    contentEl.addEventListener("click", (evt) => {
+      if (evt.target instanceof Element && evt.target.closest(INTERACTIVE_ELEMENT_SELECTOR)) {
+        evt.stopPropagation();
+      }
+    });
+    return fragment;
   }
   /**
    * Builds the notice content, prefixing the message with the plugin name in a styled element so it is
@@ -112,8 +226,28 @@ class PluginNoticeComponent extends ComponentEx {
       map.delete(this.pluginName);
     }
   }
+  /**
+   * Shows a notice with the given duration, replacing the current notice, and optionally registers it
+   * as this plugin's permanent notice.
+   *
+   * @param message - The message to display.
+   * @param durationInMilliseconds - The notice duration; `0` keeps it until it is hidden explicitly.
+   * @param shouldRegisterAsPermanent - Whether to track the notice as this plugin's permanent notice.
+   * @returns The created notice.
+   */
+  showNoticeWithDuration(message, durationInMilliseconds, shouldRegisterAsPermanent) {
+    this.notice?.hide();
+    const content = this.buildNoticeContent(message);
+    this.notice = new Notice(content, durationInMilliseconds);
+    if (shouldRegisterAsPermanent) {
+      this.setPermanentNotice(this.notice);
+    } else {
+      this.setPermanentNotice(null);
+    }
+    return this.notice;
+  }
 }
 export {
   PluginNoticeComponent
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/plugin-notice-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that manages displaying notices to the user.\n */\n\nimport { Notice } from 'obsidian';\n\nimport { getObsidianDevUtilsState } from '../../obsidian-dev-utils-state.ts';\nimport { CssClass } from '../css-class.ts';\nimport { addPluginCssClasses } from '../plugin/plugin-context.ts';\nimport { ComponentEx } from './component-ex.ts';\n\nconst PERMANENT_NOTICES_STATE_KEY = 'plugin-notice-component:permanent-notices';\nconst PERMANENT_NOTICE_DURATION_IN_MILLISECONDS = 0;\n\n/**\n * Options for {@link PluginNoticeComponent.showNotice}.\n */\nexport interface PluginNoticeComponentShowNoticeOptions {\n  /**\n   * Whether the notice should stay until it is replaced, the plugin is reloaded, or the user dismisses it.\n   *\n   * A permanent notice is shown with an infinite duration and is not hidden when the component unloads, so it can\n   * communicate state that outlives the plugin (e.g. a cleanup that requires a reload). There is at most one permanent\n   * notice per plugin: it is hidden by the next {@link PluginNoticeComponent.showNotice} call and dismissed\n   * automatically the next time the component loads (i.e. when the plugin is re-enabled).\n   *\n   * @default `false`\n   */\n  readonly isPermanent?: boolean;\n}\n\n/**\n * Manages showing plugin notices. Automatically hides the previous notice when a new one is shown.\n */\nexport class PluginNoticeComponent extends ComponentEx {\n  private notice: Notice | null = null;\n\n  /**\n   * Creates a new plugin notice component.\n   *\n   * @param pluginName - The plugin name (shown as prefix in notices).\n   */\n  public constructor(private readonly pluginName: string) {\n    super();\n  }\n\n  /**\n   * Dismisses the permanent notice left over from a previous load (e.g. a previous plugin session) on load.\n   */\n  public override onload(): void {\n    super.onload();\n    const permanentNotice = this.getPermanentNotice();\n    permanentNotice?.hide();\n    this.setPermanentNotice(null);\n  }\n\n  /**\n   * Hides the current notice on unload, unless it is the permanent notice (which is meant to outlive the plugin).\n   */\n  public override onunload(): void {\n    if (this.getPermanentNotice() !== this.notice) {\n      this.notice?.hide();\n    }\n  }\n\n  /**\n   * Displays a notice message to the user.\n   *\n   * @param message - The message to display.\n   * @param options - The options for displaying the notice.\n   * @returns The notice object.\n   */\n  public showNotice(message: DocumentFragment | string, options?: PluginNoticeComponentShowNoticeOptions): Notice {\n    this.notice?.hide();\n\n    const prefixedMessage = this.buildPrefixedMessage(message);\n    this.notice = new Notice(prefixedMessage, options?.isPermanent ? PERMANENT_NOTICE_DURATION_IN_MILLISECONDS : undefined);\n\n    if (options?.isPermanent) {\n      this.setPermanentNotice(this.notice);\n    } else {\n      this.setPermanentNotice(null);\n    }\n    return this.notice;\n  }\n\n  /**\n   * Builds the notice content, prefixing the message with the plugin name in a styled element so it is\n   * visually distinguished from the message body.\n   *\n   * @param message - The message to display after the plugin name prefix.\n   * @returns A {@link DocumentFragment} with the styled plugin name prefix followed by the message.\n   */\n  private buildPrefixedMessage(message: DocumentFragment | string): DocumentFragment {\n    const fragment = createFragment();\n    const nameEl = createSpan({ text: this.pluginName });\n    addPluginCssClasses(nameEl, CssClass.PluginNoticeName);\n    fragment.appendChild(nameEl);\n    if (!this._loaded) {\n      fragment.appendText(' (unloaded)');\n    }\n    fragment.appendText('\\n');\n    if (typeof message === 'string') {\n      fragment.appendText(message);\n    } else {\n      fragment.appendChild(message);\n    }\n    return fragment;\n  }\n\n  private getPermanentNotice(): Notice | null {\n    return this.getPermanentNotices().get(this.pluginName) ?? null;\n  }\n\n  private getPermanentNotices(): Map<string, Notice> {\n    return getObsidianDevUtilsState<Map<string, Notice>>(PERMANENT_NOTICES_STATE_KEY, new Map<string, Notice>()).value;\n  }\n\n  private setPermanentNotice(notice: Notice | null): void {\n    const map = this.getPermanentNotices();\n    if (notice) {\n      map.set(this.pluginName, notice);\n    } else {\n      map.delete(this.pluginName);\n    }\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAMA,SAAS,cAAc;AAEvB,SAAS,gCAAgC;AACzC,SAAS,gBAAgB;AACzB,SAAS,2BAA2B;AACpC,SAAS,mBAAmB;AAE5B,MAAM,8BAA8B;AACpC,MAAM,4CAA4C;AAsB3C,MAAM,8BAA8B,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,YAA6B,YAAoB;AACtD,UAAM;AAD4B;AAAA,EAEpC;AAAA,EAFoC;AAAA,EAP5B,SAAwB;AAAA;AAAA;AAAA;AAAA,EAchB,SAAe;AAC7B,UAAM,OAAO;AACb,UAAM,kBAAkB,KAAK,mBAAmB;AAChD,qBAAiB,KAAK;AACtB,SAAK,mBAAmB,IAAI;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA,EAKgB,WAAiB;AAC/B,QAAI,KAAK,mBAAmB,MAAM,KAAK,QAAQ;AAC7C,WAAK,QAAQ,KAAK;AAAA,IACpB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,WAAW,SAAoC,SAA0D;AAC9G,SAAK,QAAQ,KAAK;AAElB,UAAM,kBAAkB,KAAK,qBAAqB,OAAO;AACzD,SAAK,SAAS,IAAI,OAAO,iBAAiB,SAAS,cAAc,4CAA4C,MAAS;AAEtH,QAAI,SAAS,aAAa;AACxB,WAAK,mBAAmB,KAAK,MAAM;AAAA,IACrC,OAAO;AACL,WAAK,mBAAmB,IAAI;AAAA,IAC9B;AACA,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASQ,qBAAqB,SAAsD;AACjF,UAAM,WAAW,eAAe;AAChC,UAAM,SAAS,WAAW,EAAE,MAAM,KAAK,WAAW,CAAC;AACnD,wBAAoB,QAAQ,SAAS,gBAAgB;AACrD,aAAS,YAAY,MAAM;AAC3B,QAAI,CAAC,KAAK,SAAS;AACjB,eAAS,WAAW,aAAa;AAAA,IACnC;AACA,aAAS,WAAW,IAAI;AACxB,QAAI,OAAO,YAAY,UAAU;AAC/B,eAAS,WAAW,OAAO;AAAA,IAC7B,OAAO;AACL,eAAS,YAAY,OAAO;AAAA,IAC9B;AACA,WAAO;AAAA,EACT;AAAA,EAEQ,qBAAoC;AAC1C,WAAO,KAAK,oBAAoB,EAAE,IAAI,KAAK,UAAU,KAAK;AAAA,EAC5D;AAAA,EAEQ,sBAA2C;AACjD,WAAO,yBAA8C,6BAA6B,oBAAI,IAAoB,CAAC,EAAE;AAAA,EAC/G;AAAA,EAEQ,mBAAmB,QAA6B;AACtD,UAAM,MAAM,KAAK,oBAAoB;AACrC,QAAI,QAAQ;AACV,UAAI,IAAI,KAAK,YAAY,MAAM;AAAA,IACjC,OAAO;AACL,UAAI,OAAO,KAAK,UAAU;AAAA,IAC5B;AAAA,EACF;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/plugin-notice-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Component that manages displaying notices to the user.\n */\n\nimport {\n  ButtonComponent,\n  Notice\n} from 'obsidian';\n\nimport type { ValueProvider } from '../../value-provider.ts';\n\nimport { invokeAsyncSafely } from '../../async.ts';\nimport { normalizeOptionalProperties } from '../../object-utils.ts';\nimport { getObsidianDevUtilsState } from '../../obsidian-dev-utils-state.ts';\nimport { resolveValue } from '../../value-provider.ts';\nimport { CssClass } from '../css-class.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { addPluginCssClasses } from '../plugin/plugin-context.ts';\nimport { ComponentEx } from './component-ex.ts';\n\nconst PERMANENT_NOTICES_STATE_KEY = 'plugin-notice-component:permanent-notices';\nconst PERMANENT_NOTICE_DURATION_IN_MILLISECONDS = 0;\nconst DEFAULT_DELAY_BEFORE_SHOW_IN_MILLISECONDS = 500;\n\n// Elements a user clicks to act on them rather than to dismiss the notice. A click landing on (or\n// Inside) one of these is kept from bubbling to the notice, so the notice stays open.\nconst INTERACTIVE_ELEMENT_SELECTOR = 'a, button, input, select, textarea, label, [contenteditable=\"true\"], [role=\"button\"], [role=\"link\"], [role=\"checkbox\"], [role=\"tab\"], [role=\"menuitem\"]';\n\n/**\n * A handle to a delayed notice created by {@link PluginNoticeComponent.showNoticeAfterDelay}. It is a\n * {@link Disposable} (so it can be used with `using`) that also lets the content be updated while the\n * notice is shown.\n */\nexport interface PluginNoticeComponentDelayedNotice extends Disposable {\n  /**\n   * Replaces the notice content, re-applying the plugin-name prefix, the interactive-click guard, and\n   * the Cancel button. Useful for reporting progress. If the delay has not elapsed yet, the new content\n   * becomes what is shown once it does.\n   *\n   * @param content - The new notice content.\n   */\n  setContent(content: DocumentFragment | string): void;\n}\n\n/**\n * Parameters for {@link PluginNoticeComponent.showNoticeAfterDelay}.\n */\nexport interface PluginNoticeComponentShowNoticeAfterDelayParams {\n  /**\n   * When provided, a Cancel button is appended to the notice; clicking it aborts this controller. When\n   * omitted, no Cancel button is shown.\n   */\n  readonly abortController?: AbortController;\n\n  /**\n   * The text of the Cancel button shown when {@link PluginNoticeComponentShowNoticeAfterDelayParams.abortController}\n   * is provided. When omitted, the localized `Cancel` label is used.\n   */\n  readonly cancelButtonText?: string;\n\n  /**\n   * The notice content, resolved lazily only if the delay elapses \u2014 so an operation that finishes\n   * sooner never builds it.\n   */\n  readonly content: ValueProvider<DocumentFragment | string>;\n\n  /**\n   * How long the operation must run before the notice is shown. Operations that finish sooner never\n   * show a notice, avoiding a distracting flash.\n   *\n   * @default `500`\n   */\n  readonly delayInMilliseconds?: number;\n}\n\n/**\n * Options for {@link PluginNoticeComponent.showNotice}.\n */\nexport interface PluginNoticeComponentShowNoticeOptions {\n  /**\n   * Whether the notice should stay until it is replaced, the plugin is reloaded, or the user dismisses it.\n   *\n   * A permanent notice is shown with an infinite duration and is not hidden when the component unloads, so it can\n   * communicate state that outlives the plugin (e.g. a cleanup that requires a reload). There is at most one permanent\n   * notice per plugin: it is hidden by the next {@link PluginNoticeComponent.showNotice} call and dismissed\n   * automatically the next time the component loads (i.e. when the plugin is re-enabled).\n   *\n   * @default `false`\n   */\n  readonly isPermanent?: boolean;\n}\n\ninterface PluginNoticeComponentBuildDelayedNoticeMessageParams {\n  readonly abortController?: AbortController;\n  readonly cancelButtonText?: string;\n  readonly content: DocumentFragment | string;\n}\n\n/**\n * Manages showing plugin notices. Automatically hides the previous notice when a new one is shown.\n */\nexport class PluginNoticeComponent extends ComponentEx {\n  private notice: Notice | null = null;\n  private readonly pendingTimerCancellations = new Set<() => void>();\n\n  /**\n   * Creates a new plugin notice component.\n   *\n   * @param pluginName - The plugin name (shown as prefix in notices).\n   */\n  public constructor(private readonly pluginName: string) {\n    super();\n  }\n\n  /**\n   * Dismisses the permanent notice left over from a previous load (e.g. a previous plugin session) on load.\n   */\n  public override onload(): void {\n    super.onload();\n    const permanentNotice = this.getPermanentNotice();\n    permanentNotice?.hide();\n    this.setPermanentNotice(null);\n  }\n\n  /**\n   * Hides the current notice on unload, unless it is the permanent notice (which is meant to outlive the plugin).\n   */\n  public override onunload(): void {\n    // Cancel any delayed notice whose timer has not fired yet, so it never appears after unload.\n    for (const cancelPendingTimer of [...this.pendingTimerCancellations]) {\n      cancelPendingTimer();\n    }\n    if (this.getPermanentNotice() !== this.notice) {\n      this.notice?.hide();\n    }\n  }\n\n  /**\n   * Displays a notice message to the user.\n   *\n   * @param message - The message to display.\n   * @param options - The options for displaying the notice.\n   * @returns The notice object.\n   */\n  public showNotice(message: DocumentFragment | string, options?: PluginNoticeComponentShowNoticeOptions): Notice {\n    const isPermanent = options?.isPermanent ?? false;\n    return this.showNoticeWithDuration(message, isPermanent ? PERMANENT_NOTICE_DURATION_IN_MILLISECONDS : undefined, isPermanent);\n  }\n\n  /**\n   * Shows a notice describing a long-running operation, but only once the operation has run for longer\n   * than {@link PluginNoticeComponentShowNoticeAfterDelayParams.delayInMilliseconds} \u2014 so operations\n   * that finish sooner never flash a notice. The notice stays until the returned {@link Disposable} is\n   * disposed (which also cancels the pending timer if it has not fired yet), so it can be used with\n   * `using`. When an {@link PluginNoticeComponentShowNoticeAfterDelayParams.abortController} is given, a\n   * Cancel button that aborts it is appended (and, being interactive, does not dismiss the notice).\n   *\n   * @example\n   * ```ts\n   * using _notice = pluginNoticeComponent.showNoticeAfterDelay({\n   *   abortController,\n   *   content: () => buildProgressFragment()\n   * });\n   * await runOperation(abortController.signal);\n   * ```\n   *\n   * @param params - The parameters.\n   * @returns A {@link PluginNoticeComponentDelayedNotice} that hides the notice (or cancels the pending\n   * timer) when disposed and lets the content be updated while it is shown.\n   */\n  public showNoticeAfterDelay(params: PluginNoticeComponentShowNoticeAfterDelayParams): PluginNoticeComponentDelayedNotice {\n    let shownNotice: Notice | null = null;\n    let isDisposed = false;\n    let timerId = 0;\n    let currentContent: ValueProvider<DocumentFragment | string> = params.content;\n\n    const cancelPendingTimer = (): void => {\n      window.clearTimeout(timerId);\n      this.pendingTimerCancellations.delete(cancelPendingTimer);\n    };\n\n    const buildDelayedMessage = (content: DocumentFragment | string): DocumentFragment =>\n      this.buildDelayedNoticeMessage(normalizeOptionalProperties<PluginNoticeComponentBuildDelayedNoticeMessageParams>({\n        abortController: params.abortController,\n        cancelButtonText: params.cancelButtonText,\n        content\n      }));\n\n    timerId = window.setTimeout(() => {\n      cancelPendingTimer();\n      invokeAsyncSafely(async () => {\n        const resolvedContent = await resolveValue(currentContent, {});\n        // The handle may have been disposed while the content was being resolved; don't show a stale notice.\n        if (isDisposed) {\n          return;\n        }\n        shownNotice = this.showNoticeWithDuration(buildDelayedMessage(resolvedContent), PERMANENT_NOTICE_DURATION_IN_MILLISECONDS, false);\n      });\n    }, params.delayInMilliseconds ?? DEFAULT_DELAY_BEFORE_SHOW_IN_MILLISECONDS);\n\n    this.pendingTimerCancellations.add(cancelPendingTimer);\n\n    return {\n      setContent: (content: DocumentFragment | string): void => {\n        currentContent = content;\n        // Re-wrap so the prefix, interactive guard, and Cancel button survive the content swap.\n        shownNotice?.setMessage(this.buildNoticeContent(buildDelayedMessage(content)));\n      },\n      [Symbol.dispose]: (): void => {\n        isDisposed = true;\n        cancelPendingTimer();\n        shownNotice?.hide();\n        if (this.notice === shownNotice) {\n          this.notice = null;\n        }\n      }\n    };\n  }\n\n  /**\n   * Builds the message for a delayed notice: the resolved content, optionally followed by a Cancel\n   * button that aborts the provided controller when clicked.\n   *\n   * @param params - The parameters.\n   * @returns A {@link DocumentFragment} holding the content and, if requested, a Cancel button.\n   */\n  private buildDelayedNoticeMessage(params: PluginNoticeComponentBuildDelayedNoticeMessageParams): DocumentFragment {\n    const { abortController, cancelButtonText, content } = params;\n    const fragment = createFragment();\n    if (typeof content === 'string') {\n      fragment.appendText(content);\n    } else {\n      fragment.appendChild(content);\n    }\n\n    if (abortController) {\n      // `ButtonComponent` requires an `HTMLElement` parent, so build it on a throwaway\n      // Detached element and move its `buttonEl` into the fragment.\n      const cancelButton = new ButtonComponent(createDiv());\n      cancelButton.setButtonText(cancelButtonText ?? t(($) => $.obsidianDevUtils.buttons.cancel));\n      addPluginCssClasses(cancelButton.buttonEl, CssClass.CancelButton);\n      // The click is wired via `addEventListener` rather than `ButtonComponent.onClick` so it\n      // Bubbles through the interactive-element guard (keeping the notice open) and stays\n      // Directly exercisable via a dispatched DOM event in unit tests.\n      cancelButton.buttonEl.addEventListener('click', () => {\n        abortController.abort();\n      });\n      fragment.appendChild(cancelButton.buttonEl);\n    }\n    return fragment;\n  }\n\n  /**\n   * Builds the notice content wrapped in a container that keeps the notice open when an interactive\n   * element inside it is clicked. Obsidian dismisses a notice on any click that bubbles up to its\n   * element; the container intercepts clicks originating on an interactive element (a link, button,\n   * input, etc.) and stops them there, so the element's own handler still runs but the notice stays.\n   *\n   * @param message - The message to display after the plugin name prefix.\n   * @returns A {@link DocumentFragment} holding the wrapped, prefixed notice content.\n   */\n  private buildNoticeContent(message: DocumentFragment | string): DocumentFragment {\n    const fragment = createFragment();\n    const contentEl = fragment.createDiv();\n    addPluginCssClasses(contentEl, CssClass.PluginNoticeContent);\n    contentEl.appendChild(this.buildPrefixedMessage(message));\n    contentEl.addEventListener('click', (evt) => {\n      if (evt.target instanceof Element && evt.target.closest(INTERACTIVE_ELEMENT_SELECTOR)) {\n        evt.stopPropagation();\n      }\n    });\n    return fragment;\n  }\n\n  /**\n   * Builds the notice content, prefixing the message with the plugin name in a styled element so it is\n   * visually distinguished from the message body.\n   *\n   * @param message - The message to display after the plugin name prefix.\n   * @returns A {@link DocumentFragment} with the styled plugin name prefix followed by the message.\n   */\n  private buildPrefixedMessage(message: DocumentFragment | string): DocumentFragment {\n    const fragment = createFragment();\n    const nameEl = createSpan({ text: this.pluginName });\n    addPluginCssClasses(nameEl, CssClass.PluginNoticeName);\n    fragment.appendChild(nameEl);\n    if (!this._loaded) {\n      fragment.appendText(' (unloaded)');\n    }\n    fragment.appendText('\\n');\n    if (typeof message === 'string') {\n      fragment.appendText(message);\n    } else {\n      fragment.appendChild(message);\n    }\n    return fragment;\n  }\n\n  private getPermanentNotice(): Notice | null {\n    return this.getPermanentNotices().get(this.pluginName) ?? null;\n  }\n\n  private getPermanentNotices(): Map<string, Notice> {\n    return getObsidianDevUtilsState<Map<string, Notice>>(PERMANENT_NOTICES_STATE_KEY, new Map<string, Notice>()).value;\n  }\n\n  private setPermanentNotice(notice: Notice | null): void {\n    const map = this.getPermanentNotices();\n    if (notice) {\n      map.set(this.pluginName, notice);\n    } else {\n      map.delete(this.pluginName);\n    }\n  }\n\n  /**\n   * Shows a notice with the given duration, replacing the current notice, and optionally registers it\n   * as this plugin's permanent notice.\n   *\n   * @param message - The message to display.\n   * @param durationInMilliseconds - The notice duration; `0` keeps it until it is hidden explicitly.\n   * @param shouldRegisterAsPermanent - Whether to track the notice as this plugin's permanent notice.\n   * @returns The created notice.\n   */\n  private showNoticeWithDuration(message: DocumentFragment | string, durationInMilliseconds: number | undefined, shouldRegisterAsPermanent: boolean): Notice {\n    this.notice?.hide();\n\n    const content = this.buildNoticeContent(message);\n    this.notice = new Notice(content, durationInMilliseconds);\n\n    if (shouldRegisterAsPermanent) {\n      this.setPermanentNotice(this.notice);\n    } else {\n      this.setPermanentNotice(null);\n    }\n    return this.notice;\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/components/rename-delete-handler-component.d.mts

@@ -5,7 +5,7 @@
  * Contains utility functions for handling rename and delete events in Obsidian.
  */
 import type { App } from 'obsidian';
-import type { EditorLockComponent } from '../editor-lock.mjs';
+import type { ResourceLockComponent } from '../resource-lock.mjs';
 import type { AbortSignalComponent } from './abort-signal-component.mjs';
 import type { PluginNoticeComponent } from './plugin-notice-component.mjs';
 import { ComponentEx } from './component-ex.mjs';
@@ -70,9 +70,9 @@ export interface RenameDeleteHandlerSettings {
 interface RenameDeleteHandlerComponentConstructorParams {
     readonly abortSignalComponent: AbortSignalComponent;
     readonly app: App;
-    readonly editorLockComponent: EditorLockComponent | null;
     readonly pluginId: string;
     readonly pluginNoticeComponent: PluginNoticeComponent;
+    readonly resourceLockComponent: null | ResourceLockComponent;
     settingsBuilder(this: void): Partial<RenameDeleteHandlerSettings>;
 }
 /**
@@ -84,11 +84,11 @@ export declare class RenameDeleteHandlerComponent extends ComponentEx {
     private readonly abortSignalComponent;
     private readonly app;
     private readonly deletedMetadataCacheMap;
-    private readonly editorLockComponent;
     private readonly handledRenames;
     private readonly interruptedRenamesMap;
     private readonly pluginId;
     private readonly pluginNoticeComponent;
+    private readonly resourceLockComponent;
     private readonly settingsBuilder;
     private readonly settingsManager;
     /**