obsidian-dev-utils 86.2.0 → 87.0.0

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

@@ -33,7 +33,6 @@ import { ensureNonNullable } from "../../type-guards.mjs";
 import { resolveValue } from "../../value-provider.mjs";
 import { CssClass } from "../css-class.mjs";
 import { t } from "../i18n/i18n.mjs";
-import { confirm } from "../modals/confirm.mjs";
 import { addPluginCssClasses } from "../plugin/plugin-context.mjs";
 import { ComponentEx } from "./component-ex.mjs";
 import { MonkeyAroundComponent } from "./monkey-around-component.mjs";
@@ -50,9 +49,11 @@ class PluginNoticeComponent extends ComponentEx {
    * The plugin name (shown as prefix in notices).
    */
   pluginName;
+  closeButtonClickedNotices = /* @__PURE__ */ new WeakSet();
   notice = null;
   pendingTimerCancellations = /* @__PURE__ */ new Set();
   standaloneNotices = /* @__PURE__ */ new Set();
+  userClickedNotices = /* @__PURE__ */ new WeakSet();
   /**
    * Creates a new plugin notice component.
    *
@@ -96,22 +97,25 @@ class PluginNoticeComponent extends ComponentEx {
    */
   showNotice(message, options) {
     const isPermanent = options?.isPermanent ?? false;
-    const requiresCloseConfirmation = options?.requiresCloseConfirmation ?? false;
-    const isReusable = options?.isReusable ?? !requiresCloseConfirmation;
-    if (options?.isReusable === true && requiresCloseConfirmation) {
-      throw new Error("A notice that requires close confirmation cannot be reusable.");
+    const shouldHideOnClick = options?.shouldHideOnClick ?? true;
+    const requiresExplicitClose = !shouldHideOnClick;
+    const isReusable = options?.isReusable ?? !requiresExplicitClose;
+    if (options?.isReusable === true && requiresExplicitClose) {
+      throw new Error("A notice that does not hide on click cannot be reusable.");
     }
     if (options?.isReusable === false && isPermanent) {
       throw new Error("A permanent notice must be reusable.");
     }
-    const durationInMilliseconds = isPermanent || requiresCloseConfirmation ? PERMANENT_NOTICE_DURATION_IN_MILLISECONDS : null;
+    const durationInMilliseconds = isPermanent || requiresExplicitClose ? PERMANENT_NOTICE_DURATION_IN_MILLISECONDS : null;
     return this.showNoticeWithDuration({
       durationInMilliseconds,
       isReusable,
       message,
+      onCloseClick: options?.onCloseClick,
       onHide: options?.onHide,
-      requiresCloseConfirmation,
-      shouldRegisterAsPermanent: isPermanent
+      requiresExplicitClose,
+      shouldRegisterAsPermanent: isPermanent,
+      shouldShowCloseButton: options?.shouldShowCloseButton ?? true
     });
   }
   /**
@@ -160,9 +164,11 @@ class PluginNoticeComponent extends ComponentEx {
           durationInMilliseconds: PERMANENT_NOTICE_DURATION_IN_MILLISECONDS,
           isReusable: true,
           message: buildDelayedMessage(resolvedContent),
+          onCloseClick: void 0,
           onHide: void 0,
-          requiresCloseConfirmation: false,
-          shouldRegisterAsPermanent: false
+          requiresExplicitClose: false,
+          shouldRegisterAsPermanent: false,
+          shouldShowCloseButton: true
         });
       });
     }, params.delayInMilliseconds ?? DEFAULT_DELAY_BEFORE_SHOW_IN_MILLISECONDS);
@@ -183,29 +189,36 @@ class PluginNoticeComponent extends ComponentEx {
     };
   }
   /**
-   * Appends a close (X) button to the notice content. Clicking it opens a confirmation modal and, only
-   * if confirmed, hides the notice and drops it from the standalone-notice tracking set.
+   * Appends a close (X) button to the notice content. Clicking it fires
+   * {@link PluginNoticeComponentAppendCloseButtonParams.onCloseClick} (which may cancel the close); if
+   * not cancelled, it hides the notice and drops it from the standalone-notice tracking set. The hide is
+   * marked as a close-button click so {@link PluginNoticeComponentShowNoticeOptions.onHide} can
+   * distinguish it.
    *
-   * @param contentEl - The notice content wrapper to append the button to.
-   * @param getNotice - Resolves the notice to hide when the close is confirmed.
+   * @param params - The parameters.
    */
-  appendCloseButton(contentEl, getNotice) {
+  appendCloseButton(params) {
+    const { contentEl, getNotice, onCloseClick } = params;
     const closeButtonEl = contentEl.createEl("button", {
       attr: { "aria-label": t(($) => $.obsidianDevUtils.notices.closeAriaLabel) }
     });
     addPluginCssClasses(closeButtonEl, CssClass.PluginNoticeCloseButton);
+    closeButtonEl.addClasses([CssClass.ClickableIcon, CssClass.ModalHeaderButton]);
     setIcon(closeButtonEl, "x");
     closeButtonEl.addEventListener("click", (evt) => {
       evt.stopPropagation();
       invokeAsyncSafely(async () => {
-        const isConfirmed = await confirm({
-          app: this.app,
-          message: t(($) => $.obsidianDevUtils.notices.closeConfirmMessage)
+        let isCancelled = false;
+        await onCloseClick?.({
+          cancel: () => {
+            isCancelled = true;
+          }
         });
-        if (!isConfirmed) {
+        if (isCancelled) {
           return;
         }
         const notice = ensureNonNullable(getNotice());
+        this.closeButtonClickedNotices.add(notice);
         notice.hide();
         this.standaloneNotices.delete(notice);
       });
@@ -247,13 +260,13 @@ class PluginNoticeComponent extends ComponentEx {
    * @returns A {@link DocumentFragment} holding the wrapped, prefixed notice content.
    */
   buildNoticeContent(params) {
-    const { getNotice, message, requiresCloseConfirmation = false } = params;
+    const { getNotice, message, onCloseClick, requiresExplicitClose = false, shouldShowCloseButton = true } = params;
     const fragment = createFragment();
     const contentEl = fragment.createDiv();
     addPluginCssClasses(contentEl, CssClass.PluginNoticeContent);
     contentEl.appendChild(this.buildPrefixedMessage(message));
     contentEl.addEventListener("click", (evt) => {
-      if (requiresCloseConfirmation) {
+      if (requiresExplicitClose) {
         evt.stopPropagation();
         return;
       }
@@ -261,8 +274,12 @@ class PluginNoticeComponent extends ComponentEx {
         evt.stopPropagation();
       }
     });
-    if (requiresCloseConfirmation) {
-      this.appendCloseButton(contentEl, ensureNonNullable(getNotice));
+    if (requiresExplicitClose && shouldShowCloseButton) {
+      this.appendCloseButton(normalizeOptionalProperties({
+        contentEl,
+        getNotice: ensureNonNullable(getNotice),
+        onCloseClick
+      }));
     }
     return fragment;
   }
@@ -302,14 +319,14 @@ class PluginNoticeComponent extends ComponentEx {
    * interactive child's own handler still runs while a stray click cannot dismiss the notice.
    *
    * @param notice - The notice to guard.
-   * @param requiresCloseConfirmation - Whether the notice requires close confirmation; when `false`,
-   * nothing is installed.
+   * @param requiresExplicitClose - Whether the notice requires explicit close; when `false`, nothing is
+   * installed.
    */
-  installCloseConfirmationGuards(notice, requiresCloseConfirmation) {
-    if (!requiresCloseConfirmation) {
+  installExplicitCloseGuards(notice, requiresExplicitClose) {
+    if (!requiresExplicitClose) {
       return;
     }
-    addPluginCssClasses(notice.containerEl, CssClass.PluginNoticeRequiresConfirmation);
+    addPluginCssClasses(notice.containerEl, CssClass.PluginNoticeRequiresExplicitClose);
     notice.containerEl.addEventListener("click", (evt) => {
       if (evt.target instanceof Element && evt.target.closest(INTERACTIVE_ELEMENT_SELECTOR)) {
         return;
@@ -317,6 +334,23 @@ class PluginNoticeComponent extends ComponentEx {
       evt.stopPropagation();
     }, { capture: true });
   }
+  /**
+   * Tracks a click on the notice so {@link PluginNoticeComponentShowNoticeOptions.onHide} can report a
+   * user dismissal. Obsidian hides a dismissible notice synchronously during the click, so a
+   * capture-phase listener marks the notice before that hide runs; the mark is cleared after the event
+   * so a later programmatic hide is not misattributed. A close-button click is tracked separately (see
+   * {@link PluginNoticeComponent.appendCloseButton}).
+   *
+   * @param notice - The notice to track.
+   */
+  installUserClickTracking(notice) {
+    notice.containerEl.addEventListener("click", () => {
+      this.userClickedNotices.add(notice);
+      queueMicrotask(() => {
+        this.userClickedNotices.delete(notice);
+      });
+    }, { capture: true });
+  }
   setPermanentNotice(notice) {
     const map = this.getPermanentNotices();
     if (notice) {
@@ -334,17 +368,21 @@ class PluginNoticeComponent extends ComponentEx {
    * @returns The created notice.
    */
   showNoticeWithDuration(params) {
-    const { durationInMilliseconds, isReusable, message, onHide, requiresCloseConfirmation, shouldRegisterAsPermanent } = params;
+    const { durationInMilliseconds, isReusable, message, onCloseClick, onHide, requiresExplicitClose, shouldRegisterAsPermanent, shouldShowCloseButton } = params;
     const noticeDurationInMilliseconds = durationInMilliseconds ?? void 0;
+    const hasCloseButton = requiresExplicitClose && shouldShowCloseButton;
     let builtNotice = null;
     const content = this.buildNoticeContent(normalizeOptionalProperties({
-      getNotice: requiresCloseConfirmation ? () => builtNotice : void 0,
+      getNotice: hasCloseButton ? () => builtNotice : void 0,
       message,
-      requiresCloseConfirmation
+      onCloseClick,
+      requiresExplicitClose,
+      shouldShowCloseButton
     }));
     if (!isReusable) {
       builtNotice = new Notice(content, noticeDurationInMilliseconds);
-      this.installCloseConfirmationGuards(builtNotice, requiresCloseConfirmation);
+      this.installExplicitCloseGuards(builtNotice, requiresExplicitClose);
+      this.installUserClickTracking(builtNotice);
       this.wireOnHide(builtNotice, onHide);
       this.standaloneNotices.add(builtNotice);
       return builtNotice;
@@ -352,7 +390,8 @@ class PluginNoticeComponent extends ComponentEx {
     this.notice?.hide();
     builtNotice = new Notice(content, noticeDurationInMilliseconds);
     this.notice = builtNotice;
-    this.installCloseConfirmationGuards(builtNotice, requiresCloseConfirmation);
+    this.installExplicitCloseGuards(builtNotice, requiresExplicitClose);
+    this.installUserClickTracking(builtNotice);
     this.wireOnHide(builtNotice, onHide);
     if (shouldRegisterAsPermanent) {
       this.setPermanentNotice(builtNotice);
@@ -381,8 +420,10 @@ class PluginNoticeComponent extends ComponentEx {
       once: true,
       patchHandler: ({ fallback }) => {
         fallback();
+        const isCloseButtonClicked = this.closeButtonClickedNotices.has(notice);
+        const isUserAction = isCloseButtonClicked || this.userClickedNotices.has(notice);
         invokeAsyncSafely(async () => {
-          await onHide();
+          await onHide({ isCloseButtonClicked, isUserAction });
         });
       }
     });
@@ -391,4 +432,4 @@ class PluginNoticeComponent extends ComponentEx {
 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 type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  ButtonComponent,\n  Notice,\n  setIcon\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 { ensureNonNullable } from '../../type-guards.ts';\nimport { resolveValue } from '../../value-provider.ts';\nimport { CssClass } from '../css-class.ts';\nimport { t } from '../i18n/i18n.ts';\nimport { confirm } from '../modals/confirm.ts';\nimport { addPluginCssClasses } from '../plugin/plugin-context.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { MonkeyAroundComponent } from './monkey-around-component.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  /**\n   * Whether the notice occupies the single per-plugin reusable slot.\n   *\n   * A reusable notice takes the shared slot: the next reusable notice hides it, and it is hidden on unload.\n   * A non-reusable (standalone) notice is not placed in the slot \u2014 it never hides, and is never hidden by, a\n   * reusable notice; multiple standalone notices coexist. Standalone notices are still hidden together on unload.\n   *\n   * A permanent notice must be reusable ({@link PluginNoticeComponentShowNoticeOptions.isPermanent} implies\n   * `isReusable`); passing `isReusable: false` together with `isPermanent: true` throws.\n   *\n   * @default `true`\n   */\n  readonly isReusable?: boolean;\n\n  /**\n   * A callback invoked when the notice is hidden \u2014 whether by the user closing it, by a later reusable\n   * notice replacing it, by its duration elapsing, or on component unload. It runs at most once per\n   * notice. An async callback is run fire-and-forget (its rejection surfaces through the async-error\n   * pipeline).\n   */\n  onHide?(this: void): Promisable<void>;\n\n  /**\n   * Whether the notice is hard to close: it does not dismiss on any stray click, and instead shows a\n   * close (X) button whose click opens a confirmation modal, dismissing the notice only if confirmed.\n   *\n   * A hard-to-close notice is shown with an infinite duration and is standalone (implies\n   * {@link PluginNoticeComponentShowNoticeOptions.isReusable} `= false`), so a later notice never\n   * silently replaces it; passing `isReusable: true` together with `requiresCloseConfirmation: true`\n   * throws.\n   *\n   * @default `false`\n   */\n  readonly requiresCloseConfirmation?: boolean;\n}\n\ninterface PluginNoticeComponentBuildDelayedNoticeMessageParams {\n  readonly abortController?: AbortController;\n  readonly cancelButtonText?: string;\n  readonly content: DocumentFragment | string;\n}\n\ninterface PluginNoticeComponentBuildNoticeContentParams {\n  /**\n   * Resolves the notice this content belongs to, used by the close button's handler. The notice does\n   * not exist yet when the content is built, so it is resolved lazily at click time. Required when\n   * {@link PluginNoticeComponentBuildNoticeContentParams.requiresCloseConfirmation} is `true`.\n   */\n  getNotice?(this: void): Notice | null;\n\n  /**\n   * The message to display after the plugin name prefix.\n   */\n  readonly message: DocumentFragment | string;\n\n  /**\n   * Whether the notice is hard to close: stops every click from dismissing it and adds a close button\n   * guarded by a confirmation modal.\n   *\n   * @default `false`\n   */\n  readonly requiresCloseConfirmation?: boolean;\n}\n\ninterface PluginNoticeComponentConstructorParams {\n  readonly app: App;\n  readonly pluginName: string;\n}\n\ninterface PluginNoticeComponentShowNoticeWithDurationParams {\n  readonly durationInMilliseconds: null | number;\n  readonly isReusable: boolean;\n  readonly message: DocumentFragment | string;\n  readonly onHide: (() => Promisable<void>) | undefined;\n  readonly requiresCloseConfirmation: boolean;\n  readonly shouldRegisterAsPermanent: 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  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * The plugin name (shown as prefix in notices).\n   */\n  protected readonly pluginName: string;\n\n  private notice: Notice | null = null;\n  private readonly pendingTimerCancellations = new Set<() => void>();\n  private readonly standaloneNotices = new Set<Notice>();\n\n  /**\n   * Creates a new plugin notice component.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginNoticeComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.pluginName = params.pluginName;\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    for (const standaloneNotice of this.standaloneNotices) {\n      standaloneNotice.hide();\n    }\n    this.standaloneNotices.clear();\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    const requiresCloseConfirmation = options?.requiresCloseConfirmation ?? false;\n    const isReusable = options?.isReusable ?? !requiresCloseConfirmation;\n\n    if (options?.isReusable === true && requiresCloseConfirmation) {\n      throw new Error('A notice that requires close confirmation cannot be reusable.');\n    }\n    if (options?.isReusable === false && isPermanent) {\n      throw new Error('A permanent notice must be reusable.');\n    }\n\n    const durationInMilliseconds = isPermanent || requiresCloseConfirmation ? PERMANENT_NOTICE_DURATION_IN_MILLISECONDS : null;\n    return this.showNoticeWithDuration({\n      durationInMilliseconds,\n      isReusable,\n      message,\n      onHide: options?.onHide,\n      requiresCloseConfirmation,\n      shouldRegisterAsPermanent: isPermanent\n    });\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({\n          durationInMilliseconds: PERMANENT_NOTICE_DURATION_IN_MILLISECONDS,\n          isReusable: true,\n          message: buildDelayedMessage(resolvedContent),\n          onHide: undefined,\n          requiresCloseConfirmation: false,\n          shouldRegisterAsPermanent: false\n        });\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({ message: 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   * Appends a close (X) button to the notice content. Clicking it opens a confirmation modal and, only\n   * if confirmed, hides the notice and drops it from the standalone-notice tracking set.\n   *\n   * @param contentEl - The notice content wrapper to append the button to.\n   * @param getNotice - Resolves the notice to hide when the close is confirmed.\n   */\n  private appendCloseButton(contentEl: HTMLElement, getNotice: () => Notice | null): void {\n    const closeButtonEl = contentEl.createEl('button', {\n      attr: { 'aria-label': t(($) => $.obsidianDevUtils.notices.closeAriaLabel) }\n    });\n    addPluginCssClasses(closeButtonEl, CssClass.PluginNoticeCloseButton);\n    setIcon(closeButtonEl, 'x');\n    closeButtonEl.addEventListener('click', (evt) => {\n      evt.stopPropagation();\n      invokeAsyncSafely(async () => {\n        const isConfirmed = await confirm({\n          app: this.app,\n          message: t(($) => $.obsidianDevUtils.notices.closeConfirmMessage)\n        });\n        if (!isConfirmed) {\n          return;\n        }\n        const notice = ensureNonNullable(getNotice());\n        notice.hide();\n        this.standaloneNotices.delete(notice);\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 params - The parameters.\n   * @returns A {@link DocumentFragment} holding the wrapped, prefixed notice content.\n   */\n  private buildNoticeContent(params: PluginNoticeComponentBuildNoticeContentParams): DocumentFragment {\n    const { getNotice, message, requiresCloseConfirmation = false } = params;\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      // A hard-to-close notice must not dismiss on any stray click; only its close button (via the\n      // Confirmation modal) may dismiss it.\n      if (requiresCloseConfirmation) {\n        evt.stopPropagation();\n        return;\n      }\n      if (evt.target instanceof Element && evt.target.closest(INTERACTIVE_ELEMENT_SELECTOR)) {\n        evt.stopPropagation();\n      }\n    });\n\n    if (requiresCloseConfirmation) {\n      this.appendCloseButton(contentEl, ensureNonNullable(getNotice));\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  /**\n   * Makes a notice hard to close: marks its outer element (so the CSS neutralizes its padding) and\n   * installs a capture-phase click guard that stops every click except on an interactive element (a\n   * button, link, the close button, etc.) from reaching Obsidian's own dismiss handler \u2014 so an\n   * interactive child's own handler still runs while a stray click cannot dismiss the notice.\n   *\n   * @param notice - The notice to guard.\n   * @param requiresCloseConfirmation - Whether the notice requires close confirmation; when `false`,\n   * nothing is installed.\n   */\n  private installCloseConfirmationGuards(notice: Notice, requiresCloseConfirmation: boolean): void {\n    if (!requiresCloseConfirmation) {\n      return;\n    }\n    // The outer `.notice` element (`containerEl`) carries Obsidian's dismiss-on-click handler and the\n    // Padding a stray click could land on; mark it so the stylesheet drops that padding.\n    addPluginCssClasses(notice.containerEl, CssClass.PluginNoticeRequiresConfirmation);\n    // Stop every click on the notice \u2014 except on an interactive element \u2014 from reaching Obsidian's\n    // Dismiss handler. Registered in the capture phase on the outermost element so it always runs first.\n    // Letting a click reach an interactive child (a button, link, the close button, etc.) is what keeps\n    // Its own handler working; the bubble-phase guard on the content wrapper then stops that click from\n    // Bubbling up to Obsidian's dismiss handler, so the notice still stays open.\n    notice.containerEl.addEventListener('click', (evt) => {\n      if (evt.target instanceof Element && evt.target.closest(INTERACTIVE_ELEMENT_SELECTOR)) {\n        return;\n      }\n      evt.stopPropagation();\n    }, { capture: true });\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. A reusable notice replaces the current reusable notice (and\n   * is optionally registered as this plugin's permanent notice); a standalone notice is tracked\n   * separately, leaving the reusable slot untouched.\n   *\n   * @param params - The parameters.\n   * @returns The created notice.\n   */\n  private showNoticeWithDuration(params: PluginNoticeComponentShowNoticeWithDurationParams): Notice {\n    const { durationInMilliseconds, isReusable, message, onHide, requiresCloseConfirmation, shouldRegisterAsPermanent } = params;\n    // Obsidian's `Notice` treats an omitted duration as its default, so map the `null` \"no explicit\n    // Duration\" value to `undefined`.\n    const noticeDurationInMilliseconds = durationInMilliseconds ?? undefined;\n\n    // The close button's confirm handler needs the `Notice`, which does not exist until it is built from\n    // This content; capture it lazily via a holder resolved at click time. The getter is created only\n    // For a hard-to-close notice \u2014 the only kind that has a close button.\n    let builtNotice: Notice | null = null;\n    const content = this.buildNoticeContent(normalizeOptionalProperties<PluginNoticeComponentBuildNoticeContentParams>({\n      getNotice: requiresCloseConfirmation ? (): Notice | null => builtNotice : undefined,\n      message,\n      requiresCloseConfirmation\n    }));\n\n    if (!isReusable) {\n      builtNotice = new Notice(content, noticeDurationInMilliseconds);\n      this.installCloseConfirmationGuards(builtNotice, requiresCloseConfirmation);\n      this.wireOnHide(builtNotice, onHide);\n      this.standaloneNotices.add(builtNotice);\n      return builtNotice;\n    }\n\n    this.notice?.hide();\n    builtNotice = new Notice(content, noticeDurationInMilliseconds);\n    this.notice = builtNotice;\n    this.installCloseConfirmationGuards(builtNotice, requiresCloseConfirmation);\n    this.wireOnHide(builtNotice, onHide);\n\n    if (shouldRegisterAsPermanent) {\n      this.setPermanentNotice(builtNotice);\n    } else {\n      this.setPermanentNotice(null);\n    }\n    return builtNotice;\n  }\n\n  /**\n   * Wraps a notice's `hide` so the given callback runs the first time the notice is hidden \u2014 by the\n   * user, by a replacing notice, by its duration elapsing, or on unload. Does nothing when no callback\n   * is given.\n   *\n   * @param notice - The notice whose `hide` to wrap.\n   * @param onHide - The callback to invoke on the first hide, or `undefined` to skip wrapping.\n   */\n  private wireOnHide(notice: Notice, onHide: (() => Promisable<void>) | undefined): void {\n    if (!onHide) {\n      return;\n    }\n    // Run `onHide` the first time the notice is hidden. A `once` patch on `hide` intercepts exactly one\n    // Call then uninstalls itself (unloading this dedicated component), so there is no manual\n    // Single-fire bookkeeping and no lingering patch on the transient notice.\n    const patchComponent = new MonkeyAroundComponent();\n    patchComponent.load();\n    patchComponent.registerMethodPatch({\n      methodName: 'hide',\n      obj: notice,\n      once: true,\n      patchHandler: ({ fallback }) => {\n        fallback();\n        invokeAsyncSafely(async () => {\n          await onHide();\n        });\n      }\n    });\n  }\n}\n"],
  "mappings": "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",
  "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 type { App } from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport {\n  ButtonComponent,\n  Notice,\n  setIcon\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 { ensureNonNullable } from '../../type-guards.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';\nimport { MonkeyAroundComponent } from './monkey-around-component.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 * The event passed to {@link PluginNoticeComponentShowNoticeOptions.onCloseClick} when the notice's\n * close (X) button is clicked.\n */\nexport interface PluginNoticeCloseClickEvent {\n  /**\n   * Cancels the close, leaving the notice open.\n   */\n  cancel(): void;\n}\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  /**\n   * Whether the notice occupies the single per-plugin reusable slot.\n   *\n   * A reusable notice takes the shared slot: the next reusable notice hides it, and it is hidden on unload.\n   * A non-reusable (standalone) notice is not placed in the slot \u2014 it never hides, and is never hidden by, a\n   * reusable notice; multiple standalone notices coexist. Standalone notices are still hidden together on unload.\n   *\n   * A permanent notice must be reusable ({@link PluginNoticeComponentShowNoticeOptions.isPermanent} implies\n   * `isReusable`); passing `isReusable: false` together with `isPermanent: true` throws.\n   *\n   * @default `true`\n   */\n  readonly isReusable?: boolean;\n\n  /**\n   * A callback invoked when the user clicks the close (X) button, before the notice is hidden. Call\n   * {@link PluginNoticeCloseClickEvent.cancel} on the event to cancel the close and keep the notice\n   * open \u2014 for example after your own confirmation declines. An async callback is awaited before the\n   * notice is hidden. Runs only when a close button is shown (both\n   * {@link PluginNoticeComponentShowNoticeOptions.shouldHideOnClick} `= false` and\n   * {@link PluginNoticeComponentShowNoticeOptions.shouldShowCloseButton} are set).\n   */\n  onCloseClick?(this: void, event: PluginNoticeCloseClickEvent): Promisable<void>;\n\n  /**\n   * A callback invoked when the notice is hidden \u2014 whether by the user closing it, by a later reusable\n   * notice replacing it, by its duration elapsing, or on component unload. It runs at most once per\n   * notice. The {@link PluginNoticeHideInfo} argument distinguishes a user close (the close button) from\n   * a programmatic hide. An async callback is run fire-and-forget (its rejection surfaces through the\n   * async-error pipeline).\n   */\n  onHide?(this: void, info: PluginNoticeHideInfo): Promisable<void>;\n\n  /**\n   * Whether clicking the notice hides it. When `true` (the default), the notice dismisses on click like\n   * a normal Obsidian notice. When `false`, the notice is hard to close: it does not dismiss on any stray\n   * click, and instead shows a close (X) button that hides it directly (see\n   * {@link PluginNoticeComponentShowNoticeOptions.shouldShowCloseButton} and\n   * {@link PluginNoticeComponentShowNoticeOptions.onCloseClick}).\n   *\n   * A `shouldHideOnClick: false` notice is shown with an infinite duration and is standalone (implies\n   * {@link PluginNoticeComponentShowNoticeOptions.isReusable} `= false`), so a later notice never\n   * silently replaces it; passing `isReusable: true` together with `shouldHideOnClick: false` throws.\n   *\n   * @default `true`\n   */\n  readonly shouldHideOnClick?: boolean;\n\n  /**\n   * Whether the close (X) button is shown on a hard-to-close notice\n   * ({@link PluginNoticeComponentShowNoticeOptions.shouldHideOnClick} `= false`). When `false`, no close\n   * button is rendered and the notice can only be hidden programmatically. Ignored unless\n   * `shouldHideOnClick` is `false`.\n   *\n   * @default `true`\n   */\n  readonly shouldShowCloseButton?: boolean;\n}\n\n/**\n * Describes why a notice was hidden, passed to {@link PluginNoticeComponentShowNoticeOptions.onHide}.\n */\nexport interface PluginNoticeHideInfo {\n  /**\n   * Whether the notice was hidden by the user clicking its close (X) button specifically. Always implies\n   * {@link PluginNoticeHideInfo.isUserAction}.\n   */\n  readonly isCloseButtonClicked: boolean;\n\n  /**\n   * Whether the notice was hidden by a user action \u2014 clicking the close (X) button, or clicking a\n   * dismissible notice to dismiss it \u2014 as opposed to programmatically (a later reusable notice replacing\n   * it, an explicit `hide()`, the duration elapsing, or component unload).\n   */\n  readonly isUserAction: boolean;\n}\n\ninterface PluginNoticeComponentAppendCloseButtonParams {\n  readonly contentEl: HTMLElement;\n  getNotice(this: void): Notice | null;\n  onCloseClick?(this: void, event: PluginNoticeCloseClickEvent): Promisable<void>;\n}\n\ninterface PluginNoticeComponentBuildDelayedNoticeMessageParams {\n  readonly abortController?: AbortController;\n  readonly cancelButtonText?: string;\n  readonly content: DocumentFragment | string;\n}\n\ninterface PluginNoticeComponentBuildNoticeContentParams {\n  /**\n   * Resolves the notice this content belongs to, used by the close button's handler. The notice does\n   * not exist yet when the content is built, so it is resolved lazily at click time. Required when a\n   * close button is shown.\n   */\n  getNotice?(this: void): Notice | null;\n\n  /**\n   * The message to display after the plugin name prefix.\n   */\n  readonly message: DocumentFragment | string;\n\n  /**\n   * Invoked when the close button is clicked; may cancel the close. See\n   * {@link PluginNoticeComponentShowNoticeOptions.onCloseClick}.\n   */\n  onCloseClick?(this: void, event: PluginNoticeCloseClickEvent): Promisable<void>;\n\n  /**\n   * Whether the notice is hard to close: stops every click from dismissing it and, unless suppressed by\n   * {@link PluginNoticeComponentBuildNoticeContentParams.shouldShowCloseButton}, adds a close button.\n   *\n   * @default `false`\n   */\n  readonly requiresExplicitClose?: boolean;\n\n  /**\n   * Whether to render the close button when {@link PluginNoticeComponentBuildNoticeContentParams.requiresExplicitClose}.\n   *\n   * @default `true`\n   */\n  readonly shouldShowCloseButton?: boolean;\n}\n\ninterface PluginNoticeComponentConstructorParams {\n  readonly app: App;\n  readonly pluginName: string;\n}\n\ninterface PluginNoticeComponentShowNoticeWithDurationParams {\n  readonly durationInMilliseconds: null | number;\n  readonly isReusable: boolean;\n  readonly message: DocumentFragment | string;\n  readonly onCloseClick: ((this: void, event: PluginNoticeCloseClickEvent) => Promisable<void>) | undefined;\n  readonly onHide: ((this: void, info: PluginNoticeHideInfo) => Promisable<void>) | undefined;\n  readonly requiresExplicitClose: boolean;\n  readonly shouldRegisterAsPermanent: boolean;\n  readonly shouldShowCloseButton: 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  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * The plugin name (shown as prefix in notices).\n   */\n  protected readonly pluginName: string;\n\n  private readonly closeButtonClickedNotices = new WeakSet<Notice>();\n  private notice: Notice | null = null;\n  private readonly pendingTimerCancellations = new Set<() => void>();\n  private readonly standaloneNotices = new Set<Notice>();\n  private readonly userClickedNotices = new WeakSet<Notice>();\n\n  /**\n   * Creates a new plugin notice component.\n   *\n   * @param params - The constructor parameters.\n   */\n  public constructor(params: PluginNoticeComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.pluginName = params.pluginName;\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    for (const standaloneNotice of this.standaloneNotices) {\n      standaloneNotice.hide();\n    }\n    this.standaloneNotices.clear();\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    const shouldHideOnClick = options?.shouldHideOnClick ?? true;\n    const requiresExplicitClose = !shouldHideOnClick;\n    const isReusable = options?.isReusable ?? !requiresExplicitClose;\n\n    if (options?.isReusable === true && requiresExplicitClose) {\n      throw new Error('A notice that does not hide on click cannot be reusable.');\n    }\n    if (options?.isReusable === false && isPermanent) {\n      throw new Error('A permanent notice must be reusable.');\n    }\n\n    const durationInMilliseconds = isPermanent || requiresExplicitClose ? PERMANENT_NOTICE_DURATION_IN_MILLISECONDS : null;\n    return this.showNoticeWithDuration({\n      durationInMilliseconds,\n      isReusable,\n      message,\n      onCloseClick: options?.onCloseClick,\n      onHide: options?.onHide,\n      requiresExplicitClose,\n      shouldRegisterAsPermanent: isPermanent,\n      shouldShowCloseButton: options?.shouldShowCloseButton ?? true\n    });\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({\n          durationInMilliseconds: PERMANENT_NOTICE_DURATION_IN_MILLISECONDS,\n          isReusable: true,\n          message: buildDelayedMessage(resolvedContent),\n          onCloseClick: undefined,\n          onHide: undefined,\n          requiresExplicitClose: false,\n          shouldRegisterAsPermanent: false,\n          shouldShowCloseButton: true\n        });\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({ message: 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   * Appends a close (X) button to the notice content. Clicking it fires\n   * {@link PluginNoticeComponentAppendCloseButtonParams.onCloseClick} (which may cancel the close); if\n   * not cancelled, it hides the notice and drops it from the standalone-notice tracking set. The hide is\n   * marked as a close-button click so {@link PluginNoticeComponentShowNoticeOptions.onHide} can\n   * distinguish it.\n   *\n   * @param params - The parameters.\n   */\n  private appendCloseButton(params: PluginNoticeComponentAppendCloseButtonParams): void {\n    const { contentEl, getNotice, onCloseClick } = params;\n    const closeButtonEl = contentEl.createEl('button', {\n      attr: { 'aria-label': t(($) => $.obsidianDevUtils.notices.closeAriaLabel) }\n    });\n    // Reuse Obsidian's modal close-button classes so this button matches the native modal close button\n    // (look and hover); the stylesheet only positions it in the notice corner.\n    addPluginCssClasses(closeButtonEl, CssClass.PluginNoticeCloseButton);\n    closeButtonEl.addClasses([CssClass.ClickableIcon, CssClass.ModalHeaderButton]);\n    setIcon(closeButtonEl, 'x');\n    closeButtonEl.addEventListener('click', (evt) => {\n      evt.stopPropagation();\n      invokeAsyncSafely(async () => {\n        let isCancelled = false;\n        await onCloseClick?.({\n          cancel: (): void => {\n            isCancelled = true;\n          }\n        });\n        if (isCancelled) {\n          return;\n        }\n        const notice = ensureNonNullable(getNotice());\n        this.closeButtonClickedNotices.add(notice);\n        notice.hide();\n        this.standaloneNotices.delete(notice);\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 params - The parameters.\n   * @returns A {@link DocumentFragment} holding the wrapped, prefixed notice content.\n   */\n  private buildNoticeContent(params: PluginNoticeComponentBuildNoticeContentParams): DocumentFragment {\n    const { getNotice, message, onCloseClick, requiresExplicitClose = false, shouldShowCloseButton = true } = params;\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      // A hard-to-close notice must not dismiss on any stray click; only its close button may hide it.\n      if (requiresExplicitClose) {\n        evt.stopPropagation();\n        return;\n      }\n      if (evt.target instanceof Element && evt.target.closest(INTERACTIVE_ELEMENT_SELECTOR)) {\n        evt.stopPropagation();\n      }\n    });\n\n    if (requiresExplicitClose && shouldShowCloseButton) {\n      this.appendCloseButton(normalizeOptionalProperties<PluginNoticeComponentAppendCloseButtonParams>({\n        contentEl,\n        getNotice: ensureNonNullable(getNotice),\n        onCloseClick\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  /**\n   * Makes a notice hard to close: marks its outer element (so the CSS neutralizes its padding) and\n   * installs a capture-phase click guard that stops every click except on an interactive element (a\n   * button, link, the close button, etc.) from reaching Obsidian's own dismiss handler \u2014 so an\n   * interactive child's own handler still runs while a stray click cannot dismiss the notice.\n   *\n   * @param notice - The notice to guard.\n   * @param requiresExplicitClose - Whether the notice requires explicit close; when `false`, nothing is\n   * installed.\n   */\n  private installExplicitCloseGuards(notice: Notice, requiresExplicitClose: boolean): void {\n    if (!requiresExplicitClose) {\n      return;\n    }\n    // The outer `.notice` element (`containerEl`) carries Obsidian's dismiss-on-click handler and the\n    // Padding a stray click could land on; mark it so the stylesheet drops that padding.\n    addPluginCssClasses(notice.containerEl, CssClass.PluginNoticeRequiresExplicitClose);\n    // Stop every click on the notice \u2014 except on an interactive element \u2014 from reaching Obsidian's\n    // Dismiss handler. Registered in the capture phase on the outermost element so it always runs first.\n    // Letting a click reach an interactive child (a button, link, the close button, etc.) is what keeps\n    // Its own handler working; the bubble-phase guard on the content wrapper then stops that click from\n    // Bubbling up to Obsidian's dismiss handler, so the notice still stays open.\n    notice.containerEl.addEventListener('click', (evt) => {\n      if (evt.target instanceof Element && evt.target.closest(INTERACTIVE_ELEMENT_SELECTOR)) {\n        return;\n      }\n      evt.stopPropagation();\n    }, { capture: true });\n  }\n\n  /**\n   * Tracks a click on the notice so {@link PluginNoticeComponentShowNoticeOptions.onHide} can report a\n   * user dismissal. Obsidian hides a dismissible notice synchronously during the click, so a\n   * capture-phase listener marks the notice before that hide runs; the mark is cleared after the event\n   * so a later programmatic hide is not misattributed. A close-button click is tracked separately (see\n   * {@link PluginNoticeComponent.appendCloseButton}).\n   *\n   * @param notice - The notice to track.\n   */\n  private installUserClickTracking(notice: Notice): void {\n    notice.containerEl.addEventListener('click', () => {\n      // Obsidian dismisses a dismissible notice synchronously during this click, so mark it now (before\n      // That hide runs) and clear it on the next microtask \u2014 after any synchronous dismiss, but before a\n      // Later programmatic hide, so that hide is not misattributed as a user action.\n      this.userClickedNotices.add(notice);\n      queueMicrotask(() => {\n        this.userClickedNotices.delete(notice);\n      });\n    }, { capture: true });\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. A reusable notice replaces the current reusable notice (and\n   * is optionally registered as this plugin's permanent notice); a standalone notice is tracked\n   * separately, leaving the reusable slot untouched.\n   *\n   * @param params - The parameters.\n   * @returns The created notice.\n   */\n  private showNoticeWithDuration(params: PluginNoticeComponentShowNoticeWithDurationParams): Notice {\n    const { durationInMilliseconds, isReusable, message, onCloseClick, onHide, requiresExplicitClose, shouldRegisterAsPermanent, shouldShowCloseButton } = params;\n    // Obsidian's `Notice` treats an omitted duration as its default, so map the `null` \"no explicit\n    // Duration\" value to `undefined`.\n    const noticeDurationInMilliseconds = durationInMilliseconds ?? undefined;\n\n    const hasCloseButton = requiresExplicitClose && shouldShowCloseButton;\n    // The close button's click handler needs the `Notice`, which does not exist until it is built from\n    // This content; capture it lazily via a holder resolved at click time. The getter is created only\n    // When a close button is shown.\n    let builtNotice: Notice | null = null;\n    const content = this.buildNoticeContent(normalizeOptionalProperties<PluginNoticeComponentBuildNoticeContentParams>({\n      getNotice: hasCloseButton ? (): Notice | null => builtNotice : undefined,\n      message,\n      onCloseClick,\n      requiresExplicitClose,\n      shouldShowCloseButton\n    }));\n\n    if (!isReusable) {\n      builtNotice = new Notice(content, noticeDurationInMilliseconds);\n      this.installExplicitCloseGuards(builtNotice, requiresExplicitClose);\n      this.installUserClickTracking(builtNotice);\n      this.wireOnHide(builtNotice, onHide);\n      this.standaloneNotices.add(builtNotice);\n      return builtNotice;\n    }\n\n    this.notice?.hide();\n    builtNotice = new Notice(content, noticeDurationInMilliseconds);\n    this.notice = builtNotice;\n    this.installExplicitCloseGuards(builtNotice, requiresExplicitClose);\n    this.installUserClickTracking(builtNotice);\n    this.wireOnHide(builtNotice, onHide);\n\n    if (shouldRegisterAsPermanent) {\n      this.setPermanentNotice(builtNotice);\n    } else {\n      this.setPermanentNotice(null);\n    }\n    return builtNotice;\n  }\n\n  /**\n   * Wraps a notice's `hide` so the given callback runs the first time the notice is hidden \u2014 by the\n   * user, by a replacing notice, by its duration elapsing, or on unload. Does nothing when no callback\n   * is given.\n   *\n   * @param notice - The notice whose `hide` to wrap.\n   * @param onHide - The callback to invoke on the first hide, or `undefined` to skip wrapping.\n   */\n  private wireOnHide(notice: Notice, onHide: ((this: void, info: PluginNoticeHideInfo) => Promisable<void>) | undefined): void {\n    if (!onHide) {\n      return;\n    }\n    // Run `onHide` the first time the notice is hidden. A `once` patch on `hide` intercepts exactly one\n    // Call then uninstalls itself (unloading this dedicated component), so there is no manual\n    // Single-fire bookkeeping and no lingering patch on the transient notice. The user-close flags were\n    // Set before `hide()` was invoked (see `appendCloseButton` / `installUserClickTracking`), so they\n    // Still hold when read here after `fallback()`.\n    const patchComponent = new MonkeyAroundComponent();\n    patchComponent.load();\n    patchComponent.registerMethodPatch({\n      methodName: 'hide',\n      obj: notice,\n      once: true,\n      patchHandler: ({ fallback }) => {\n        fallback();\n        const isCloseButtonClicked = this.closeButtonClickedNotices.has(notice);\n        const isUserAction = isCloseButtonClicked || this.userClickedNotices.has(notice);\n        invokeAsyncSafely(async () => {\n          await onHide({ isCloseButtonClicked, isUserAction });\n        });\n      }\n    });\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/obsidian/css-class.d.mts

@@ -20,6 +20,10 @@ export declare enum CssClass {
      * A CSS class for the checkbox component.
      */
     CheckboxComponent = "checkbox-component",
+    /**
+     * Obsidian's class for a clickable icon button, giving it the hover background and icon-color treatment.
+     */
+    ClickableIcon = "clickable-icon",
     /**
      * Obsidian's class for an inline code element (used by `appendCodeBlock`).
      */
@@ -81,6 +85,11 @@ export declare enum CssClass {
      * A CSS class for the title of the minimized bar of the minimizable modal.
      */
     MinimizedModalBarTitle = "minimized-modal-bar-title",
+    /**
+     * Obsidian's class for a modal header button (e.g. the modal close button), reused to match the
+     * native modal close button's box and hover.
+     */
+    ModalHeaderButton = "modal-header-button",
     /**
      * A CSS class for the month component.
      */
@@ -131,10 +140,10 @@ export declare enum CssClass {
      */
     PluginNoticeName = "plugin-notice-name",
     /**
-     * A CSS class applied to the notice element of a notice that requires close confirmation, used to
-     * make its whole area non-dismissible.
+     * A CSS class applied to the notice element of a notice that requires an explicit close, used to make
+     * its whole area non-dismissible.
      */
-    PluginNoticeRequiresConfirmation = "plugin-notice-requires-confirmation",
+    PluginNoticeRequiresExplicitClose = "plugin-notice-requires-explicit-close",
     /**
      * A CSS class for the plugin settings tab.
      */

package/dist/lib/esm/obsidian/css-class.mjs

@@ -25,6 +25,7 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["AlertModal"] = "alert-modal";
   CssClass2["CancelButton"] = "cancel-button";
   CssClass2["CheckboxComponent"] = "checkbox-component";
+  CssClass2["ClickableIcon"] = "clickable-icon";
   CssClass2["Code"] = "code";
   CssClass2["CodeHighlighterComponent"] = "code-highlighter-component";
   CssClass2["ConfirmModal"] = "confirm-modal";
@@ -40,6 +41,7 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["MinimizedModalBar"] = "minimized-modal-bar";
   CssClass2["MinimizedModalBarAttention"] = "minimized-modal-bar-attention";
   CssClass2["MinimizedModalBarTitle"] = "minimized-modal-bar-title";
+  CssClass2["ModalHeaderButton"] = "modal-header-button";
   CssClass2["MonthComponent"] = "month-component";
   CssClass2["MultipleDropdownComponent"] = "multiple-dropdown-component";
   CssClass2["MultipleEmailComponent"] = "multiple-email-component";
@@ -52,7 +54,7 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["PluginNoticeCloseButton"] = "plugin-notice-close-button";
   CssClass2["PluginNoticeContent"] = "plugin-notice-content";
   CssClass2["PluginNoticeName"] = "plugin-notice-name";
-  CssClass2["PluginNoticeRequiresConfirmation"] = "plugin-notice-requires-confirmation";
+  CssClass2["PluginNoticeRequiresExplicitClose"] = "plugin-notice-requires-explicit-close";
   CssClass2["PluginSettingsTab"] = "plugin-settings-tab";
   CssClass2["PromptModal"] = "prompt-modal";
   CssClass2["RestoreButton"] = "restore-button";
@@ -75,4 +77,4 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
 export {
   CssClass
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/css-class.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * CSS classes used by the `obsidian-dev-utils` library.\n */\n\n/**\n * CSS classes used by the `obsidian-dev-utils` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name.\n   */\n  LibraryName = 'obsidian-dev-utils',\n\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the close button of a notice that requires close confirmation.\n   */\n  PluginNoticeCloseButton = 'plugin-notice-close-button',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class applied to the notice element of a notice that requires close confirmation, used to\n   * make its whole area non-dismissible.\n   */\n  PluginNoticeRequiresConfirmation = 'plugin-notice-requires-confirmation',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the select option modal.\n   */\n  SelectOptionModal = 'select-option-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AASO,IAAK,WAAL,kBAAKA,cAAL;AAIL,EAAAA,UAAA,gBAAa;AAKb,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,UAAO;AAKP,EAAAA,UAAA,8BAA2B;AAK3B,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,uBAAoB;AAMpB,EAAAA,UAAA,gCAA6B;AAK7B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAM1B,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,sBAAmB;AAMnB,EAAAA,UAAA,sCAAmC;AAKnC,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oCAAiC;AAKjC,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAlPN,SAAAA;AAAA,GAAA;",
  "names": ["CssClass"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/css-class.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * CSS classes used by the `obsidian-dev-utils` library.\n */\n\n/**\n * CSS classes used by the `obsidian-dev-utils` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for a clickable icon button, giving it the hover background and icon-color treatment.\n   */\n  ClickableIcon = 'clickable-icon',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name.\n   */\n  LibraryName = 'obsidian-dev-utils',\n\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * Obsidian's class for a modal header button (e.g. the modal close button), reused to match the\n   * native modal close button's box and hover.\n   */\n  ModalHeaderButton = 'modal-header-button',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the close button of a notice that requires close confirmation.\n   */\n  PluginNoticeCloseButton = 'plugin-notice-close-button',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class applied to the notice element of a notice that requires an explicit close, used to make\n   * its whole area non-dismissible.\n   */\n  PluginNoticeRequiresExplicitClose = 'plugin-notice-requires-explicit-close',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the select option modal.\n   */\n  SelectOptionModal = 'select-option-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AASO,IAAK,WAAL,kBAAKA,cAAL;AAIL,EAAAA,UAAA,gBAAa;AAKb,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,UAAO;AAKP,EAAAA,UAAA,8BAA2B;AAK3B,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,uBAAoB;AAMpB,EAAAA,UAAA,gCAA6B;AAK7B,EAAAA,UAAA,4BAAyB;AAMzB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAM1B,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,sBAAmB;AAMnB,EAAAA,UAAA,uCAAoC;AAKpC,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oCAAiC;AAKjC,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AA7PN,SAAAA;AAAA,GAAA;",
  "names": ["CssClass"]
}


package/dist/lib/esm/obsidian/i18n/locales/en.d.mts

@@ -34,7 +34,6 @@ export declare const en: {
         readonly notices: {
             readonly attachmentIsStillUsed: "Attachment {{attachmentPath}} is still used by other notes. It will not be deleted.";
             readonly closeAriaLabel: "Close";
-            readonly closeConfirmMessage: "Are you sure you want to close the notice?";
             readonly unhandledError: "An unhandled error occurred. Please check the console for more information.";
         };
         readonly queue: {

package/dist/lib/esm/obsidian/i18n/locales/en.mjs

@@ -48,7 +48,6 @@ const en = {
     notices: {
       attachmentIsStillUsed: "Attachment {{attachmentPath}} is still used by other notes. It will not be deleted.",
       closeAriaLabel: "Close",
-      closeConfirmMessage: "Are you sure you want to close the notice?",
       unhandledError: "An unhandled error occurred. Please check the console for more information."
     },
     queue: {
@@ -75,4 +74,4 @@ const en = {
 export {
   en
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/i18n/locales/translations-map.d.mts

@@ -37,7 +37,6 @@ declare const translationsMapImpl: {
             readonly notices: {
                 readonly attachmentIsStillUsed: "Attachment {{attachmentPath}} is still used by other notes. It will not be deleted.";
                 readonly closeAriaLabel: "Close";
-                readonly closeConfirmMessage: "Are you sure you want to close the notice?";
                 readonly unhandledError: "An unhandled error occurred. Please check the console for more information.";
             };
             readonly queue: {