obsidian-dev-utils 88.8.0 → 90.0.0

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

@@ -0,0 +1,297 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // 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
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  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_obsidian = require('obsidian');
+var import_disposable = require('../../disposable.cjs');
+var import_function = require('../../function.cjs');
+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);
+        }
+      })
+    );
+  }
+  /**
+   * 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/obsidian/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 {\n  App,\n  IconName,\n  Menu,\n  TAbstractFile,\n  TFile\n} from 'obsidian';\n\nimport { Menu as MenuImpl } from 'obsidian';\n\nimport type { DisposableEx } from '../../disposable.ts';\nimport type {\n  EditorMenuEventHandler,\n  FileMenuEventHandler,\n  FilesMenuEventHandler,\n  MenuEventRegistrar\n} from '../menu-event-registrar.ts';\nimport type {\n  NotebookNavigatorFileMenuContext,\n  NotebookNavigatorFolderMenuContext,\n  NotebookNavigatorMenuContext\n} from '../notebook-navigator.ts';\n\nimport { CallbackDisposable } from '../../disposable.ts';\nimport { noop } from '../../function.ts';\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   * 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": "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",
  "names": ["MenuImpl"]
}


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

@@ -0,0 +1,139 @@
+/// <reference path="../../library.d.cts" />
+/**
+ * @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 { App, IconName } from 'obsidian' with { 'resolution-mode': 'import' };
+import type { DisposableEx } from '../../disposable.cjs';
+import type { EditorMenuEventHandler, FileMenuEventHandler, FilesMenuEventHandler, MenuEventRegistrar } from '../menu-event-registrar.cjs';
+import { LayoutReadyComponent } from './layout-ready-component.cjs';
+/**
+ * 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;
+    /**
+     * 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;
+}

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

@@ -40,16 +40,11 @@ if you want to view the source, please visit the github repository of this plugi
     globalThisRecord[key] ??= newFuncs[key]?.();
   }
 
-  function name(obj) {
-    return obj;
-  }
-
   function extractDefault(module) {
     return module && module.__esModule && 'default' in module ? module.default : module;
   }
 
-  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
-  'obsidian',
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
   '@codemirror/autocomplete',
   '@codemirror/collab',
   '@codemirror/commands',
@@ -60,11 +55,12 @@ if you want to view the source, please visit the github repository of this plugi
   '@codemirror/text',
   '@codemirror/view',
   '@lezer/common',
+  '@lezer/highlight',
   '@lezer/lr',
-  '@lezer/highlight'];
-
+  'obsidian']
+  );
 
-  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = new Set([
   '@codemirror/closebrackets',
   '@codemirror/comment',
   '@codemirror/fold',
@@ -76,11 +72,11 @@ if you want to view the source, please visit the github repository of this plugi
   '@codemirror/rangeset',
   '@codemirror/rectangular-selection',
   '@codemirror/stream-parser',
-  '@codemirror/tooltip'];
-
+  '@codemirror/tooltip']
+  );
 
   function requirePatched(id) {
-    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
       return originalRequire?.(id);
     }
 
@@ -89,8 +85,8 @@ if you want to view the source, please visit the github repository of this plugi
       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.`);
-        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
-        return globalThis.process;
+
+        return process;
       }
     } else {
       const module = originalRequire?.(id);
@@ -168,4 +164,4 @@ class PluginContextComponent extends import_component_ex.ComponentEx {
 0 && (module.exports = {
   PluginContextComponent
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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