@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

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

@@ -0,0 +1,241 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Improved type-safe wrapper of {@link https://www.npmjs.com/package/monkey-around} library.
+ */
+import type { GenericFunction } from '@mnaoumov/typescript-lib/function';
+import type { MaybeReturn } from '@mnaoumov/typescript-lib/type';
+import type { ConditionalKeys } from 'type-fest';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * A type of the factories to apply to the object.
+ *
+ * @typeParam $Object - The object to patch.
+ */
+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 $Object - The object whose keys are filtered.
+ */
+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 $Object - The object whose keys are filtered.
+ */
+export type MethodKeys<$Object extends object> = MethodKeysMap<$Object>[FunctionKeys<$Object>];
+/**
+ * Parameters passed to {@link MonkeyAroundComponent#registerFunctionPatch}.
+ *
+ * @typeParam $Object - The object to patch.
+ * @typeParam FunctionName - The function name to patch.
+ */
+export interface MonkeyAroundComponentRegisterFunctionPatchParams<$Object extends object, FunctionName extends FunctionKeys<$Object>> {
+    /**
+     * The object to patch.
+     */
+    readonly $object: $Object;
+    /**
+     * The function name to patch.
+     */
+    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.
+     * 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.
+     *
+     * @param originalValue - The original value of the function.
+     * @returns The patched value of the function.
+     */
+    readonly patchHandler: (originalValue: $Object[FunctionName]) => $Object[FunctionName];
+}
+/**
+ * Parameters passed to {@link MonkeyAroundComponent#registerMethodPatch}.
+ *
+ * @typeParam $Object - The object to patch.
+ * @typeParam MethodName - The method name to patch.
+ */
+export interface MonkeyAroundComponentRegisterMethodPatchParams<$Object extends object, MethodName extends MethodKeys<$Object>> {
+    /**
+     * The object to patch.
+     */
+    readonly $object: $Object;
+    /**
+     * The method name to patch.
+     */
+    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
+     * unaffected.
+     *
+     * @default `false`
+     */
+    readonly once?: boolean;
+    /**
+     * The patch handler function.
+     */
+    readonly patchHandler: PatchHandlerFunction<$Object, MethodName>;
+    /**
+     * An optional token to identify the patch.
+     *
+     * The token is recorded against the method this patch INSTALLS, so the next patch of the same method
+     * detects it via {@link hasPatchToken} on its own `originalMethod` and can defer to this one. The
+     * patch that installs a token therefore never sees its own token — only the patches stacked on top of
+     * it do. Use a `Symbol.for` token to make the detection work across independently bundled copies of
+     * this library.
+     *
+     * The token is dropped when this component unloads, so a later patch that had deferred takes over on
+     * its next call.
+     */
+    readonly patchToken?: symbol;
+    /**
+     * An optional post-patch handler function that runs after the patch is applied.
+     */
+    readonly postPatchHandler?: PostPatchHandlerFunction<$Object, MethodName>;
+}
+/**
+ * A patch handler function that intercepts calls to a method on an object.
+ *
+ * @typeParam $Object - The object being patched.
+ * @typeParam MethodName - The method name being patched.
+ */
+export type PatchHandlerFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = (params: PatchHandlerParams<$Object, MethodName>) => ReturnType<ExtractFunction<$Object, MethodName>>;
+/**
+ * Parameters passed to a {@link PatchHandlerFunction} callback.
+ *
+ * @typeParam $Object - The object being patched.
+ * @typeParam MethodName - The method name being patched.
+ */
+export interface PatchHandlerParams<$Object extends object, MethodName extends MethodKeys<$Object>> {
+    /**
+     * Invokes the original method with the original `this` and arguments.
+     *
+     * @returns Whatever the original method returns.
+     */
+    readonly fallback: () => ReturnType<ExtractFunction<$Object, MethodName>>;
+    /**
+     * The original arguments of the intercepted call, as a tuple.
+     */
+    readonly originalArguments: Parameters<ExtractFunction<$Object, MethodName>>;
+    /**
+     * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.
+     */
+    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<$Object, MethodName>>;
+    /**
+     * The original `this` context of the intercepted call.
+     */
+    readonly originalThis: $Object;
+}
+/**
+ * A post-patch handler function that runs after a patch is applied.
+ *
+ * @typeParam $Object - The object being patched.
+ * @typeParam MethodName - The method name being patched.
+ */
+export type PostPatchHandlerFunction<$Object extends object, MethodName extends MethodKeys<$Object>> = (params: PostPatchHandlerParams<$Object, MethodName>) => MaybeReturn<ExtractFunction<$Object, MethodName>>;
+/**
+ * Parameters passed to a {@link PostPatchHandlerFunction} callback.
+ *
+ * @typeParam $Object - The object being patched.
+ * @typeParam MethodName - The method name being patched.
+ */
+export interface PostPatchHandlerParams<$Object extends object, MethodName extends MethodKeys<$Object>> {
+    /**
+     * The original (unpatched) method. Call via `originalFn.call(originalThis, ...originalArgs)`.
+     */
+    readonly originalMethod: ExtractFunction<$Object, MethodName>;
+    /**
+     * The patched method.
+     */
+    readonly patchedMethod: ExtractFunction<$Object, MethodName>;
+}
+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<$Object extends object> = {
+    [Key in FunctionKeys<$Object>]: [Exclude<keyof NonNullable<$Object[Key]>, keyof GenericFunction>] extends [never] ? Key : never;
+};
+type Uninstaller = () => void;
+/**
+ * A component that manages monkey-patches with lifecycle-bound cleanup.
+ * All patches registered via this component are automatically uninstalled when the component unloads.
+ */
+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 $Object - The object to patch.
+     * @typeParam FunctionName - The function name to patch.
+     * @param params - The parameters of the patch.
+     */
+    registerFunctionPatch<$Object extends object, const FunctionName extends FunctionKeys<$Object>>(params: MonkeyAroundComponentRegisterFunctionPatchParams<$Object, FunctionName>): void;
+    /**
+     * 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<$Object extends object, const MethodName extends MethodKeys<$Object>>(params: MonkeyAroundComponentRegisterMethodPatchParams<$Object, MethodName>): void;
+    /**
+     * 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 extends object>($object: $Object, factories: Factories<$Object>): void;
+}
+/**
+ * Applies a patch to the object.
+ * Better strongly-typed version of `monkey-around`.
+ *
+ * @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<$Object extends object>($object: $Object, factories: Factories<$Object>): Uninstaller;
+/**
+ * Checks if a function has a specific patch token.
+ *
+ * A token is carried by the method a {@link MonkeyAroundComponent#registerMethodPatch} call INSTALLED, so
+ * the intended caller is a later patch of the same method, checking the `originalMethod` it wrapped in
+ * order to defer to the patch already in place:
+ *
+ * ```ts
+ * patchHandler: ({ fallback, originalMethod }) => {
+ *   if (hasPatchToken(originalMethod, PATCH_TOKEN)) {
+ *     return fallback();
+ *   }
+ *   ...
+ * }
+ * ```
+ *
+ * The check is made per call, so it stops reporting the earlier patch once that patch's component unloads.
+ *
+ * @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($function: GenericFunction, patchToken: symbol): boolean;
+export {};

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

@@ -0,0 +1,146 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { around as originalAround } from "monkey-around";
+import { getObsidianDevUtilsState } from "../obsidian-dev-utils-state.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+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 $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 originalAround($object, factories);
+}
+function hasPatchToken($function, patchToken) {
+  return getMonkeyAroundPatches().get($function) === patchToken;
+}
+function getMonkeyAroundPatches() {
+  return getObsidianDevUtilsState("monkeyAroundPatches", /* @__PURE__ */ new WeakMap()).value;
+}
+export {
+  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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA,SAAS,UAAU,sBAAsB;AAEzC,SAAS,gCAAgC;AACzC,SAAS,mBAAmB;AA6MrB,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;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,SAAO,eAAe,SAA0B,SAA6C;AAC/F;AAwBO,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": ["patchedMethod"]
}


