obsidian-dev-utils 88.7.0 → 89.0.0

package/dist/lib/esm/obsidian/components/index.mjs

@@ -34,6 +34,7 @@ import * as generate_markdown_link_default_params_component from "./generate-mar
 import * as layout_ready_component from "./layout-ready-component.mjs";
 import * as menu_event_registrar_component from "./menu-event-registrar-component.mjs";
 import * as monkey_around_component from "./monkey-around-component.mjs";
+import * as notebook_navigator_menu_event_registrar_component from "./notebook-navigator-menu-event-registrar-component.mjs";
 import * as plugin_context_component from "./plugin-context-component.mjs";
 import * as plugin_notice_component from "./plugin-notice-component.mjs";
 import * as plugin_settings_component from "./plugin-settings-component.mjs";
@@ -56,6 +57,7 @@ export {
   layout_ready_component as "layout-ready-component",
   menu_event_registrar_component as "menu-event-registrar-component",
   monkey_around_component as "monkey-around-component",
+  notebook_navigator_menu_event_registrar_component as "notebook-navigator-menu-event-registrar-component",
   plugin_context_component as "plugin-context-component",
   plugin_notice_component as "plugin-notice-component",
   plugin_settings_component as "plugin-settings-component",
@@ -65,4 +67,4 @@ export {
   rename_delete_handler_component as "rename-delete-handler-component",
   syntax_highlighting_component as "syntax-highlighting-component"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/components/menu-event-registrar-component.mjs

@@ -21,7 +21,7 @@ if you want to view the source, please visit the github repository of this plugi
   globalThis.process = browserProcess;
 })();
 
