obsidian-dev-utils 85.1.0 → 86.1.0

package/dist/lib/cjs/obsidian/components/disposable-component.cjs

@@ -129,19 +129,19 @@ __export(disposable_component_exports, {
 });
 module.exports = __toCommonJS(disposable_component_exports);
 var import_obsidian = require('obsidian');
-var import_disposable = require('../../disposable.cjs');
 function asDisposableComponent(component) {
-  if ((0, import_disposable.isDisposable)(component)) {
-    return component;
-  }
-  const disposable = component;
-  disposable[Symbol.dispose] = () => {
+  const disposableEx = component;
+  const symbolDispose = disposableEx[Symbol.dispose] ?? (() => {
     component.unload();
+  });
+  disposableEx[Symbol.dispose] = symbolDispose;
+  disposableEx.dispose = () => {
+    symbolDispose();
   };
-  return disposable;
+  return disposableEx;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   asDisposableComponent
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -5,14 +5,20 @@
  * Disposable component base class and utilities for `using` declarations.
  */
 import { Component } from 'obsidian';
-type DisposableComponentWrapper<TComponent extends Component> = Disposable & TComponent;
+import type { DisposableEx } from '../../disposable.cjs';
+type DisposableComponentWrapper<TComponent extends Component> = DisposableEx & TComponent;
 /**
- * Convert component to a Disposable interface by adding a Symbol.dispose method.
+ * Convert component to a {@link DisposableEx} interface by adding `Symbol.dispose` and a convenience
+ * {@link DisposableEx.dispose} method that unloads the component when disposed.
+ *
+ * An existing `Symbol.dispose` is preserved; the convenience {@link DisposableEx.dispose} method always
+ * delegates to it. The passed component is mutated in place and returned, so the call is idempotent.
  *
  * @typeParam TComponent - The type of component to wrap, constrained to extend Component.
  *
  * @param component - The component instance to wrap with Disposable support.
- * @returns The component cast to `DisposableComponentWrapper` with `Symbol.dispose` attached.
+ * @returns The component cast to `DisposableComponentWrapper` with `Symbol.dispose` and `dispose`
+ *   attached.
  */
 export declare function asDisposableComponent<TComponent extends Component>(component: TComponent): DisposableComponentWrapper<TComponent>;
 export {};

package/dist/lib/cjs/obsidian/components/monkey-around-component.cjs

@@ -145,7 +145,21 @@ class MonkeyAroundComponent extends import_component_ex.ComponentEx {
     this.ensureLoaded();
     const factories = {};
     factories[params.functionName] = (originalValue) => {
-      return params.patchHandler(originalValue);
+      const patchedValue = params.patchHandler(originalValue);
+      if (!params.once) {
+        return patchedValue;
+      }
+      const unloadComponent = () => {
+        this.unload();
+      };
+      function oncePatchedValue(...args) {
+        try {
+          return Reflect.apply(patchedValue, this, args);
+        } finally {
+          unloadComponent();
+        }
+      }
+      return Object.assign(oncePatchedValue, patchedValue);
     };
     this.registerPatch(params.obj, factories);
   }
@@ -165,6 +179,7 @@ class MonkeyAroundComponent extends import_component_ex.ComponentEx {
     this.registerFunctionPatch({
       functionName: params.methodName,
       obj: params.obj,
+      once: params.once ?? false,
       patchHandler: (originalMethodRaw) => {
         const originalMethod = originalMethodRaw;
         const finalPatchedMethod = params.postPatchHandler?.({
@@ -215,4 +230,4 @@ function getMonkeyAroundPatches() {
   around,
   hasPatchToken
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/monkey-around-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Improved type-safe wrapper of {@link https://www.npmjs.com/package/monkey-around} library.\n */\n\nimport type { ConditionalKeys } from 'type-fest';\n\nimport { around as originalAround } from 'monkey-around';\n\nimport type { GenericFunction } from '../../function.ts';\nimport type { GenericObject } from '../../type-guards.ts';\nimport type { MaybeReturn } from '../../type.ts';\n\nimport { getObsidianDevUtilsState } from '../../obsidian-dev-utils-state.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * A type of the factories to apply to the object.\n *\n * @typeParam Obj - The object to patch.\n */\nexport type Factories<Obj extends object> = Partial<FullFactories<Obj>>;\n\n/**\n * Keys of `Obj` whose value is callable \u2014 a method, or a function-like object such as a `Debouncer`. These are the members\n * accepted by {@link MonkeyAroundComponent#registerFunctionPatch}.\n *\n * @typeParam Obj - The object whose keys are filtered.\n */\nexport type FunctionKeys<Obj extends object> = ConditionalKeys<Obj, GenericFunction | undefined> & keyof Obj;\n\n/**\n * Keys of `Obj` whose value is a plain function (a \"real method\"). Function-like objects that carry extra members are\n * excluded \u2014 e.g. a `Debouncer` (which adds `cancel`/`run`) belongs to {@link MonkeyAroundComponent#registerFunctionPatch},\n * not {@link MonkeyAroundComponent#registerMethodPatch}. The check is whether the member has any own keys beyond a bare\n * function's (`Exclude<keyof T, keyof GenericFunction>` is `never`).\n *\n * @typeParam Obj - The object whose keys are filtered.\n */\nexport type MethodKeys<Obj extends object> = MethodKeysMap<Obj>[FunctionKeys<Obj>];\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerFunctionPatch}.\n *\n * @typeParam Obj - The object to patch.\n * @typeParam FunctionName - The function name to patch.\n */\nexport interface MonkeyAroundComponentRegisterFunctionPatchParams<Obj extends object, FunctionName extends FunctionKeys<Obj>> {\n  /**\n   * The function name to patch.\n   */\n  readonly functionName: FunctionName;\n\n  /**\n   * The object to patch.\n   */\n  readonly obj: Obj;\n\n  /**\n   * Patch handler function that takes the original value and returns the patched value.\n   *\n   * @param originalValue - The original value of the function.\n   * @returns The patched value of the function.\n   */\n  patchHandler(originalValue: Obj[FunctionName]): Obj[FunctionName];\n}\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.\n *\n * @typeParam Obj - The object to patch.\n * @typeParam MethodName - The method name to patch.\n */\nexport interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The method name to patch.\n   */\n  readonly methodName: MethodName;\n\n  /**\n   * The object to patch.\n   */\n  readonly obj: Obj;\n\n  /**\n   * The patch handler function.\n   */\n  readonly patchHandler: PatchHandlerFn<Obj, MethodName>;\n\n  /**\n   * An optional token to identify the patch.\n   */\n  readonly patchToken?: symbol;\n\n  /**\n   * An optional post-patch handler function that runs after the patch is applied.\n   */\n  readonly postPatchHandler?: PostPatchHandlerFn<Obj, MethodName>;\n}\n\n/**\n * A patch handler function that intercepts calls to a method on an object.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (\n  params: PatchHandlerParams<Obj, MethodName>\n) => ReturnType<ExtractFunction<Obj, MethodName>>;\n\n/**\n * Parameters passed to a {@link PatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  fallback(this: void): ReturnType<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original arguments of the intercepted call, as a tuple.\n   */\n  readonly originalArgs: Parameters<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<Obj, MethodName>;\n\n  /**\n   * The original method, but with the `this` context already bound to the original object. Call via `originalMethodBound(...originalArgs)`.\n   */\n  readonly originalMethodBound: OmitThisParameter<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original `this` context of the intercepted call.\n   */\n  readonly originalThis: Obj;\n}\n\n/**\n * A post-patch handler function that runs after a patch is applied.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PostPatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (\n  params: PostPatchHandlerParams<Obj, MethodName>\n) => MaybeReturn<ExtractFunction<Obj, MethodName>>;\n\n/**\n * Parameters passed to a {@link PostPatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PostPatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<Obj, MethodName>;\n\n  /**\n   * The patched method.\n   */\n  readonly patchedMethod: ExtractFunction<Obj, MethodName>;\n}\n\ntype ExtractFunction<Obj extends object, MethodName extends MethodKeys<Obj>> = GenericFunction<Parameters<Extract<Obj[MethodName], GenericFunction>>, ReturnType<Extract<Obj[MethodName], GenericFunction>>>;\n\ntype FullFactories<Obj extends object> = {\n  [Key in keyof Obj]: (originalValue: Obj[Key]) => Obj[Key];\n};\n\ntype MethodKeysMap<Obj extends object> = {\n  [Key in FunctionKeys<Obj>]: [Exclude<keyof NonNullable<Obj[Key]>, keyof GenericFunction>] extends [never] ? Key : never;\n};\n\ntype OriginalFactories<Obj extends GenericObject> = Parameters<typeof originalAround<Obj>>[1];\n\ntype Uninstaller = () => void;\n\n/**\n * A component that manages monkey-patches with lifecycle-bound cleanup.\n * All patches registered via this component are automatically uninstalled when the component unloads.\n */\nexport class MonkeyAroundComponent extends ComponentEx {\n  /**\n   * Registers a patch for a single function-like member (a method, or a callable such as a `Debouncer`) using a simplified handler.\n   *\n   * @typeParam Obj - The object to patch.\n   * @typeParam FunctionName - The function name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerFunctionPatch<Obj extends object, const FunctionName extends FunctionKeys<Obj>>(\n    params: MonkeyAroundComponentRegisterFunctionPatchParams<Obj, FunctionName>\n  ): void {\n    this.ensureLoaded();\n\n    const factories: Factories<Obj> = {};\n    factories[params.functionName] = (originalValue: Obj[FunctionName]): Obj[FunctionName] => {\n      return params.patchHandler(originalValue);\n    };\n\n    this.registerPatch(params.obj, factories);\n  }\n\n  /**\n   * Registers a single-method patch using a simplified handler.\n   *\n   * @typeParam Obj - The object to patch.\n   * @typeParam MethodName - The method name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerMethodPatch<Obj extends object, const MethodName extends MethodKeys<Obj>>(\n    params: MonkeyAroundComponentRegisterMethodPatchParams<Obj, MethodName>\n  ): void {\n    this.ensureLoaded();\n\n    if (params.patchToken) {\n      const originalMethod = params.obj[params.methodName] as GenericFunction;\n      getMonkeyAroundPatches().set(originalMethod, params.patchToken);\n    }\n\n    type Fn = ExtractFunction<Obj, MethodName>;\n\n    this.registerFunctionPatch({\n      functionName: params.methodName,\n      obj: params.obj,\n      patchHandler: (originalMethodRaw) => {\n        const originalMethod = originalMethodRaw as Fn;\n        const finalPatchedMethod = params.postPatchHandler?.({\n          originalMethod,\n          patchedMethod\n        }) ?? patchedMethod;\n        return finalPatchedMethod as Obj[MethodName];\n\n        function patchedMethod(this: Obj, ...originalArgs: Parameters<Fn>): ReturnType<Fn> {\n          // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias -- We need to use the `this` context.\n          const originalThis = this;\n          return params.patchHandler({\n            fallback() {\n              return originalMethod.call(originalThis, ...originalArgs);\n            },\n            originalArgs,\n            originalMethod,\n            originalMethodBound: originalMethod.bind(originalThis),\n            originalThis\n          });\n        }\n      }\n    });\n  }\n\n  /**\n   * Registers a patch using raw factories (advanced API).\n   *\n   * @typeParam Obj - The object to patch.\n   * @param obj - The object to patch.\n   * @param factories - The factories to apply to the object.\n   */\n  public registerPatch<Obj extends object>(obj: Obj, factories: Factories<Obj>): void {\n    this.ensureLoaded();\n\n    const uninstaller = around(obj, factories);\n    this.register(uninstaller);\n  }\n}\n\n/**\n * Applies a patch to the object.\n * Better strongly-typed version of `monkey-around`.\n *\n * @typeParam Obj - The object to patch.\n * @param obj - The object to patch.\n * @param factories - The factories to apply to the object.\n * @returns The uninstaller that removes the patch when called.\n */\nexport function around<Obj extends object>(obj: Obj, factories: Factories<Obj>): Uninstaller {\n  return originalAround(obj as GenericObject, factories as OriginalFactories<GenericObject>);\n}\n\n/**\n * Checks if a function has a specific patch token.\n *\n * @param fn - The function to check.\n * @param patchToken - The patch token to check for.\n * @returns Whether the function has the patch token.\n */\nexport function hasPatchToken(fn: GenericFunction, patchToken: symbol): boolean {\n  return getMonkeyAroundPatches().get(fn) === patchToken;\n}\n\nfunction getMonkeyAroundPatches(): WeakMap<GenericFunction, symbol> {\n  return getObsidianDevUtilsState('monkeyAroundPatches', new WeakMap<GenericFunction, symbol>()).value;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,2BAAyC;AAMzC,sCAAyC;AACzC,0BAA4B;AA4KrB,MAAM,8BAA8B,gCAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,sBACL,QACM;AACN,SAAK,aAAa;AAElB,UAAM,YAA4B,CAAC;AACnC,cAAU,OAAO,YAAY,IAAI,CAAC,kBAAwD;AACxF,aAAO,OAAO,aAAa,aAAa;AAAA,IAC1C;AAEA,SAAK,cAAc,OAAO,KAAK,SAAS;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,oBACL,QACM;AACN,SAAK,aAAa;AAElB,QAAI,OAAO,YAAY;AACrB,YAAM,iBAAiB,OAAO,IAAI,OAAO,UAAU;AACnD,6BAAuB,EAAE,IAAI,gBAAgB,OAAO,UAAU;AAAA,IAChE;AAIA,SAAK,sBAAsB;AAAA,MACzB,cAAc,OAAO;AAAA,MACrB,KAAK,OAAO;AAAA,MACZ,cAAc,CAAC,sBAAsB;AACnC,cAAM,iBAAiB;AACvB,cAAM,qBAAqB,OAAO,mBAAmB;AAAA,UACnD;AAAA,UACA;AAAA,QACF,CAAC,KAAK;AACN,eAAO;AAEP,iBAAS,iBAA4B,cAA8C;AAEjF,gBAAM,eAAe;AACrB,iBAAO,OAAO,aAAa;AAAA,YACzB,WAAW;AACT,qBAAO,eAAe,KAAK,cAAc,GAAG,YAAY;AAAA,YAC1D;AAAA,YACA;AAAA,YACA;AAAA,YACA,qBAAqB,eAAe,KAAK,YAAY;AAAA,YACrD;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,cAAkC,KAAU,WAAiC;AAClF,SAAK,aAAa;AAElB,UAAM,cAAc,OAAO,KAAK,SAAS;AACzC,SAAK,SAAS,WAAW;AAAA,EAC3B;AACF;AAWO,SAAS,OAA2B,KAAU,WAAwC;AAC3F,aAAO,qBAAAA,QAAe,KAAsB,SAA6C;AAC3F;AASO,SAAS,cAAc,IAAqB,YAA6B;AAC9E,SAAO,uBAAuB,EAAE,IAAI,EAAE,MAAM;AAC9C;AAEA,SAAS,yBAA2D;AAClE,aAAO,0DAAyB,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AACjG;",
  "names": ["originalAround"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/obsidian/components/monkey-around-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Improved type-safe wrapper of {@link https://www.npmjs.com/package/monkey-around} library.\n */\n\nimport type { ConditionalKeys } from 'type-fest';\n\nimport { around as originalAround } from 'monkey-around';\n\nimport type { GenericFunction } from '../../function.ts';\nimport type { GenericObject } from '../../type-guards.ts';\nimport type { MaybeReturn } from '../../type.ts';\n\nimport { getObsidianDevUtilsState } from '../../obsidian-dev-utils-state.ts';\nimport { ComponentEx } from './component-ex.ts';\n\n/**\n * A type of the factories to apply to the object.\n *\n * @typeParam Obj - The object to patch.\n */\nexport type Factories<Obj extends object> = Partial<FullFactories<Obj>>;\n\n/**\n * Keys of `Obj` whose value is callable \u2014 a method, or a function-like object such as a `Debouncer`. These are the members\n * accepted by {@link MonkeyAroundComponent#registerFunctionPatch}.\n *\n * @typeParam Obj - The object whose keys are filtered.\n */\nexport type FunctionKeys<Obj extends object> = ConditionalKeys<Obj, GenericFunction | undefined> & keyof Obj;\n\n/**\n * Keys of `Obj` whose value is a plain function (a \"real method\"). Function-like objects that carry extra members are\n * excluded \u2014 e.g. a `Debouncer` (which adds `cancel`/`run`) belongs to {@link MonkeyAroundComponent#registerFunctionPatch},\n * not {@link MonkeyAroundComponent#registerMethodPatch}. The check is whether the member has any own keys beyond a bare\n * function's (`Exclude<keyof T, keyof GenericFunction>` is `never`).\n *\n * @typeParam Obj - The object whose keys are filtered.\n */\nexport type MethodKeys<Obj extends object> = MethodKeysMap<Obj>[FunctionKeys<Obj>];\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerFunctionPatch}.\n *\n * @typeParam Obj - The object to patch.\n * @typeParam FunctionName - The function name to patch.\n */\nexport interface MonkeyAroundComponentRegisterFunctionPatchParams<Obj extends object, FunctionName extends FunctionKeys<Obj>> {\n  /**\n   * The function name to patch.\n   */\n  readonly functionName: FunctionName;\n\n  /**\n   * The object to patch.\n   */\n  readonly obj: Obj;\n\n  /**\n   * When `true`, the patch uninstalls itself the first time the patched function is invoked (by\n   * unloading this component), restoring the original \u2014 so the interception happens exactly once.\n   * Intended for a component dedicated to this single patch. Existing callers that omit it are\n   * unaffected.\n   *\n   * @default `false`\n   */\n  readonly once?: boolean;\n\n  /**\n   * Patch handler function that takes the original value and returns the patched value.\n   *\n   * @param originalValue - The original value of the function.\n   * @returns The patched value of the function.\n   */\n  patchHandler(originalValue: Obj[FunctionName]): Obj[FunctionName];\n}\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.\n *\n * @typeParam Obj - The object to patch.\n * @typeParam MethodName - The method name to patch.\n */\nexport interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The method name to patch.\n   */\n  readonly methodName: MethodName;\n\n  /**\n   * The object to patch.\n   */\n  readonly obj: Obj;\n\n  /**\n   * When `true`, the patch uninstalls itself the first time the patched method is invoked, restoring\n   * the original \u2014 so the interception happens exactly once. Existing callers that omit it are\n   * unaffected.\n   *\n   * @default `false`\n   */\n  readonly once?: boolean;\n\n  /**\n   * The patch handler function.\n   */\n  readonly patchHandler: PatchHandlerFn<Obj, MethodName>;\n\n  /**\n   * An optional token to identify the patch.\n   */\n  readonly patchToken?: symbol;\n\n  /**\n   * An optional post-patch handler function that runs after the patch is applied.\n   */\n  readonly postPatchHandler?: PostPatchHandlerFn<Obj, MethodName>;\n}\n\n/**\n * A patch handler function that intercepts calls to a method on an object.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (\n  params: PatchHandlerParams<Obj, MethodName>\n) => ReturnType<ExtractFunction<Obj, MethodName>>;\n\n/**\n * Parameters passed to a {@link PatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  fallback(this: void): ReturnType<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original arguments of the intercepted call, as a tuple.\n   */\n  readonly originalArgs: Parameters<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<Obj, MethodName>;\n\n  /**\n   * The original method, but with the `this` context already bound to the original object. Call via `originalMethodBound(...originalArgs)`.\n   */\n  readonly originalMethodBound: OmitThisParameter<ExtractFunction<Obj, MethodName>>;\n\n  /**\n   * The original `this` context of the intercepted call.\n   */\n  readonly originalThis: Obj;\n}\n\n/**\n * A post-patch handler function that runs after a patch is applied.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PostPatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (\n  params: PostPatchHandlerParams<Obj, MethodName>\n) => MaybeReturn<ExtractFunction<Obj, MethodName>>;\n\n/**\n * Parameters passed to a {@link PostPatchHandlerFn} callback.\n *\n * @typeParam Obj - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PostPatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<Obj, MethodName>;\n\n  /**\n   * The patched method.\n   */\n  readonly patchedMethod: ExtractFunction<Obj, MethodName>;\n}\n\ntype ExtractFunction<Obj extends object, MethodName extends MethodKeys<Obj>> = GenericFunction<Parameters<Extract<Obj[MethodName], GenericFunction>>, ReturnType<Extract<Obj[MethodName], GenericFunction>>>;\n\ntype FullFactories<Obj extends object> = {\n  [Key in keyof Obj]: (originalValue: Obj[Key]) => Obj[Key];\n};\n\ntype MethodKeysMap<Obj extends object> = {\n  [Key in FunctionKeys<Obj>]: [Exclude<keyof NonNullable<Obj[Key]>, keyof GenericFunction>] extends [never] ? Key : never;\n};\n\ntype OriginalFactories<Obj extends GenericObject> = Parameters<typeof originalAround<Obj>>[1];\n\ntype Uninstaller = () => void;\n\n/**\n * A component that manages monkey-patches with lifecycle-bound cleanup.\n * All patches registered via this component are automatically uninstalled when the component unloads.\n */\nexport class MonkeyAroundComponent extends ComponentEx {\n  /**\n   * Registers a patch for a single function-like member (a method, or a callable such as a `Debouncer`) using a simplified handler.\n   *\n   * @typeParam Obj - The object to patch.\n   * @typeParam FunctionName - The function name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerFunctionPatch<Obj extends object, const FunctionName extends FunctionKeys<Obj>>(\n    params: MonkeyAroundComponentRegisterFunctionPatchParams<Obj, FunctionName>\n  ): void {\n    this.ensureLoaded();\n\n    const factories: Factories<Obj> = {};\n    factories[params.functionName] = (originalValue: Obj[FunctionName]): Obj[FunctionName] => {\n      const patchedValue = params.patchHandler(originalValue);\n      if (!params.once) {\n        return patchedValue;\n      }\n\n      // A `once` patch unloads this component after the first invocation \u2014 running the registered\n      // Uninstaller and restoring the original. `unloadComponent` is an arrow so it captures the\n      // Component `this`; the nested `oncePatchedValue` must be a function to receive the call-time\n      // `this`. Own members (e.g. a `Debouncer`'s `cancel`/`run`) are copied onto it so function-like\n      // Values keep working.\n      const unloadComponent = (): void => {\n        this.unload();\n      };\n      function oncePatchedValue(this: unknown, ...args: unknown[]): unknown {\n        try {\n          return Reflect.apply(patchedValue, this, args);\n        } finally {\n          unloadComponent();\n        }\n      }\n      return Object.assign(oncePatchedValue, patchedValue) as Obj[FunctionName];\n    };\n\n    this.registerPatch(params.obj, factories);\n  }\n\n  /**\n   * Registers a single-method patch using a simplified handler.\n   *\n   * @typeParam Obj - The object to patch.\n   * @typeParam MethodName - The method name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerMethodPatch<Obj extends object, const MethodName extends MethodKeys<Obj>>(\n    params: MonkeyAroundComponentRegisterMethodPatchParams<Obj, MethodName>\n  ): void {\n    this.ensureLoaded();\n\n    if (params.patchToken) {\n      const originalMethod = params.obj[params.methodName] as GenericFunction;\n      getMonkeyAroundPatches().set(originalMethod, params.patchToken);\n    }\n\n    type Fn = ExtractFunction<Obj, MethodName>;\n\n    this.registerFunctionPatch({\n      functionName: params.methodName,\n      obj: params.obj,\n      once: params.once ?? false,\n      patchHandler: (originalMethodRaw) => {\n        const originalMethod = originalMethodRaw as Fn;\n        const finalPatchedMethod = params.postPatchHandler?.({\n          originalMethod,\n          patchedMethod\n        }) ?? patchedMethod;\n        return finalPatchedMethod as Obj[MethodName];\n\n        function patchedMethod(this: Obj, ...originalArgs: Parameters<Fn>): ReturnType<Fn> {\n          // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias -- We need to use the `this` context.\n          const originalThis = this;\n          return params.patchHandler({\n            fallback() {\n              return originalMethod.call(originalThis, ...originalArgs);\n            },\n            originalArgs,\n            originalMethod,\n            originalMethodBound: originalMethod.bind(originalThis),\n            originalThis\n          });\n        }\n      }\n    });\n  }\n\n  /**\n   * Registers a patch using raw factories (advanced API).\n   *\n   * @typeParam Obj - The object to patch.\n   * @param obj - The object to patch.\n   * @param factories - The factories to apply to the object.\n   */\n  public registerPatch<Obj extends object>(obj: Obj, factories: Factories<Obj>): void {\n    this.ensureLoaded();\n\n    const uninstaller = around(obj, factories);\n    this.register(uninstaller);\n  }\n}\n\n/**\n * Applies a patch to the object.\n * Better strongly-typed version of `monkey-around`.\n *\n * @typeParam Obj - The object to patch.\n * @param obj - The object to patch.\n * @param factories - The factories to apply to the object.\n * @returns The uninstaller that removes the patch when called.\n */\nexport function around<Obj extends object>(obj: Obj, factories: Factories<Obj>): Uninstaller {\n  return originalAround(obj as GenericObject, factories as OriginalFactories<GenericObject>);\n}\n\n/**\n * Checks if a function has a specific patch token.\n *\n * @param fn - The function to check.\n * @param patchToken - The patch token to check for.\n * @returns Whether the function has the patch token.\n */\nexport function hasPatchToken(fn: GenericFunction, patchToken: symbol): boolean {\n  return getMonkeyAroundPatches().get(fn) === patchToken;\n}\n\nfunction getMonkeyAroundPatches(): WeakMap<GenericFunction, symbol> {\n  return getObsidianDevUtilsState('monkeyAroundPatches', new WeakMap<GenericFunction, symbol>()).value;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,2BAAyC;AAMzC,sCAAyC;AACzC,0BAA4B;AA+LrB,MAAM,8BAA8B,gCAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,sBACL,QACM;AACN,SAAK,aAAa;AAElB,UAAM,YAA4B,CAAC;AACnC,cAAU,OAAO,YAAY,IAAI,CAAC,kBAAwD;AACxF,YAAM,eAAe,OAAO,aAAa,aAAa;AACtD,UAAI,CAAC,OAAO,MAAM;AAChB,eAAO;AAAA,MACT;AAOA,YAAM,kBAAkB,MAAY;AAClC,aAAK,OAAO;AAAA,MACd;AACA,eAAS,oBAAmC,MAA0B;AACpE,YAAI;AACF,iBAAO,QAAQ,MAAM,cAAc,MAAM,IAAI;AAAA,QAC/C,UAAE;AACA,0BAAgB;AAAA,QAClB;AAAA,MACF;AACA,aAAO,OAAO,OAAO,kBAAkB,YAAY;AAAA,IACrD;AAEA,SAAK,cAAc,OAAO,KAAK,SAAS;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,oBACL,QACM;AACN,SAAK,aAAa;AAElB,QAAI,OAAO,YAAY;AACrB,YAAM,iBAAiB,OAAO,IAAI,OAAO,UAAU;AACnD,6BAAuB,EAAE,IAAI,gBAAgB,OAAO,UAAU;AAAA,IAChE;AAIA,SAAK,sBAAsB;AAAA,MACzB,cAAc,OAAO;AAAA,MACrB,KAAK,OAAO;AAAA,MACZ,MAAM,OAAO,QAAQ;AAAA,MACrB,cAAc,CAAC,sBAAsB;AACnC,cAAM,iBAAiB;AACvB,cAAM,qBAAqB,OAAO,mBAAmB;AAAA,UACnD;AAAA,UACA;AAAA,QACF,CAAC,KAAK;AACN,eAAO;AAEP,iBAAS,iBAA4B,cAA8C;AAEjF,gBAAM,eAAe;AACrB,iBAAO,OAAO,aAAa;AAAA,YACzB,WAAW;AACT,qBAAO,eAAe,KAAK,cAAc,GAAG,YAAY;AAAA,YAC1D;AAAA,YACA;AAAA,YACA;AAAA,YACA,qBAAqB,eAAe,KAAK,YAAY;AAAA,YACrD;AAAA,UACF,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,cAAkC,KAAU,WAAiC;AAClF,SAAK,aAAa;AAElB,UAAM,cAAc,OAAO,KAAK,SAAS;AACzC,SAAK,SAAS,WAAW;AAAA,EAC3B;AACF;AAWO,SAAS,OAA2B,KAAU,WAAwC;AAC3F,aAAO,qBAAAA,QAAe,KAAsB,SAA6C;AAC3F;AASO,SAAS,cAAc,IAAqB,YAA6B;AAC9E,SAAO,uBAAuB,EAAE,IAAI,EAAE,MAAM;AAC9C;AAEA,SAAS,yBAA2D;AAClE,aAAO,0DAAyB,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AACjG;",
  "names": ["originalAround"]
}


package/dist/lib/cjs/obsidian/components/monkey-around-component.d.cts

@@ -45,6 +45,15 @@ export interface MonkeyAroundComponentRegisterFunctionPatchParams<Obj extends ob
      * The object to patch.
      */
     readonly obj: Obj;
+    /**
+     * When `true`, the patch uninstalls itself the first time the patched function is invoked (by
+     * unloading this component), restoring the original — so the interception happens exactly once.
+     * Intended for a component dedicated to this single patch. Existing callers that omit it are
+     * unaffected.
+     *
+     * @default `false`
+     */
+    readonly once?: boolean;
     /**
      * Patch handler function that takes the original value and returns the patched value.
      *
@@ -68,6 +77,14 @@ export interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends obje
      * The object to patch.
      */
     readonly obj: Obj;
+    /**
+     * When `true`, the patch uninstalls itself the first time the patched method is invoked, restoring
+     * the original — so the interception happens exactly once. Existing callers that omit it are
+     * unaffected.
+     *
+     * @default `false`
+     */
+    readonly once?: boolean;
     /**
      * The patch handler function.
      */

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

@@ -132,28 +132,40 @@ var import_obsidian = require('obsidian');
 var import_async = require('../../async.cjs');
 var import_object_utils = require('../../object-utils.cjs');
 var import_obsidian_dev_utils_state = require('../../obsidian-dev-utils-state.cjs');
+var import_type_guards = require('../../type-guards.cjs');
 var import_value_provider = require('../../value-provider.cjs');
 var import_css_class = require('../css-class.cjs');
 var import_i18n = require('../i18n/i18n.cjs');
+var import_confirm = require('../modals/confirm.cjs');
 var import_plugin_context = require('../plugin/plugin-context.cjs');
 var import_component_ex = require('./component-ex.cjs');
+var import_monkey_around_component = require('./monkey-around-component.cjs');
 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 import_component_ex.ComponentEx {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * The plugin name (shown as prefix in notices).
+   */
+  pluginName;
+  notice = null;
+  pendingTimerCancellations = /* @__PURE__ */ new Set();
+  standaloneNotices = /* @__PURE__ */ new Set();
   /**
    * Creates a new plugin notice component.
    *
-   * @param pluginName - The plugin name (shown as prefix in notices).
+   * @param params - The constructor parameters.
    */
-  constructor(pluginName) {
+  constructor(params) {
     super();
-    this.pluginName = pluginName;
+    this.app = params.app;
+    this.pluginName = params.pluginName;
   }
-  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.
    */
@@ -173,6 +185,10 @@ class PluginNoticeComponent extends import_component_ex.ComponentEx {
     if (this.getPermanentNotice() !== this.notice) {
       this.notice?.hide();
     }
+    for (const standaloneNotice of this.standaloneNotices) {
+      standaloneNotice.hide();
+    }
+    this.standaloneNotices.clear();
   }
   /**
    * Displays a notice message to the user.
@@ -183,7 +199,23 @@ class PluginNoticeComponent extends import_component_ex.ComponentEx {
    */
   showNotice(message, options) {
     const isPermanent = options?.isPermanent ?? false;
-    return this.showNoticeWithDuration(message, isPermanent ? PERMANENT_NOTICE_DURATION_IN_MILLISECONDS : void 0, isPermanent);
+    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.");
+    }
+    if (options?.isReusable === false && isPermanent) {
+      throw new Error("A permanent notice must be reusable.");
+    }
+    const durationInMilliseconds = isPermanent || requiresCloseConfirmation ? PERMANENT_NOTICE_DURATION_IN_MILLISECONDS : null;
+    return this.showNoticeWithDuration({
+      durationInMilliseconds,
+      isReusable,
+      message,
+      onHide: options?.onHide,
+      requiresCloseConfirmation,
+      shouldRegisterAsPermanent: isPermanent
+    });
   }
   /**
    * Shows a notice describing a long-running operation, but only once the operation has run for longer
@@ -227,14 +259,21 @@ class PluginNoticeComponent extends import_component_ex.ComponentEx {
         if (isDisposed) {
           return;
         }
-        shownNotice = this.showNoticeWithDuration(buildDelayedMessage(resolvedContent), PERMANENT_NOTICE_DURATION_IN_MILLISECONDS, false);
+        shownNotice = this.showNoticeWithDuration({
+          durationInMilliseconds: PERMANENT_NOTICE_DURATION_IN_MILLISECONDS,
+          isReusable: true,
+          message: buildDelayedMessage(resolvedContent),
+          onHide: void 0,
+          requiresCloseConfirmation: false,
+          shouldRegisterAsPermanent: false
+        });
       });
     }, params.delayInMilliseconds ?? DEFAULT_DELAY_BEFORE_SHOW_IN_MILLISECONDS);
     this.pendingTimerCancellations.add(cancelPendingTimer);
     return {
       setContent: (content) => {
         currentContent = content;
-        shownNotice?.setMessage(this.buildNoticeContent(buildDelayedMessage(content)));
+        shownNotice?.setMessage(this.buildNoticeContent({ message: buildDelayedMessage(content) }));
       },
       [Symbol.dispose]: () => {
         isDisposed = true;
@@ -246,6 +285,35 @@ class PluginNoticeComponent extends import_component_ex.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.
+   *
+   * @param contentEl - The notice content wrapper to append the button to.
+   * @param getNotice - Resolves the notice to hide when the close is confirmed.
+   */
+  appendCloseButton(contentEl, getNotice) {
+    const closeButtonEl = contentEl.createEl("button", {
+      attr: { "aria-label": (0, import_i18n.t)(($) => $.obsidianDevUtils.notices.closeAriaLabel) }
+    });
+    (0, import_plugin_context.addPluginCssClasses)(closeButtonEl, import_css_class.CssClass.PluginNoticeCloseButton);
+    (0, import_obsidian.setIcon)(closeButtonEl, "x");
+    closeButtonEl.addEventListener("click", (evt) => {
+      evt.stopPropagation();
+      (0, import_async.invokeAsyncSafely)(async () => {
+        const isConfirmed = await (0, import_confirm.confirm)({
+          app: this.app,
+          message: (0, import_i18n.t)(($) => $.obsidianDevUtils.notices.closeConfirmMessage)
+        });
+        if (!isConfirmed) {
+          return;
+        }
+        const notice = (0, import_type_guards.ensureNonNullable)(getNotice());
+        notice.hide();
+        this.standaloneNotices.delete(notice);
+      });
+    });
+  }
   /**
    * Builds the message for a delayed notice: the resolved content, optionally followed by a Cancel
    * button that aborts the provided controller when clicked.
@@ -278,19 +346,27 @@ class PluginNoticeComponent extends import_component_ex.ComponentEx {
    * 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.
+   * @param params - The parameters.
    * @returns A {@link DocumentFragment} holding the wrapped, prefixed notice content.
    */
-  buildNoticeContent(message) {
+  buildNoticeContent(params) {
+    const { getNotice, message, requiresCloseConfirmation = false } = params;
     const fragment = createFragment();
     const contentEl = fragment.createDiv();
     (0, import_plugin_context.addPluginCssClasses)(contentEl, import_css_class.CssClass.PluginNoticeContent);
     contentEl.appendChild(this.buildPrefixedMessage(message));
     contentEl.addEventListener("click", (evt) => {
+      if (requiresCloseConfirmation) {
+        evt.stopPropagation();
+        return;
+      }
       if (evt.target instanceof Element && evt.target.closest(INTERACTIVE_ELEMENT_SELECTOR)) {
         evt.stopPropagation();
       }
     });
+    if (requiresCloseConfirmation) {
+      this.appendCloseButton(contentEl, (0, import_type_guards.ensureNonNullable)(getNotice));
+    }
     return fragment;
   }
   /**
@@ -322,6 +398,27 @@ class PluginNoticeComponent extends import_component_ex.ComponentEx {
   getPermanentNotices() {
     return (0, import_obsidian_dev_utils_state.getObsidianDevUtilsState)(PERMANENT_NOTICES_STATE_KEY, /* @__PURE__ */ new Map()).value;
   }
+  /**
+   * Makes a notice hard to close: marks its outer element (so the CSS neutralizes its padding) and
+   * installs a capture-phase click guard that stops every click except on the close button from
+   * reaching Obsidian's own dismiss handler.
+   *
+   * @param notice - The notice to guard.
+   * @param requiresCloseConfirmation - Whether the notice requires close confirmation; when `false`,
+   * nothing is installed.
+   */
+  installCloseConfirmationGuards(notice, requiresCloseConfirmation) {
+    if (!requiresCloseConfirmation) {
+      return;
+    }
+    (0, import_plugin_context.addPluginCssClasses)(notice.containerEl, import_css_class.CssClass.PluginNoticeRequiresConfirmation);
+    notice.containerEl.addEventListener("click", (evt) => {
+      if (evt.target instanceof Element && evt.target.closest(`.${import_css_class.CssClass.PluginNoticeCloseButton}`)) {
+        return;
+      }
+      evt.stopPropagation();
+    }, { capture: true });
+  }
   setPermanentNotice(notice) {
     const map = this.getPermanentNotices();
     if (notice) {
@@ -331,28 +428,70 @@ class PluginNoticeComponent extends import_component_ex.ComponentEx {
     }
   }
   /**
-   * Shows a notice with the given duration, replacing the current notice, and optionally registers it
-   * as this plugin's permanent notice.
+   * Shows a notice with the given duration. A reusable notice replaces the current reusable notice (and
+   * is optionally registered as this plugin's permanent notice); a standalone notice is tracked
+   * separately, leaving the reusable slot untouched.
    *
-   * @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.
+   * @param params - The parameters.
    * @returns The created notice.
    */
-  showNoticeWithDuration(message, durationInMilliseconds, shouldRegisterAsPermanent) {
+  showNoticeWithDuration(params) {
+    const { durationInMilliseconds, isReusable, message, onHide, requiresCloseConfirmation, shouldRegisterAsPermanent } = params;
+    const noticeDurationInMilliseconds = durationInMilliseconds ?? void 0;
+    let builtNotice = null;
+    const content = this.buildNoticeContent((0, import_object_utils.normalizeOptionalProperties)({
+      getNotice: requiresCloseConfirmation ? () => builtNotice : void 0,
+      message,
+      requiresCloseConfirmation
+    }));
+    if (!isReusable) {
+      builtNotice = new import_obsidian.Notice(content, noticeDurationInMilliseconds);
+      this.installCloseConfirmationGuards(builtNotice, requiresCloseConfirmation);
+      this.wireOnHide(builtNotice, onHide);
+      this.standaloneNotices.add(builtNotice);
+      return builtNotice;
+    }
     this.notice?.hide();
-    const content = this.buildNoticeContent(message);
-    this.notice = new import_obsidian.Notice(content, durationInMilliseconds);
+    builtNotice = new import_obsidian.Notice(content, noticeDurationInMilliseconds);
+    this.notice = builtNotice;
+    this.installCloseConfirmationGuards(builtNotice, requiresCloseConfirmation);
+    this.wireOnHide(builtNotice, onHide);
     if (shouldRegisterAsPermanent) {
-      this.setPermanentNotice(this.notice);
+      this.setPermanentNotice(builtNotice);
     } else {
       this.setPermanentNotice(null);
     }
-    return this.notice;
+    return builtNotice;
+  }
+  /**
+   * Wraps a notice's `hide` so the given callback runs the first time the notice is hidden — by the
+   * user, by a replacing notice, by its duration elapsing, or on unload. Does nothing when no callback
+   * is given.
+   *
+   * @param notice - The notice whose `hide` to wrap.
+   * @param onHide - The callback to invoke on the first hide, or `undefined` to skip wrapping.
+   */
+  wireOnHide(notice, onHide) {
+    if (!onHide) {
+      return;
+    }
+    const patchComponent = new import_monkey_around_component.MonkeyAroundComponent();
+    patchComponent.load();
+    patchComponent.registerMethodPatch({
+      methodName: "hide",
+      obj: notice,
+      once: true,
+      patchHandler: ({ fallback }) => {
+        fallback();
+        (0, import_async.invokeAsyncSafely)(async () => {
+          await onHide();
+        });
+      }
+    });
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   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 {\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(protected 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": []
}

+//# 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 the close button from\n   * reaching Obsidian's own dismiss handler.\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 the close button \u2014 from reaching Obsidian's dismiss\n    // Handler. Registered in the capture phase on the outermost element so it always runs first.\n    notice.containerEl.addEventListener('click', (evt) => {\n      if (evt.target instanceof Element && evt.target.closest(`.${CssClass.PluginNoticeCloseButton}`)) {\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": []
}
