@mnaoumov/obsidian-lib 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,241 @@
+/// <reference path="../library.d.cts" />
+/**
+ * @file
+ *
+ * Improved type-safe wrapper of {@link https://www.npmjs.com/package/monkey-around} library.
+ */
+import type { GenericFunction } from '@mnaoumov/typescript-lib/function' with { 'resolution-mode': 'import' };
+import type { MaybeReturn } from '@mnaoumov/typescript-lib/type' with { 'resolution-mode': 'import' };
+import type { ConditionalKeys } from 'type-fest' with { 'resolution-mode': 'import' };
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * 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/cjs/components/notebook-navigator-menu-event-registrar-component.cjs

@@ -0,0 +1,345 @@
+/*
+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'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    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() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+
+  // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+  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 = 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 = 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);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        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);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    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 notebook_navigator_menu_event_registrar_component_exports = {};
+__export(notebook_navigator_menu_event_registrar_component_exports, {
+  NotebookNavigatorMenuEventRegistrarComponent: () => NotebookNavigatorMenuEventRegistrarComponent
+});
+module.exports = __toCommonJS(notebook_navigator_menu_event_registrar_component_exports);
+var import_disposable = require('@mnaoumov/typescript-lib/disposable');
+var import_function = require('@mnaoumov/typescript-lib/function');
+var import_obsidian = require('obsidian');
+var import_notebook_navigator = require('../notebook-navigator.cjs');
+var import_layout_ready_component = require('./layout-ready-component.cjs');
+class NotebookNavigatorMenuEventRegistrarComponent extends import_layout_ready_component.LayoutReadyComponent {
+  /**
+   * The plugin's display name, which titles the parent entry.
+   */
+  pluginName;
+  /**
+   * The icon for the parent entry.
+   */
+  submenuIcon;
+  fileMenuEventHandlers = [];
+  filesMenuEventHandlers = [];
+  /**
+   * Creates a new Notebook Navigator menu event registrar.
+   *
+   * @param params - The parameters for the component.
+   */
+  constructor(params) {
+    super(params.app);
+    this.pluginName = params.pluginName;
+    this.submenuIcon = params.submenuIcon ?? "";
+  }
+  /**
+   * 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) {
+    return new import_disposable.CallbackDisposable({ callback: import_function.noop });
+  }
+  /**
+   * 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) {
+    this.fileMenuEventHandlers.push(handler);
+    return this.registerDisposable(
+      new import_disposable.CallbackDisposable({
+        callback: () => {
+          this.fileMenuEventHandlers = this.fileMenuEventHandlers.filter((collected) => collected !== handler);
+        }
+      })
+    );
+  }
+  /**
+   * 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) {
+    this.filesMenuEventHandlers.push(handler);
+    return this.registerDisposable(
+      new import_disposable.CallbackDisposable({
+        callback: () => {
+          this.filesMenuEventHandlers = this.filesMenuEventHandlers.filter((collected) => collected !== handler);
+        }
+      })
+    );
+  }
+  /**
+   * 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) {
+    return new import_disposable.CallbackDisposable({ callback: import_function.noop });
+  }
+  /**
+   * 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.
+   */
+  onLayoutReady() {
+    const api = (0, import_notebook_navigator.resolveNotebookNavigatorApi)(this.app);
+    if (api === null) {
+      return;
+    }
+    this.register(api.menus.registerFileMenu((context) => {
+      this.handleFileMenu(context);
+    }));
+    this.register(api.menus.registerFolderMenu((context) => {
+      this.handleFolderMenu(context);
+    }));
+  }
+  /**
+   * 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.
+   */
+  contribute(context, populate) {
+    const probeMenu = new import_obsidian.Menu();
+    populate(probeMenu);
+    if (probeMenu.items.length === 0) {
+      return;
+    }
+    context.addItem((item) => {
+      item.setTitle(this.pluginName).setIcon(this.submenuIcon);
+      populate(item.setSubmenu());
+    });
+  }
+  /**
+   * Handles a file menu, single or multi-selection.
+   *
+   * @param context - The Notebook Navigator menu being built.
+   */
+  handleFileMenu(context) {
+    const selectedFiles = [...context.selection.files];
+    this.contribute(
+      context,
+      context.selection.mode === "multiple" ? (menu) => {
+        this.runFilesMenuHandlers(menu, selectedFiles);
+      } : (menu) => {
+        this.runFileMenuHandlers(menu, context.file);
+      }
+    );
+  }
+  /**
+   * 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.
+   */
+  handleFolderMenu(context) {
+    this.contribute(context, (menu) => {
+      this.runFileMenuHandlers(menu, context.folder);
+    });
+  }
+  /**
+   * 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.
+   */
+  runFileMenuHandlers(menu, abstractFile) {
+    for (const handler of this.fileMenuEventHandlers) {
+      handler(menu, abstractFile, import_notebook_navigator.NOTEBOOK_NAVIGATOR_MENU_SOURCE);
+    }
+  }
+  /**
+   * Runs the multi-file handlers against a menu.
+   *
+   * @param menu - The menu to populate.
+   * @param abstractFiles - The files the menu was raised on.
+   */
+  runFilesMenuHandlers(menu, abstractFiles) {
+    for (const handler of this.filesMenuEventHandlers) {
+      handler(menu, abstractFiles, import_notebook_navigator.NOTEBOOK_NAVIGATOR_MENU_SOURCE);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NotebookNavigatorMenuEventRegistrarComponent
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/components/notebook-navigator-menu-event-registrar-component.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Bridges the file and files context-menu events into Notebook Navigator's own menus.\n *\n * Notebook Navigator draws its own file tree and never raises Obsidian's `file-menu` / `files-menu`\n * workspace events, so a plugin's context-menu items vanish for anyone browsing through it. This\n * component is a {@link MenuEventRegistrar} backed by Notebook Navigator's extension API instead of\n * the workspace, so the very same handlers reach both surfaces.\n */\n\nimport type { DisposableEx } from '@mnaoumov/typescript-lib/disposable';\nimport type {\n  App,\n  IconName,\n  Menu,\n  TAbstractFile,\n  TFile\n} from 'obsidian';\n\nimport { CallbackDisposable } from '@mnaoumov/typescript-lib/disposable';\nimport { noop } from '@mnaoumov/typescript-lib/function';\nimport { Menu as MenuImpl } from 'obsidian';\n\nimport type {\n  EditorMenuEventHandler,\n  FileMenuEventHandler,\n  FilesMenuEventHandler,\n  MarkdownViewportMenuEventHandler,\n  MenuEventRegistrar\n} from '../menu-event-registrar.ts';\nimport type {\n  NotebookNavigatorFileMenuContext,\n  NotebookNavigatorFolderMenuContext,\n  NotebookNavigatorMenuContext\n} from '../notebook-navigator.ts';\n\nimport {\n  NOTEBOOK_NAVIGATOR_MENU_SOURCE,\n  resolveNotebookNavigatorApi\n} from '../notebook-navigator.ts';\nimport { LayoutReadyComponent } from './layout-ready-component.ts';\n\n/**\n * Parameters for {@link NotebookNavigatorMenuEventRegistrarComponent}.\n */\nexport interface NotebookNavigatorMenuEventRegistrarComponentConstructorParams {\n  /**\n   * The application instance.\n   */\n  readonly app: App;\n\n  /**\n   * The plugin's display name, which titles the parent entry.\n   */\n  readonly pluginName: string;\n\n  /**\n   * The icon for the parent entry.\n   *\n   * @default `''` (no icon)\n   */\n  readonly submenuIcon?: IconName | undefined;\n}\n\n/**\n * {@link MenuEventRegistrar} backed by Notebook Navigator's menu-extension API.\n *\n * Handlers registered here are collected eagerly and bound to Notebook Navigator once the workspace\n * layout is ready. When Notebook Navigator is not installed the component simply stays dormant.\n *\n * Every collected handler writes into a plugin-titled parent entry's submenu, so a handler must NOT\n * declare a section submenu of its own \u2014 `Menu.sort()` would fold that into a second, nested\n * plugin-titled entry. `CommandHandlerComponent` takes care of this by forcing\n * `CommandHandlerRegistrationContext.shouldAddCommandToSubmenu` off for the surfaces it feeds here.\n */\nexport class NotebookNavigatorMenuEventRegistrarComponent extends LayoutReadyComponent implements MenuEventRegistrar {\n  /**\n   * The plugin's display name, which titles the parent entry.\n   */\n  protected readonly pluginName: string;\n\n  /**\n   * The icon for the parent entry.\n   */\n  protected readonly submenuIcon: IconName;\n\n  private fileMenuEventHandlers: FileMenuEventHandler[] = [];\n  private filesMenuEventHandlers: FilesMenuEventHandler[] = [];\n\n  /**\n   * Creates a new Notebook Navigator menu event registrar.\n   *\n   * @param params - The parameters for the component.\n   */\n  public constructor(params: NotebookNavigatorMenuEventRegistrarComponentConstructorParams) {\n    super(params.app);\n    this.pluginName = params.pluginName;\n    this.submenuIcon = params.submenuIcon ?? '';\n  }\n\n  /**\n   * Accepts an editor-menu registration and does nothing with it.\n   *\n   * Notebook Navigator extends the file tree, not the editor \u2014 an editor menu there is Obsidian's\n   * own, which the handlers already reach through the workspace event. The registration is inert\n   * rather than refused so a handler that declares one is not a load-time error.\n   *\n   * @param _handler - The handler, deliberately unused.\n   * @returns A {@link DisposableEx} that has nothing to undo.\n   */\n  public registerEditorMenuEventHandler(_handler: EditorMenuEventHandler): DisposableEx {\n    return new CallbackDisposable({ callback: noop });\n  }\n\n  /**\n   * Collects a single-file menu handler.\n   *\n   * @param handler - The handler to collect.\n   * @returns A {@link DisposableEx} that drops the handler again (or on component unload).\n   */\n  public registerFileMenuEventHandler(handler: FileMenuEventHandler): DisposableEx {\n    this.fileMenuEventHandlers.push(handler);\n    return this.registerDisposable(\n      new CallbackDisposable({\n        callback: (): void => {\n          this.fileMenuEventHandlers = this.fileMenuEventHandlers.filter((collected) => collected !== handler);\n        }\n      })\n    );\n  }\n\n  /**\n   * Collects a multi-file menu handler.\n   *\n   * @param handler - The handler to collect.\n   * @returns A {@link DisposableEx} that drops the handler again (or on component unload).\n   */\n  public registerFilesMenuEventHandler(handler: FilesMenuEventHandler): DisposableEx {\n    this.filesMenuEventHandlers.push(handler);\n    return this.registerDisposable(\n      new CallbackDisposable({\n        callback: (): void => {\n          this.filesMenuEventHandlers = this.filesMenuEventHandlers.filter((collected) => collected !== handler);\n        }\n      })\n    );\n  }\n\n  /**\n   * Accepts a markdown-viewport-menu registration and does nothing with it.\n   *\n   * Notebook Navigator extends the file tree, not the editor \u2014 the margin beside a note's text is\n   * Obsidian's own viewport, which the handlers already reach through the workspace event. The\n   * registration is inert rather than refused so a handler that declares one is not a load-time error.\n   *\n   * @param _handler - The handler, deliberately unused.\n   * @returns A {@link DisposableEx} that has nothing to undo.\n   */\n  public registerMarkdownViewportMenuEventHandler(_handler: MarkdownViewportMenuEventHandler): DisposableEx {\n    return new CallbackDisposable({ callback: noop });\n  }\n\n  /**\n   * Binds to Notebook Navigator once every plugin has loaded.\n   *\n   * Layout-ready rather than `onload`: plugin load order is not ours to choose, and Notebook\n   * Navigator's API only exists once its own plugin is up. When it is not installed the component\n   * stays dormant \u2014 enabling it later takes an Obsidian reload, exactly as it does for anything else\n   * that reads another plugin at startup.\n   */\n  protected override onLayoutReady(): void {\n    const api = resolveNotebookNavigatorApi(this.app);\n    if (api === null) {\n      return;\n    }\n\n    this.register(api.menus.registerFileMenu((context) => {\n      this.handleFileMenu(context);\n    }));\n    this.register(api.menus.registerFolderMenu((context) => {\n      this.handleFolderMenu(context);\n    }));\n  }\n\n  /**\n   * Adds the plugin's entry, unless the handlers had nothing to contribute.\n   *\n   * The menu is populated TWICE, and both runs are needed: Notebook Navigator's `addItem` cannot be\n   * taken back once called, so the only way to keep an unrelated file's menu clean is to ask the\n   * handlers first, against a menu nobody sees. The gates they answer with are metadata reads, so the\n   * second run costs nothing and cannot disagree with the first.\n   *\n   * @param context - The Notebook Navigator menu being built.\n   * @param populate - Runs the collected handlers against a menu.\n   */\n  private contribute(context: NotebookNavigatorMenuContext, populate: (menu: Menu) => void): void {\n    const probeMenu = new MenuImpl();\n    populate(probeMenu);\n\n    if (probeMenu.items.length === 0) {\n      return;\n    }\n\n    context.addItem((item) => {\n      item\n        .setTitle(this.pluginName)\n        .setIcon(this.submenuIcon);\n      populate(item.setSubmenu());\n    });\n  }\n\n  /**\n   * Handles a file menu, single or multi-selection.\n   *\n   * @param context - The Notebook Navigator menu being built.\n   */\n  private handleFileMenu(context: NotebookNavigatorFileMenuContext): void {\n    const selectedFiles: TFile[] = [...context.selection.files];\n    this.contribute(\n      context,\n      context.selection.mode === 'multiple'\n        ? (menu: Menu): void => {\n          this.runFilesMenuHandlers(menu, selectedFiles);\n        }\n        : (menu: Menu): void => {\n          this.runFileMenuHandlers(menu, context.file);\n        }\n    );\n  }\n\n  /**\n   * Handles a folder menu.\n   *\n   * A folder goes through the SINGLE-file handlers, because that is how Obsidian's own `file-menu`\n   * carries one \u2014 the event is typed {@link TAbstractFile}, and the folder handlers are the ones that\n   * narrow it.\n   *\n   * @param context - The Notebook Navigator menu being built.\n   */\n  private handleFolderMenu(context: NotebookNavigatorFolderMenuContext): void {\n    this.contribute(context, (menu: Menu): void => {\n      this.runFileMenuHandlers(menu, context.folder);\n    });\n  }\n\n  /**\n   * Runs the single-file handlers against a menu.\n   *\n   * @param menu - The menu to populate.\n   * @param abstractFile - The file or folder the menu was raised on.\n   */\n  private runFileMenuHandlers(menu: Menu, abstractFile: TAbstractFile): void {\n    for (const handler of this.fileMenuEventHandlers) {\n      handler(menu, abstractFile, NOTEBOOK_NAVIGATOR_MENU_SOURCE);\n    }\n  }\n\n  /**\n   * Runs the multi-file handlers against a menu.\n   *\n   * @param menu - The menu to populate.\n   * @param abstractFiles - The files the menu was raised on.\n   */\n  private runFilesMenuHandlers(menu: Menu, abstractFiles: TAbstractFile[]): void {\n    for (const handler of this.filesMenuEventHandlers) {\n      handler(menu, abstractFiles, NOTEBOOK_NAVIGATOR_MENU_SOURCE);\n    }\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,wBAAmC;AACnC,sBAAqB;AACrB,sBAAiC;AAejC,gCAGO;AACP,oCAAqC;AAmC9B,MAAM,qDAAqD,mDAAmD;AAAA;AAAA;AAAA;AAAA,EAIhG;AAAA;AAAA;AAAA;AAAA,EAKA;AAAA,EAEX,wBAAgD,CAAC;AAAA,EACjD,yBAAkD,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOpD,YAAY,QAAuE;AACxF,UAAM,OAAO,GAAG;AAChB,SAAK,aAAa,OAAO;AACzB,SAAK,cAAc,OAAO,eAAe;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,+BAA+B,UAAgD;AACpF,WAAO,IAAI,qCAAmB,EAAE,UAAU,qBAAK,CAAC;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,6BAA6B,SAA6C;AAC/E,SAAK,sBAAsB,KAAK,OAAO;AACvC,WAAO,KAAK;AAAA,MACV,IAAI,qCAAmB;AAAA,QACrB,UAAU,MAAY;AACpB,eAAK,wBAAwB,KAAK,sBAAsB,OAAO,CAAC,cAAc,cAAc,OAAO;AAAA,QACrG;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQO,8BAA8B,SAA8C;AACjF,SAAK,uBAAuB,KAAK,OAAO;AACxC,WAAO,KAAK;AAAA,MACV,IAAI,qCAAmB;AAAA,QACrB,UAAU,MAAY;AACpB,eAAK,yBAAyB,KAAK,uBAAuB,OAAO,CAAC,cAAc,cAAc,OAAO;AAAA,QACvG;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,yCAAyC,UAA0D;AACxG,WAAO,IAAI,qCAAmB,EAAE,UAAU,qBAAK,CAAC;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUmB,gBAAsB;AACvC,UAAM,UAAM,uDAA4B,KAAK,GAAG;AAChD,QAAI,QAAQ,MAAM;AAChB;AAAA,IACF;AAEA,SAAK,SAAS,IAAI,MAAM,iBAAiB,CAAC,YAAY;AACpD,WAAK,eAAe,OAAO;AAAA,IAC7B,CAAC,CAAC;AACF,SAAK,SAAS,IAAI,MAAM,mBAAmB,CAAC,YAAY;AACtD,WAAK,iBAAiB,OAAO;AAAA,IAC/B,CAAC,CAAC;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaQ,WAAW,SAAuC,UAAsC;AAC9F,UAAM,YAAY,IAAI,gBAAAA,KAAS;AAC/B,aAAS,SAAS;AAElB,QAAI,UAAU,MAAM,WAAW,GAAG;AAChC;AAAA,IACF;AAEA,YAAQ,QAAQ,CAAC,SAAS;AACxB,WACG,SAAS,KAAK,UAAU,EACxB,QAAQ,KAAK,WAAW;AAC3B,eAAS,KAAK,WAAW,CAAC;AAAA,IAC5B,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,eAAe,SAAiD;AACtE,UAAM,gBAAyB,CAAC,GAAG,QAAQ,UAAU,KAAK;AAC1D,SAAK;AAAA,MACH;AAAA,MACA,QAAQ,UAAU,SAAS,aACvB,CAAC,SAAqB;AACtB,aAAK,qBAAqB,MAAM,aAAa;AAAA,MAC/C,IACE,CAAC,SAAqB;AACtB,aAAK,oBAAoB,MAAM,QAAQ,IAAI;AAAA,MAC7C;AAAA,IACJ;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWQ,iBAAiB,SAAmD;AAC1E,SAAK,WAAW,SAAS,CAAC,SAAqB;AAC7C,WAAK,oBAAoB,MAAM,QAAQ,MAAM;AAAA,IAC/C,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQQ,oBAAoB,MAAY,cAAmC;AACzE,eAAW,WAAW,KAAK,uBAAuB;AAChD,cAAQ,MAAM,cAAc,wDAA8B;AAAA,IAC5D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQQ,qBAAqB,MAAY,eAAsC;AAC7E,eAAW,WAAW,KAAK,wBAAwB;AACjD,cAAQ,MAAM,eAAe,wDAA8B;AAAA,IAC7D;AAAA,EACF;AACF;",
  "names": ["MenuImpl"]
}