-import { EventRefDisposable } from "../events.mjs";
+import { EventRefDisposable as EventReferenceDisposable } from "../events.mjs";
 import { ComponentEx } from "./component-ex.mjs";
 class MenuEventRegistrarComponent extends ComponentEx {
   /**
@@ -42,7 +42,7 @@ class MenuEventRegistrarComponent extends ComponentEx {
    */
   registerEditorMenuEventHandler(handler) {
     this.ensureLoaded();
-    return this.registerDisposable(new EventRefDisposable(this.app.workspace.on("editor-menu", handler)));
+    return this.registerDisposable(new EventReferenceDisposable(this.app.workspace.on("editor-menu", handler)));
   }
   /**
    * Registers a handler for the single-file context menu event.
@@ -52,7 +52,7 @@ class MenuEventRegistrarComponent extends ComponentEx {
    */
   registerFileMenuEventHandler(handler) {
     this.ensureLoaded();
-    return this.registerDisposable(new EventRefDisposable(this.app.workspace.on("file-menu", handler)));
+    return this.registerDisposable(new EventReferenceDisposable(this.app.workspace.on("file-menu", handler)));
   }
   /**
    * Registers a handler for the multi-file context menu event.
@@ -62,10 +62,10 @@ class MenuEventRegistrarComponent extends ComponentEx {
    */
   registerFilesMenuEventHandler(handler) {
     this.ensureLoaded();
-    return this.registerDisposable(new EventRefDisposable(this.app.workspace.on("files-menu", handler)));
+    return this.registerDisposable(new EventReferenceDisposable(this.app.workspace.on("files-menu", handler)));
   }
 }
 export {
   MenuEventRegistrarComponent
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL29ic2lkaWFuL2NvbXBvbmVudHMvbWVudS1ldmVudC1yZWdpc3RyYXItY29tcG9uZW50LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogUmVnaXN0ZXJzIG1lbnUgZXZlbnQgaGFuZGxlcnMgd2l0aCBPYnNpZGlhbidzIHdvcmtzcGFjZSwgc3VwcG9ydGluZyBlZGl0b3IsIGZpbGUsIGFuZCBtdWx0aS1maWxlIGNvbnRleHQgbWVudXMuXG4gKi9cblxuaW1wb3J0IHR5cGUgeyBBcHAgfSBmcm9tICdvYnNpZGlhbic7XG5cbmltcG9ydCB0eXBlIHsgRGlzcG9zYWJsZUV4IH0gZnJvbSAnLi4vLi4vZGlzcG9zYWJsZS50cyc7XG5pbXBvcnQgdHlwZSB7XG4gIEVkaXRvck1lbnVFdmVudEhhbmRsZXIsXG4gIEZpbGVNZW51RXZlbnRIYW5kbGVyLFxuICBGaWxlc01lbnVFdmVudEhhbmRsZXIsXG4gIE1lbnVFdmVudFJlZ2lzdHJhclxufSBmcm9tICcuLi9tZW51LWV2ZW50LXJlZ2lzdHJhci50cyc7XG5cbmltcG9ydCB7IEV2ZW50UmVmRGlzcG9zYWJsZSB9IGZyb20gJy4uL2V2ZW50cy50cyc7XG5pbXBvcnQgeyBDb21wb25lbnRFeCB9IGZyb20gJy4vY29tcG9uZW50LWV4LnRzJztcblxuLyoqXG4gKiB7QGxpbmsgTWVudUV2ZW50UmVnaXN0cmFyfSBiYWNrZWQgYnkgT2JzaWRpYW4ncyB7QGxpbmsgQXBwfSB3b3Jrc3BhY2UgZXZlbnRzLlxuICpcbiAqIEV2ZW50IGhhbmRsZXJzIGFyZSByZWdpc3RlcmVkIHdpdGggdGhlIHByb3ZpZGVkIHtAbGluayBDb21wb25lbnR9IGZvciBsaWZlY3ljbGUgbWFuYWdlbWVudC5cbiAqL1xuZXhwb3J0IGNsYXNzIE1lbnVFdmVudFJlZ2lzdHJhckNvbXBvbmVudCBleHRlbmRzIENvbXBvbmVudEV4IGltcGxlbWVudHMgTWVudUV2ZW50UmVnaXN0cmFyIHtcbiAgLyoqXG4gICAqIENyZWF0ZXMgYSBuZXcgYXBwLWJhY2tlZCBtZW51IGV2ZW50IHJlZ2lzdHJhci5cbiAgICpcbiAgICogQHBhcmFtIGFwcCAtIFRoZSBPYnNpZGlhbiBhcHAgaW5zdGFuY2UuXG4gICAqL1xuICBwdWJsaWMgY29uc3RydWN0b3IocHJvdGVjdGVkIHJlYWRvbmx5IGFwcDogQXBwKSB7XG4gICAgc3VwZXIoKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZWdpc3RlcnMgYSBoYW5kbGVyIGZvciB0aGUgZWRpdG9yIGNvbnRleHQgbWVudSBldmVudC5cbiAgICpcbiAgICogQHBhcmFtIGhhbmRsZXIgLSBUaGUgaGFuZGxlciB0byByZWdpc3Rlci5cbiAgICogQHJldHVybnMgQSB7QGxpbmsgRGlzcG9zYWJsZUV4fSB0aGF0IHVucmVnaXN0ZXJzIHRoZSBoYW5kbGVyIHdoZW4gZGlzcG9zZWQgKG9yIG9uIGNvbXBvbmVudCB1bmxvYWQpLlxuICAgKi9cbiAgcHVibGljIHJlZ2lzdGVyRWRpdG9yTWVudUV2ZW50SGFuZGxlcihoYW5kbGVyOiBFZGl0b3JNZW51RXZlbnRIYW5kbGVyKTogRGlzcG9zYWJsZUV4IHtcbiAgICB0aGlzLmVuc3VyZUxvYWRlZCgpO1xuICAgIHJldHVybiB0aGlzLnJlZ2lzdGVyRGlzcG9zYWJsZShuZXcgRXZlbnRSZWZEaXNwb3NhYmxlKHRoaXMuYXBwLndvcmtzcGFjZS5vbignZWRpdG9yLW1lbnUnLCBoYW5kbGVyKSkpO1xuICB9XG5cbiAgLyoqXG4gICAqIFJlZ2lzdGVycyBhIGhhbmRsZXIgZm9yIHRoZSBzaW5nbGUtZmlsZSBjb250ZXh0IG1lbnUgZXZlbnQuXG4gICAqXG4gICAqIEBwYXJhbSBoYW5kbGVyIC0gVGhlIGhhbmRsZXIgdG8gcmVnaXN0ZXIuXG4gICAqIEByZXR1cm5zIEEge0BsaW5rIERpc3Bvc2FibGVFeH0gdGhhdCB1bnJlZ2lzdGVycyB0aGUgaGFuZGxlciB3aGVuIGRpc3Bvc2VkIChvciBvbiBjb21wb25lbnQgdW5sb2FkKS5cbiAgICovXG4gIHB1YmxpYyByZWdpc3RlckZpbGVNZW51RXZlbnRIYW5kbGVyKGhhbmRsZXI6IEZpbGVNZW51RXZlbnRIYW5kbGVyKTogRGlzcG9zYWJsZUV4IHtcbiAgICB0aGlzLmVuc3VyZUxvYWRlZCgpO1xuICAgIHJldHVybiB0aGlzLnJlZ2lzdGVyRGlzcG9zYWJsZShuZXcgRXZlbnRSZWZEaXNwb3NhYmxlKHRoaXMuYXBwLndvcmtzcGFjZS5vbignZmlsZS1tZW51JywgaGFuZGxlcikpKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBSZWdpc3RlcnMgYSBoYW5kbGVyIGZvciB0aGUgbXVsdGktZmlsZSBjb250ZXh0IG1lbnUgZXZlbnQuXG4gICAqXG4gICAqIEBwYXJhbSBoYW5kbGVyIC0gVGhlIGhhbmRsZXIgdG8gcmVnaXN0ZXIuXG4gICAqIEByZXR1cm5zIEEge0BsaW5rIERpc3Bvc2FibGVFeH0gdGhhdCB1bnJlZ2lzdGVycyB0aGUgaGFuZGxlciB3aGVuIGRpc3Bvc2VkIChvciBvbiBjb21wb25lbnQgdW5sb2FkKS5cbiAgICovXG4gIHB1YmxpYyByZWdpc3RlckZpbGVzTWVudUV2ZW50SGFuZGxlcihoYW5kbGVyOiBGaWxlc01lbnVFdmVudEhhbmRsZXIpOiBEaXNwb3NhYmxlRXgge1xuICAgIHRoaXMuZW5zdXJlTG9hZGVkKCk7XG4gICAgcmV0dXJuIHRoaXMucmVnaXN0ZXJEaXNwb3NhYmxlKG5ldyBFdmVudFJlZkRpc3Bvc2FibGUodGhpcy5hcHAud29ya3NwYWNlLm9uKCdmaWxlcy1tZW51JywgaGFuZGxlcikpKTtcbiAgfVxufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFnQkEsU0FBUywwQkFBMEI7QUFDbkMsU0FBUyxtQkFBbUI7QUFPckIsTUFBTSxvQ0FBb0MsWUFBMEM7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFNbEYsWUFBK0IsS0FBVTtBQUM5QyxVQUFNO0FBRDhCO0FBQUEsRUFFdEM7QUFBQSxFQUZzQztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBVS9CLCtCQUErQixTQUErQztBQUNuRixTQUFLLGFBQWE7QUFDbEIsV0FBTyxLQUFLLG1CQUFtQixJQUFJLG1CQUFtQixLQUFLLElBQUksVUFBVSxHQUFHLGVBQWUsT0FBTyxDQUFDLENBQUM7QUFBQSxFQUN0RztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLEVBUU8sNkJBQTZCLFNBQTZDO0FBQy9FLFNBQUssYUFBYTtBQUNsQixXQUFPLEtBQUssbUJBQW1CLElBQUksbUJBQW1CLEtBQUssSUFBSSxVQUFVLEdBQUcsYUFBYSxPQUFPLENBQUMsQ0FBQztBQUFBLEVBQ3BHO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUEsRUFRTyw4QkFBOEIsU0FBOEM7QUFDakYsU0FBSyxhQUFhO0FBQ2xCLFdBQU8sS0FBSyxtQkFBbUIsSUFBSSxtQkFBbUIsS0FBSyxJQUFJLFVBQVUsR0FBRyxjQUFjLE9BQU8sQ0FBQyxDQUFDO0FBQUEsRUFDckc7QUFDRjsiLAogICJuYW1lcyI6IFtdCn0K
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/obsidian/components/monkey-around-component.d.mts

@@ -11,40 +11,40 @@ import { ComponentEx } from './component-ex.mjs';
 /**
  * A type of the factories to apply to the object.
  *
- * @typeParam Obj - The object to patch.
+ * @typeParam $Object - The object to patch.
  */
-export type Factories<Obj extends object> = Partial<FullFactories<Obj>>;
+export type Factories<$Object extends object> = Partial<FullFactories<$Object>>;
 /**
  * Keys of `Obj` whose value is callable — a method, or a function-like object such as a `Debouncer`. These are the members
  * accepted by {@link MonkeyAroundComponent#registerFunctionPatch}.
  *
- * @typeParam Obj - The object whose keys are filtered.
+ * @typeParam $Object - The object whose keys are filtered.
  */
-export type FunctionKeys<Obj extends object> = ConditionalKeys<Obj, GenericFunction | undefined> & keyof Obj;
+export type FunctionKeys<$Object extends object> = ConditionalKeys<$Object, GenericFunction | undefined> & keyof $Object;
 /**
  * Keys of `Obj` whose value is a plain function (a "real method"). Function-like objects that carry extra members are
  * excluded — e.g. a `Debouncer` (which adds `cancel`/`run`) belongs to {@link MonkeyAroundComponent#registerFunctionPatch},
  * not {@link MonkeyAroundComponent#registerMethodPatch}. The check is whether the member has any own keys beyond a bare
  * function's (`Exclude<keyof T, keyof GenericFunction>` is `never`).
  *
- * @typeParam Obj - The object whose keys are filtered.
+ * @typeParam $Object - The object whose keys are filtered.
  */
-export type MethodKeys<Obj extends object> = MethodKeysMap<Obj>[FunctionKeys<Obj>];
+export type MethodKeys<$Object extends object> = MethodKeysMap<$Object>[FunctionKeys<$Object>];
 /**
  * Parameters passed to {@link MonkeyAroundComponent#registerFunctionPatch}.
  *
- * @typeParam Obj - The object to patch.
+ * @typeParam $Object - The object to patch.
  * @typeParam FunctionName - The function name to patch.
  */
-export interface MonkeyAroundComponentRegisterFunctionPatchParams<Obj extends object, FunctionName extends FunctionKeys<Obj>> {
+export interface MonkeyAroundComponentRegisterFunctionPatchParams<$Object extends object, FunctionName extends FunctionKeys<$Object>> {
     /**
-     * The function name to patch.
+     * The object to patch.
      */
-    readonly functionName: FunctionName;
+    readonly $object: $Object;
     /**
-     * The object to patch.
+     * The function name to patch.
      */
-    readonly obj: Obj;
+    readonly functionName: FunctionName;
     /**
      * 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.
@@ -60,23 +60,23 @@ export interface MonkeyAroundComponentRegisterFunctionPatchParams<Obj extends ob
      * @param originalValue - The original value of the function.
      * @returns The patched value of the function.
      */
-    patchHandler(originalValue: Obj[FunctionName]): Obj[FunctionName];
+    patchHandler(originalValue: $Object[FunctionName]): $Object[FunctionName];
 }
 /**
  * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.
  *
- * @typeParam Obj - The object to patch.
+ * @typeParam $Object - The object to patch.
  * @typeParam MethodName - The method name to patch.
  */
-export interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends object, MethodName extends MethodKeys<Obj>> {
+export interface MonkeyAroundComponentRegisterMethodPatchParams<$Object extends object, MethodName extends MethodKeys<$Object>> {
     /**
-     * The method name to patch.
+     * The object to patch.
      */
-    readonly methodName: MethodName;
+    readonly $object: $Object;
     /**
-     * The object to patch.
+     * The method name to patch.
      */
-    readonly obj: Obj;
+    readonly methodName: MethodName;
     /**
      * 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
@@ -88,7 +88,7 @@ export interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends obje
     /**
      * The patch handler function.
      */
-    readonly patchHandler: PatchHandlerFn<Obj, MethodName>;
+    readonly patchHandler: PatchHandlerFunction<$Object, MethodName>;
     /**
      * An optional token to identify the patch.
      */
@@ -96,69 +96,69 @@ export interface MonkeyAroundComponentRegisterMethodPatchParams<Obj extends obje
     /**
      * An optional post-patch handler function that runs after the patch is applied.
      */
-    readonly postPatchHandler?: PostPatchHandlerFn<Obj, MethodName>;
+    readonly postPatchHandler?: PostPatchHandlerFunction<$Object, MethodName>;
 }
 /**
  * A patch handler function that intercepts calls to a method on an object.
  *
- * @typeParam Obj - The object being patched.
+ * @typeParam $Object - The object being patched.
  * @typeParam MethodName - The method name being patched.
  */
-export type PatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (params: PatchHandlerParams<Obj, MethodName>) => ReturnType<ExtractFunction<Obj, MethodName>>;
+export type PatchHandlerFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = (params: PatchHandlerParams<$Object, MethodName>) => ReturnType<ExtractFunction<$Object, MethodName>>;
 /**
- * Parameters passed to a {@link PatchHandlerFn} callback.
+ * Parameters passed to a {@link PatchHandlerFunction} callback.
  *
- * @typeParam Obj - The object being patched.
+ * @typeParam $Object - The object being patched.
  * @typeParam MethodName - The method name being patched.
  */
-export interface PatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {
-    fallback(this: void): ReturnType<ExtractFunction<Obj, MethodName>>;
+export interface PatchHandlerParams<$Object extends object, MethodName extends MethodKeys<$Object>> {
+    fallback(this: void): ReturnType<ExtractFunction<$Object, MethodName>>;
     /**
      * The original arguments of the intercepted call, as a tuple.
      */
-    readonly originalArgs: Parameters<ExtractFunction<Obj, MethodName>>;
+    readonly originalArguments: Parameters<ExtractFunction<$Object, MethodName>>;
     /**
      * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.
      */
-    readonly originalMethod: ExtractFunction<Obj, MethodName>;
+    readonly originalMethod: ExtractFunction<$Object, MethodName>;
     /**
      * The original method, but with the `this` context already bound to the original object. Call via `originalMethodBound(...originalArgs)`.
      */
-    readonly originalMethodBound: OmitThisParameter<ExtractFunction<Obj, MethodName>>;
+    readonly originalMethodBound: OmitThisParameter<ExtractFunction<$Object, MethodName>>;
     /**
      * The original `this` context of the intercepted call.
      */
-    readonly originalThis: Obj;
+    readonly originalThis: $Object;
 }
 /**
  * A post-patch handler function that runs after a patch is applied.
  *
- * @typeParam Obj - The object being patched.
+ * @typeParam $Object - The object being patched.
  * @typeParam MethodName - The method name being patched.
  */
-export type PostPatchHandlerFn<Obj extends object, MethodName extends MethodKeys<Obj>> = (params: PostPatchHandlerParams<Obj, MethodName>) => MaybeReturn<ExtractFunction<Obj, MethodName>>;
+export type PostPatchHandlerFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = (params: PostPatchHandlerParams<$Object, MethodName>) => MaybeReturn<ExtractFunction<$Object, MethodName>>;
 /**
- * Parameters passed to a {@link PostPatchHandlerFn} callback.
+ * Parameters passed to a {@link PostPatchHandlerFunction} callback.
  *
- * @typeParam Obj - The object being patched.
+ * @typeParam $Object - The object being patched.
  * @typeParam MethodName - The method name being patched.
  */
-export interface PostPatchHandlerParams<Obj extends object, MethodName extends MethodKeys<Obj>> {
+export interface PostPatchHandlerParams<$Object extends object, MethodName extends MethodKeys<$Object>> {
     /**
      * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.
      */
-    readonly originalMethod: ExtractFunction<Obj, MethodName>;
+    readonly originalMethod: ExtractFunction<$Object, MethodName>;
     /**
      * The patched method.
      */
-    readonly patchedMethod: ExtractFunction<Obj, MethodName>;
+    readonly patchedMethod: ExtractFunction<$Object, MethodName>;
 }
-type ExtractFunction<Obj extends object, MethodName extends MethodKeys<Obj>> = GenericFunction<Parameters<Extract<Obj[MethodName], GenericFunction>>, ReturnType<Extract<Obj[MethodName], GenericFunction>>>;
-type FullFactories<Obj extends object> = {
-    [Key in keyof Obj]: (originalValue: Obj[Key]) => Obj[Key];
+type ExtractFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = GenericFunction<Parameters<Extract<$Object[MethodName], GenericFunction>>, ReturnType<Extract<$Object[MethodName], GenericFunction>>>;
+type FullFactories<$Object extends object> = {
+    [Key in keyof $Object]: (originalValue: $Object[Key]) => $Object[Key];
 };
-type MethodKeysMap<Obj extends object> = {
-    [Key in FunctionKeys<Obj>]: [Exclude<keyof NonNullable<Obj[Key]>, keyof GenericFunction>] extends [never] ? Key : never;
+type MethodKeysMap<$Object extends object> = {
+    [Key in FunctionKeys<$Object>]: [Exclude<keyof NonNullable<$Object[Key]>, keyof GenericFunction>] extends [never] ? Key : never;
 };
 type Uninstaller = () => void;
 /**
@@ -169,44 +169,44 @@ export declare class MonkeyAroundComponent extends ComponentEx {
     /**
      * Registers a patch for a single function-like member (a method, or a callable such as a `Debouncer`) using a simplified handler.
      *
-     * @typeParam Obj - The object to patch.
+     * @typeParam $Object - The object to patch.
      * @typeParam FunctionName - The function name to patch.
      * @param params - The parameters of the patch.
      */
-    registerFunctionPatch<Obj extends object, const FunctionName extends FunctionKeys<Obj>>(params: MonkeyAroundComponentRegisterFunctionPatchParams<Obj, FunctionName>): void;
+    registerFunctionPatch<$Object extends object, const FunctionName extends FunctionKeys<$Object>>(params: MonkeyAroundComponentRegisterFunctionPatchParams<$Object, FunctionName>): void;
     /**
      * Registers a single-method patch using a simplified handler.
      *
-     * @typeParam Obj - The object to patch.
+     * @typeParam $Object - The object to patch.
      * @typeParam MethodName - The method name to patch.
      * @param params - The parameters of the patch.
      */
-    registerMethodPatch<Obj extends object, const MethodName extends MethodKeys<Obj>>(params: MonkeyAroundComponentRegisterMethodPatchParams<Obj, MethodName>): void;
+    registerMethodPatch<$Object extends object, const MethodName extends MethodKeys<$Object>>(params: MonkeyAroundComponentRegisterMethodPatchParams<$Object, MethodName>): void;
     /**
      * Registers a patch using raw factories (advanced API).
      *
-     * @typeParam Obj - The object to patch.
-     * @param obj - The object to patch.
+     * @typeParam $Object - The object to patch.
+     * @param $object - The object to patch.
      * @param factories - The factories to apply to the object.
      */
-    registerPatch<Obj extends object>(obj: Obj, factories: Factories<Obj>): void;
+    registerPatch<$Object extends object>($object: $Object, factories: Factories<$Object>): void;
 }
 /**
  * Applies a patch to the object.
  * Better strongly-typed version of `monkey-around`.
  *
- * @typeParam Obj - The object to patch.
- * @param obj - The object to patch.
+ * @typeParam $Object - The object to patch.
+ * @param $object - The object to patch.
  * @param factories - The factories to apply to the object.
  * @returns The uninstaller that removes the patch when called.
  */
-export declare function around<Obj extends object>(obj: Obj, factories: Factories<Obj>): Uninstaller;
+export declare function around<$Object extends object>($object: $Object, factories: Factories<$Object>): Uninstaller;
 /**
  * Checks if a function has a specific patch token.
  *
- * @param fn - The function to check.
+ * @param $function - The function to check.
  * @param patchToken - The patch token to check for.
  * @returns Whether the function has the patch token.
  */
-export declare function hasPatchToken(fn: GenericFunction, patchToken: symbol): boolean;
+export declare function hasPatchToken($function: GenericFunction, patchToken: symbol): boolean;
 export {};

package/dist/lib/esm/obsidian/components/monkey-around-component.mjs

@@ -28,7 +28,7 @@ class MonkeyAroundComponent extends ComponentEx {
   /**
    * Registers a patch for a single function-like member (a method, or a callable such as a `Debouncer`) using a simplified handler.
    *
-   * @typeParam Obj - The object to patch.
+   * @typeParam $Object - The object to patch.
    * @typeParam FunctionName - The function name to patch.
    * @param params - The parameters of the patch.
    */
@@ -43,33 +43,33 @@ class MonkeyAroundComponent extends ComponentEx {
       const unloadComponent = () => {
         this.unload();
       };
-      function oncePatchedValue(...args) {
+      function oncePatchedValue(...$arguments) {
         try {
-          return Reflect.apply(patchedValue, this, args);
+          return Reflect.apply(patchedValue, this, $arguments);
         } finally {
           unloadComponent();
         }
       }
       return Object.assign(oncePatchedValue, patchedValue);
     };
-    this.registerPatch(params.obj, factories);
+    this.registerPatch(params.$object, factories);
   }
   /**
    * Registers a single-method patch using a simplified handler.
    *
-   * @typeParam Obj - The object to patch.
+   * @typeParam $Object - The object to patch.
    * @typeParam MethodName - The method name to patch.
    * @param params - The parameters of the patch.
    */
   registerMethodPatch(params) {
     this.ensureLoaded();
     if (params.patchToken) {
-      const originalMethod = params.obj[params.methodName];
+      const originalMethod = params.$object[params.methodName];
       getMonkeyAroundPatches().set(originalMethod, params.patchToken);
     }
     this.registerFunctionPatch({
+      $object: params.$object,
       functionName: params.methodName,
-      obj: params.obj,
       once: params.once ?? false,
       patchHandler: (originalMethodRaw) => {
         const originalMethod = originalMethodRaw;
@@ -78,13 +78,13 @@ class MonkeyAroundComponent extends ComponentEx {
           patchedMethod
         }) ?? patchedMethod;
         return finalPatchedMethod;
-        function patchedMethod(...originalArgs) {
+        function patchedMethod(...originalArguments) {
           const originalThis = this;
           return params.patchHandler({
             fallback() {
-              return originalMethod.call(originalThis, ...originalArgs);
+              return originalMethod.call(originalThis, ...originalArguments);
             },
-            originalArgs,
+            originalArguments,
             originalMethod,
             originalMethodBound: originalMethod.bind(originalThis),
             originalThis
@@ -96,21 +96,21 @@ class MonkeyAroundComponent extends ComponentEx {
   /**
    * Registers a patch using raw factories (advanced API).
    *
-   * @typeParam Obj - The object to patch.
-   * @param obj - The object to patch.
+   * @typeParam $Object - The object to patch.
+   * @param $object - The object to patch.
    * @param factories - The factories to apply to the object.
    */
-  registerPatch(obj, factories) {
+  registerPatch($object, factories) {
     this.ensureLoaded();
-    const uninstaller = around(obj, factories);
+    const uninstaller = around($object, factories);
     this.register(uninstaller);
   }
 }
-function around(obj, factories) {
-  return originalAround(obj, factories);
+function around($object, factories) {
+  return originalAround($object, factories);
 }
-function hasPatchToken(fn, patchToken) {
-  return getMonkeyAroundPatches().get(fn) === patchToken;
+function hasPatchToken($function, patchToken) {
+  return getMonkeyAroundPatches().get($function) === patchToken;
 }
 function getMonkeyAroundPatches() {
   return getObsidianDevUtilsState("monkeyAroundPatches", /* @__PURE__ */ new WeakMap()).value;
@@ -120,4 +120,4 @@ export {
   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   * 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": ";;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,UAAU,sBAAsB;AAMzC,SAAS,gCAAgC;AACzC,SAAS,mBAAmB;AA+LrB,MAAM,8BAA8B,YAAY;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,SAAO,eAAe,KAAsB,SAA6C;AAC3F;AASO,SAAS,cAAc,IAAqB,YAA6B;AAC9E,SAAO,uBAAuB,EAAE,IAAI,EAAE,MAAM;AAC9C;AAEA,SAAS,yBAA2D;AAClE,SAAO,yBAAyB,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AACjG;",
  "names": []
}

+//# 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 $Object - The object to patch.\n */\nexport type Factories<$Object extends object> = Partial<FullFactories<$Object>>;\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 $Object - The object whose keys are filtered.\n */\nexport type FunctionKeys<$Object extends object> = ConditionalKeys<$Object, GenericFunction | undefined> & keyof $Object;\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 $Object - The object whose keys are filtered.\n */\nexport type MethodKeys<$Object extends object> = MethodKeysMap<$Object>[FunctionKeys<$Object>];\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerFunctionPatch}.\n *\n * @typeParam $Object - The object to patch.\n * @typeParam FunctionName - The function name to patch.\n */\nexport interface MonkeyAroundComponentRegisterFunctionPatchParams<$Object extends object, FunctionName extends FunctionKeys<$Object>> {\n  /**\n   * The object to patch.\n   */\n  readonly $object: $Object;\n\n  /**\n   * The function name to patch.\n   */\n  readonly functionName: FunctionName;\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: $Object[FunctionName]): $Object[FunctionName];\n}\n\n/**\n * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.\n *\n * @typeParam $Object - The object to patch.\n * @typeParam MethodName - The method name to patch.\n */\nexport interface MonkeyAroundComponentRegisterMethodPatchParams<$Object extends object, MethodName extends MethodKeys<$Object>> {\n  /**\n   * The object to patch.\n   */\n  readonly $object: $Object;\n\n  /**\n   * The method name to patch.\n   */\n  readonly methodName: MethodName;\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: PatchHandlerFunction<$Object, 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?: PostPatchHandlerFunction<$Object, MethodName>;\n}\n\n/**\n * A patch handler function that intercepts calls to a method on an object.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PatchHandlerFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = (\n  params: PatchHandlerParams<$Object, MethodName>\n) => ReturnType<ExtractFunction<$Object, MethodName>>;\n\n/**\n * Parameters passed to a {@link PatchHandlerFunction} callback.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PatchHandlerParams<$Object extends object, MethodName extends MethodKeys<$Object>> {\n  fallback(this: void): ReturnType<ExtractFunction<$Object, MethodName>>;\n\n  /**\n   * The original arguments of the intercepted call, as a tuple.\n   */\n  readonly originalArguments: Parameters<ExtractFunction<$Object, MethodName>>;\n\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<$Object, 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<$Object, MethodName>>;\n\n  /**\n   * The original `this` context of the intercepted call.\n   */\n  readonly originalThis: $Object;\n}\n\n/**\n * A post-patch handler function that runs after a patch is applied.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport type PostPatchHandlerFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = (\n  params: PostPatchHandlerParams<$Object, MethodName>\n) => MaybeReturn<ExtractFunction<$Object, MethodName>>;\n\n/**\n * Parameters passed to a {@link PostPatchHandlerFunction} callback.\n *\n * @typeParam $Object - The object being patched.\n * @typeParam MethodName - The method name being patched.\n */\nexport interface PostPatchHandlerParams<$Object extends object, MethodName extends MethodKeys<$Object>> {\n  /**\n   * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.\n   */\n  readonly originalMethod: ExtractFunction<$Object, MethodName>;\n\n  /**\n   * The patched method.\n   */\n  readonly patchedMethod: ExtractFunction<$Object, MethodName>;\n}\n\ntype ExtractFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = GenericFunction<Parameters<Extract<$Object[MethodName], GenericFunction>>, ReturnType<Extract<$Object[MethodName], GenericFunction>>>;\n\ntype FullFactories<$Object extends object> = {\n  [Key in keyof $Object]: (originalValue: $Object[Key]) => $Object[Key];\n};\n\ntype MethodKeysMap<$Object extends object> = {\n  [Key in FunctionKeys<$Object>]: [Exclude<keyof NonNullable<$Object[Key]>, keyof GenericFunction>] extends [never] ? Key : never;\n};\n\ntype OriginalFactories<$Object extends GenericObject> = Parameters<typeof originalAround<$Object>>[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 $Object - The object to patch.\n   * @typeParam FunctionName - The function name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerFunctionPatch<$Object extends object, const FunctionName extends FunctionKeys<$Object>>(\n    params: MonkeyAroundComponentRegisterFunctionPatchParams<$Object, FunctionName>\n  ): void {\n    this.ensureLoaded();\n\n    const factories: Factories<$Object> = {};\n    // eslint-disable-next-line unicorn/no-immediate-mutation -- A computed key in an object literal does not match `Partial<FullFactories<$Object>>` when the key type is generic; assigning after declaration keeps the target type known.\n    factories[params.functionName] = (originalValue: $Object[FunctionName]): $Object[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, ...$arguments: unknown[]): unknown {\n        try {\n          return Reflect.apply(patchedValue, this, $arguments);\n        } finally {\n          unloadComponent();\n        }\n      }\n      return Object.assign(oncePatchedValue, patchedValue) as $Object[FunctionName];\n    };\n\n    this.registerPatch(params.$object, factories);\n  }\n\n  /**\n   * Registers a single-method patch using a simplified handler.\n   *\n   * @typeParam $Object - The object to patch.\n   * @typeParam MethodName - The method name to patch.\n   * @param params - The parameters of the patch.\n   */\n  public registerMethodPatch<$Object extends object, const MethodName extends MethodKeys<$Object>>(\n    params: MonkeyAroundComponentRegisterMethodPatchParams<$Object, MethodName>\n  ): void {\n    this.ensureLoaded();\n\n    if (params.patchToken) {\n      const originalMethod = params.$object[params.methodName] as GenericFunction;\n      getMonkeyAroundPatches().set(originalMethod, params.patchToken);\n    }\n\n    type $Function = ExtractFunction<$Object, MethodName>;\n\n    this.registerFunctionPatch({\n      $object: params.$object,\n      functionName: params.methodName,\n      once: params.once ?? false,\n      patchHandler: (originalMethodRaw) => {\n        const originalMethod = originalMethodRaw as $Function;\n        const finalPatchedMethod = params.postPatchHandler?.({\n          originalMethod,\n          patchedMethod\n        }) ?? patchedMethod;\n        return finalPatchedMethod as $Object[MethodName];\n\n        function patchedMethod(this: $Object, ...originalArguments: Parameters<$Function>): ReturnType<$Function> {\n          // eslint-disable-next-line consistent-this, @typescript-eslint/no-this-alias, unicorn/no-this-assignment -- We need to use the `this` context.\n          const originalThis = this;\n          return params.patchHandler({\n            fallback() {\n              return originalMethod.call(originalThis, ...originalArguments);\n            },\n            originalArguments,\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 $Object - The object to patch.\n   * @param $object - The object to patch.\n   * @param factories - The factories to apply to the object.\n   */\n  public registerPatch<$Object extends object>($object: $Object, factories: Factories<$Object>): void {\n    this.ensureLoaded();\n\n    const uninstaller = around($object, 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 $Object - The object to patch.\n * @param $object - 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<$Object extends object>($object: $Object, factories: Factories<$Object>): Uninstaller {\n  return originalAround($object as GenericObject, factories as OriginalFactories<GenericObject>);\n}\n\n/**\n * Checks if a function has a specific patch token.\n *\n * @param $function - 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($function: GenericFunction, patchToken: symbol): boolean {\n  return getMonkeyAroundPatches().get($function) === patchToken;\n}\n\nfunction getMonkeyAroundPatches(): WeakMap<GenericFunction, symbol> {\n  return getObsidianDevUtilsState('monkeyAroundPatches', new WeakMap<GenericFunction, symbol>()).value;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAQA,SAAS,UAAU,sBAAsB;AAMzC,SAAS,gCAAgC;AACzC,SAAS,mBAAmB;AA+LrB,MAAM,8BAA8B,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQ9C,sBACL,QACM;AACN,SAAK,aAAa;AAElB,UAAM,YAAgC,CAAC;AAEvC,cAAU,OAAO,YAAY,IAAI,CAAC,kBAAgE;AAChG,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,YAAgC;AAC1E,YAAI;AACF,iBAAO,QAAQ,MAAM,cAAc,MAAM,UAAU;AAAA,QACrD,UAAE;AACA,0BAAgB;AAAA,QAClB;AAAA,MACF;AACA,aAAO,OAAO,OAAO,kBAAkB,YAAY;AAAA,IACrD;AAEA,SAAK,cAAc,OAAO,SAAS,SAAS;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASO,oBACL,QACM;AACN,SAAK,aAAa;AAElB,QAAI,OAAO,YAAY;AACrB,YAAM,iBAAiB,OAAO,QAAQ,OAAO,UAAU;AACvD,6BAAuB,EAAE,IAAI,gBAAgB,OAAO,UAAU;AAAA,IAChE;AAIA,SAAK,sBAAsB;AAAA,MACzB,SAAS,OAAO;AAAA,MAChB,cAAc,OAAO;AAAA,MACrB,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,iBAAgC,mBAAiE;AAExG,gBAAM,eAAe;AACrB,iBAAO,OAAO,aAAa;AAAA,YACzB,WAAW;AACT,qBAAO,eAAe,KAAK,cAAc,GAAG,iBAAiB;AAAA,YAC/D;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,cAAsC,SAAkB,WAAqC;AAClG,SAAK,aAAa;AAElB,UAAM,cAAc,OAAO,SAAS,SAAS;AAC7C,SAAK,SAAS,WAAW;AAAA,EAC3B;AACF;AAWO,SAAS,OAA+B,SAAkB,WAA4C;AAC3G,SAAO,eAAe,SAA0B,SAA6C;AAC/F;AASO,SAAS,cAAc,WAA4B,YAA6B;AACrF,SAAO,uBAAuB,EAAE,IAAI,SAAS,MAAM;AACrD;AAEA,SAAS,yBAA2D;AAClE,SAAO,yBAAyB,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AACjG;",
  "names": []
}
