@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/components/menu-event-registrar-component.cjs

@@ -0,0 +1,196 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var menu_event_registrar_component_exports = {};
+__export(menu_event_registrar_component_exports, {
+  MenuEventRegistrarComponent: () => MenuEventRegistrarComponent
+});
+module.exports = __toCommonJS(menu_event_registrar_component_exports);
+var import_events = require('../events.cjs');
+var import_component_ex = require('./component-ex.cjs');
+class MenuEventRegistrarComponent extends import_component_ex.ComponentEx {
+  /**
+   * Creates a new app-backed menu event registrar.
+   *
+   * @param app - The Obsidian app instance.
+   */
+  constructor(app) {
+    super();
+    this.app = app;
+  }
+  app;
+  /**
+   * Registers a handler for the editor context menu event.
+   *
+   * @param handler - The handler to register.
+   * @returns A {@link DisposableEx} that unregisters the handler when disposed (or on component unload).
+   */
+  registerEditorMenuEventHandler(handler) {
+    this.ensureLoaded();
+    return this.registerDisposable(new import_events.EventRefDisposable(this.app.workspace.on("editor-menu", handler)));
+  }
+  /**
+   * Registers a handler for the single-file context menu event.
+   *
+   * @param handler - The handler to register.
+   * @returns A {@link DisposableEx} that unregisters the handler when disposed (or on component unload).
+   */
+  registerFileMenuEventHandler(handler) {
+    this.ensureLoaded();
+    return this.registerDisposable(new import_events.EventRefDisposable(this.app.workspace.on("file-menu", handler)));
+  }
+  /**
+   * Registers a handler for the multi-file context menu event.
+   *
+   * @param handler - The handler to register.
+   * @returns A {@link DisposableEx} that unregisters the handler when disposed (or on component unload).
+   */
+  registerFilesMenuEventHandler(handler) {
+    this.ensureLoaded();
+    return this.registerDisposable(new import_events.EventRefDisposable(this.app.workspace.on("files-menu", handler)));
+  }
+  /**
+   * Registers a handler for the markdown viewport (margin) context menu event.
+   *
+   * @param handler - The handler to register.
+   * @returns A {@link DisposableEx} that unregisters the handler when disposed (or on component unload).
+   */
+  registerMarkdownViewportMenuEventHandler(handler) {
+    this.ensureLoaded();
+    return this.registerDisposable(new import_events.EventRefDisposable(this.app.workspace.on("markdown-viewport-menu", handler)));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MenuEventRegistrarComponent
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/components/menu-event-registrar-component.d.cts

@@ -0,0 +1,52 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Registers menu event handlers with Obsidian's workspace, supporting editor, file, and multi-file context menus.
+ */
+import type { DisposableEx } from '@mnaoumov/typescript-lib/disposable' with { 'resolution-mode': 'import' };
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { EditorMenuEventHandler, FileMenuEventHandler, FilesMenuEventHandler, MarkdownViewportMenuEventHandler, MenuEventRegistrar } from '../menu-event-registrar.cjs';
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * {@link MenuEventRegistrar} backed by Obsidian's {@link App} workspace events.
+ *
+ * Event handlers are registered with the provided {@link Component} for lifecycle management.
+ */
+export declare class MenuEventRegistrarComponent extends ComponentEx implements MenuEventRegistrar {
+    protected readonly app: App;
+    /**
+     * Creates a new app-backed menu event registrar.
+     *
+     * @param app - The Obsidian app instance.
+     */
+    constructor(app: App);
+    /**
+     * Registers a handler for the editor context menu event.
+     *
+     * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed (or on component unload).
+     */
+    registerEditorMenuEventHandler(handler: EditorMenuEventHandler): DisposableEx;
+    /**
+     * Registers a handler for the single-file context menu event.
+     *
+     * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed (or on component unload).
+     */
+    registerFileMenuEventHandler(handler: FileMenuEventHandler): DisposableEx;
+    /**
+     * Registers a handler for the multi-file context menu event.
+     *
+     * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed (or on component unload).
+     */
+    registerFilesMenuEventHandler(handler: FilesMenuEventHandler): DisposableEx;
+    /**
+     * Registers a handler for the markdown viewport (margin) context menu event.
+     *
+     * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed (or on component unload).
+     */
+    registerMarkdownViewportMenuEventHandler(handler: MarkdownViewportMenuEventHandler): DisposableEx;
+}

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

@@ -0,0 +1,245 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var monkey_around_component_exports = {};
+__export(monkey_around_component_exports, {
+  MonkeyAroundComponent: () => MonkeyAroundComponent,
+  around: () => around,
+  hasPatchToken: () => hasPatchToken
+});
+module.exports = __toCommonJS(monkey_around_component_exports);
+var import_monkey_around = require('monkey-around');
+var import_obsidian_dev_utils_state = require('../obsidian-dev-utils-state.cjs');
+var import_component_ex = require('./component-ex.cjs');
+class MonkeyAroundComponent extends import_component_ex.ComponentEx {
+  /**
+   * Registers a patch for a single function-like member (a method, or a callable such as a `Debouncer`) using a simplified handler.
+   *
+   * @typeParam $Object - The object to patch.
+   * @typeParam FunctionName - The function name to patch.
+   * @param params - The parameters of the patch.
+   */
+  registerFunctionPatch(params) {
+    this.ensureLoaded();
+    const factories = {};
+    factories[params.functionName] = (originalValue) => {
+      const patchedValue = params.patchHandler(originalValue);
+      if (!params.once) {
+        return patchedValue;
+      }
+      const unloadComponent = () => {
+        this.unload();
+      };
+      function oncePatchedValue(...$arguments) {
+        try {
+          return Reflect.apply(patchedValue, this, $arguments);
+        } finally {
+          unloadComponent();
+        }
+      }
+      return Object.assign(oncePatchedValue, patchedValue);
+    };
+    this.registerPatch(params.$object, factories);
+  }
+  /**
+   * Registers a single-method patch using a simplified handler.
+   *
+   * @typeParam $Object - The object to patch.
+   * @typeParam MethodName - The method name to patch.
+   * @param params - The parameters of the patch.
+   */
+  registerMethodPatch(params) {
+    this.ensureLoaded();
+    this.registerFunctionPatch({
+      $object: params.$object,
+      functionName: params.methodName,
+      once: params.once ?? false,
+      patchHandler: (originalMethodRaw) => {
+        const originalMethod = originalMethodRaw;
+        const finalPatchedMethod = params.postPatchHandler?.({
+          originalMethod,
+          patchedMethod: patchedMethod2
+        }) ?? patchedMethod2;
+        return finalPatchedMethod;
+        function patchedMethod2(...originalArguments) {
+          const originalThis = this;
+          return params.patchHandler({
+            fallback() {
+              return originalMethod.call(originalThis, ...originalArguments);
+            },
+            originalArguments,
+            originalMethod,
+            originalMethodBound: originalMethod.bind(originalThis),
+            originalThis
+          });
+        }
+      }
+    });
+    if (!params.patchToken) {
+      return;
+    }
+    const patchedMethod = params.$object[params.methodName];
+    const monkeyAroundPatches = getMonkeyAroundPatches();
+    monkeyAroundPatches.set(patchedMethod, params.patchToken);
+    this.register(() => {
+      monkeyAroundPatches.delete(patchedMethod);
+    });
+  }
+  /**
+   * Registers a patch using raw factories (advanced API).
+   *
+   * @typeParam $Object - The object to patch.
+   * @param $object - The object to patch.
+   * @param factories - The factories to apply to the object.
+   */
+  registerPatch($object, factories) {
+    this.ensureLoaded();
+    const uninstaller = around($object, factories);
+    this.register(uninstaller);
+  }
+}
+function around($object, factories) {
+  return (0, import_monkey_around.around)($object, factories);
+}
+function hasPatchToken($function, patchToken) {
+  return getMonkeyAroundPatches().get($function) === patchToken;
+}
+function getMonkeyAroundPatches() {
+  return (0, import_obsidian_dev_utils_state.getObsidianDevUtilsState)("monkeyAroundPatches", /* @__PURE__ */ new WeakMap()).value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MonkeyAroundComponent,
+  around,
+  hasPatchToken
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/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 { GenericFunction } from '@mnaoumov/typescript-lib/function';\nimport type { MaybeReturn } from '@mnaoumov/typescript-lib/type';\nimport type { GenericObject } from '@mnaoumov/typescript-lib/type-guards';\nimport type { ConditionalKeys } from 'type-fest';\n\nimport { around as originalAround } from 'monkey-around';\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  readonly 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   * The token is recorded against the method this patch INSTALLS, so the next patch of the same method\n   * detects it via {@link hasPatchToken} on its own `originalMethod` and can defer to this one. The\n   * patch that installs a token therefore never sees its own token \u2014 only the patches stacked on top of\n   * it do. Use a `Symbol.for` token to make the detection work across independently bundled copies of\n   * this library.\n   *\n   * The token is dropped when this component unloads, so a later patch that had deferred takes over on\n   * its next call.\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  /**\n   * Invokes the original method with the original `this` and arguments.\n   *\n   * @returns Whatever the original method returns.\n   */\n  readonly fallback: () => 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    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    if (!params.patchToken) {\n      return;\n    }\n\n    // The token marks the INSTALLED method, read back once the patch is in place.\n    // That is the identity the next patch of the same method receives as its `originalMethod`.\n    // `monkey-around` installs a wrapper of its own and exposes the value built above only via its prototype.\n    // Marking that value, or the method being wrapped as this once did, matches nothing the next patch sees.\n    // Dropping the token on unload lets a deferring later patch take over, since the guard is read per call.\n    const patchedMethod = params.$object[params.methodName] as GenericFunction;\n    const monkeyAroundPatches = getMonkeyAroundPatches();\n    monkeyAroundPatches.set(patchedMethod, params.patchToken);\n    this.register(() => {\n      monkeyAroundPatches.delete(patchedMethod);\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 * A token is carried by the method a {@link MonkeyAroundComponent#registerMethodPatch} call INSTALLED, so\n * the intended caller is a later patch of the same method, checking the `originalMethod` it wrapped in\n * order to defer to the patch already in place:\n *\n * ```ts\n * patchHandler: ({ fallback, originalMethod }) => {\n *   if (hasPatchToken(originalMethod, PATCH_TOKEN)) {\n *     return fallback();\n *   }\n *   ...\n * }\n * ```\n *\n * The check is made per call, so it stops reporting the earlier patch once that patch's component unloads.\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,2BAAyC;AAEzC,sCAAyC;AACzC,0BAA4B;AA6MrB,MAAM,8BAA8B,gCAAY;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;AAIlB,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,eAAAA;AAAA,QACF,CAAC,KAAKA;AACN,eAAO;AAEP,iBAASA,kBAAgC,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;AAED,QAAI,CAAC,OAAO,YAAY;AACtB;AAAA,IACF;AAOA,UAAM,gBAAgB,OAAO,QAAQ,OAAO,UAAU;AACtD,UAAM,sBAAsB,uBAAuB;AACnD,wBAAoB,IAAI,eAAe,OAAO,UAAU;AACxD,SAAK,SAAS,MAAM;AAClB,0BAAoB,OAAO,aAAa;AAAA,IAC1C,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,aAAO,qBAAAC,QAAe,SAA0B,SAA6C;AAC/F;AAwBO,SAAS,cAAc,WAA4B,YAA6B;AACrF,SAAO,uBAAuB,EAAE,IAAI,SAAS,MAAM;AACrD;AAEA,SAAS,yBAA2D;AAClE,aAAO,0DAAyB,uBAAuB,oBAAI,QAAiC,CAAC,EAAE;AACjG;",
  "names": ["patchedMethod", "originalAround"]
}