package/dist/lib/esm/components/notebook-navigator-menu-event-registrar-component.d.mts

@@ -0,0 +1,150 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Bridges the file and files context-menu events into Notebook Navigator's own menus.
+ *
+ * Notebook Navigator draws its own file tree and never raises Obsidian's `file-menu` / `files-menu`
+ * workspace events, so a plugin's context-menu items vanish for anyone browsing through it. This
+ * component is a {@link MenuEventRegistrar} backed by Notebook Navigator's extension API instead of
+ * the workspace, so the very same handlers reach both surfaces.
+ */
+import type { DisposableEx } from '@mnaoumov/typescript-lib/disposable';
+import type { App, IconName } from 'obsidian';
+import type { EditorMenuEventHandler, FileMenuEventHandler, FilesMenuEventHandler, MarkdownViewportMenuEventHandler, MenuEventRegistrar } from '../menu-event-registrar.mjs';
+import { LayoutReadyComponent } from './layout-ready-component.mjs';
+/**
+ * Parameters for {@link NotebookNavigatorMenuEventRegistrarComponent}.
+ */
+export interface NotebookNavigatorMenuEventRegistrarComponentConstructorParams {
+    /**
+     * The application instance.
+     */
+    readonly app: App;
+    /**
+     * The plugin's display name, which titles the parent entry.
+     */
+    readonly pluginName: string;
+    /**
+     * The icon for the parent entry.
+     *
+     * @default `''` (no icon)
+     */
+    readonly submenuIcon?: IconName | undefined;
+}
+/**
+ * {@link MenuEventRegistrar} backed by Notebook Navigator's menu-extension API.
+ *
+ * Handlers registered here are collected eagerly and bound to Notebook Navigator once the workspace
+ * layout is ready. When Notebook Navigator is not installed the component simply stays dormant.
+ *
+ * Every collected handler writes into a plugin-titled parent entry's submenu, so a handler must NOT
+ * declare a section submenu of its own — `Menu.sort()` would fold that into a second, nested
+ * plugin-titled entry. `CommandHandlerComponent` takes care of this by forcing
+ * `CommandHandlerRegistrationContext.shouldAddCommandToSubmenu` off for the surfaces it feeds here.
+ */
+export declare class NotebookNavigatorMenuEventRegistrarComponent extends LayoutReadyComponent implements MenuEventRegistrar {
+    /**
+     * The plugin's display name, which titles the parent entry.
+     */
+    protected readonly pluginName: string;
+    /**
+     * The icon for the parent entry.
+     */
+    protected readonly submenuIcon: IconName;
+    private fileMenuEventHandlers;
+    private filesMenuEventHandlers;
+    /**
+     * Creates a new Notebook Navigator menu event registrar.
+     *
+     * @param params - The parameters for the component.
+     */
+    constructor(params: NotebookNavigatorMenuEventRegistrarComponentConstructorParams);
+    /**
+     * Accepts an editor-menu registration and does nothing with it.
+     *
+     * Notebook Navigator extends the file tree, not the editor — an editor menu there is Obsidian's
+     * own, which the handlers already reach through the workspace event. The registration is inert
+     * rather than refused so a handler that declares one is not a load-time error.
+     *
+     * @param _handler - The handler, deliberately unused.
+     * @returns A {@link DisposableEx} that has nothing to undo.
+     */
+    registerEditorMenuEventHandler(_handler: EditorMenuEventHandler): DisposableEx;
+    /**
+     * Collects a single-file menu handler.
+     *
+     * @param handler - The handler to collect.
+     * @returns A {@link DisposableEx} that drops the handler again (or on component unload).
+     */
+    registerFileMenuEventHandler(handler: FileMenuEventHandler): DisposableEx;
+    /**
+     * Collects a multi-file menu handler.
+     *
+     * @param handler - The handler to collect.
+     * @returns A {@link DisposableEx} that drops the handler again (or on component unload).
+     */
+    registerFilesMenuEventHandler(handler: FilesMenuEventHandler): DisposableEx;
+    /**
+     * Accepts a markdown-viewport-menu registration and does nothing with it.
+     *
+     * Notebook Navigator extends the file tree, not the editor — the margin beside a note's text is
+     * Obsidian's own viewport, which the handlers already reach through the workspace event. The
+     * registration is inert rather than refused so a handler that declares one is not a load-time error.
+     *
+     * @param _handler - The handler, deliberately unused.
+     * @returns A {@link DisposableEx} that has nothing to undo.
+     */
+    registerMarkdownViewportMenuEventHandler(_handler: MarkdownViewportMenuEventHandler): DisposableEx;
+    /**
+     * Binds to Notebook Navigator once every plugin has loaded.
+     *
+     * Layout-ready rather than `onload`: plugin load order is not ours to choose, and Notebook
+     * Navigator's API only exists once its own plugin is up. When it is not installed the component
+     * stays dormant — enabling it later takes an Obsidian reload, exactly as it does for anything else
+     * that reads another plugin at startup.
+     */
+    protected onLayoutReady(): void;
+    /**
+     * Adds the plugin's entry, unless the handlers had nothing to contribute.
+     *
+     * The menu is populated TWICE, and both runs are needed: Notebook Navigator's `addItem` cannot be
+     * taken back once called, so the only way to keep an unrelated file's menu clean is to ask the
+     * handlers first, against a menu nobody sees. The gates they answer with are metadata reads, so the
+     * second run costs nothing and cannot disagree with the first.
+     *
+     * @param context - The Notebook Navigator menu being built.
+     * @param populate - Runs the collected handlers against a menu.
+     */
+    private contribute;
+    /**
+     * Handles a file menu, single or multi-selection.
+     *
+     * @param context - The Notebook Navigator menu being built.
+     */
+    private handleFileMenu;
+    /**
+     * Handles a folder menu.
+     *
+     * A folder goes through the SINGLE-file handlers, because that is how Obsidian's own `file-menu`
+     * carries one — the event is typed {@link TAbstractFile}, and the folder handlers are the ones that
+     * narrow it.
+     *
+     * @param context - The Notebook Navigator menu being built.
+     */
+    private handleFolderMenu;
+    /**
+     * Runs the single-file handlers against a menu.
+     *
+     * @param menu - The menu to populate.
+     * @param abstractFile - The file or folder the menu was raised on.
+     */
+    private runFileMenuHandlers;
+    /**
+     * Runs the multi-file handlers against a menu.
+     *
+     * @param menu - The menu to populate.
+     * @param abstractFiles - The files the menu was raised on.
+     */
+    private runFilesMenuHandlers;
+}