obsidian-dev-utils 88.7.0 → 89.0.0

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

@@ -0,0 +1,139 @@
+/// <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 { App, IconName } from 'obsidian';
+import type { DisposableEx } from '../../disposable.mjs';
+import type { EditorMenuEventHandler, FileMenuEventHandler, FilesMenuEventHandler, 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;
+    /**
+     * 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/esm/obsidian/components/notebook-navigator-menu-event-registrar-component.mjs

@@ -0,0 +1,196 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initEsm() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  if (globalThis.process) {
+    return;
+  }
+
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  globalThis.process = browserProcess;
+})();
+
+import { Menu as MenuImpl } from "obsidian";
+import { CallbackDisposable } from "../../disposable.mjs";
+import { noop } from "../../function.mjs";
+import {
+  NOTEBOOK_NAVIGATOR_MENU_SOURCE,
+  resolveNotebookNavigatorApi
+} from "../notebook-navigator.mjs";
+import { LayoutReadyComponent } from "./layout-ready-component.mjs";
+class NotebookNavigatorMenuEventRegistrarComponent extends 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 CallbackDisposable({ callback: 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 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 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 = 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 MenuImpl();
+    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, 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, NOTEBOOK_NAVIGATOR_MENU_SOURCE);
+    }
+  }
+}
+export {
+  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": []
}
