@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

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

@@ -0,0 +1,227 @@
+/*
+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 { CallbackDisposable } from "@mnaoumov/typescript-lib/disposable";
+import { noop } from "@mnaoumov/typescript-lib/function";
+import { Menu as MenuImpl } from "obsidian";
+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);
+        }
+      })
+    );
+  }
+  /**
+   * 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 CallbackDisposable({ callback: 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 = 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/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": "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",
  "names": []
}


package/dist/lib/esm/components/plugin-context-component.d.mts

@@ -0,0 +1,36 @@
+/// <reference path="../library.d.mts" />
+/**
+ * @file
+ *
+ * Component that initializes the plugin context, debug controller, and library styles.
+ */
+import type { App } from 'obsidian';
+import { ComponentEx } from './component-ex.mjs';
+interface PluginContextComponentConstructorParams {
+    readonly app: App;
+    readonly pluginId: string;
+}
+/**
+ * Initializes plugin context (plugin ID, debug controller, library styles) on load.
+ */
+export declare class PluginContextComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * The plugin ID used to initialize the plugin context and debug controller.
+     */
+    protected readonly pluginId: string;
+    /**
+     * Creates a new plugin context component.
+     *
+     * @param params - The constructor parameters.
+     */
+    constructor(params: PluginContextComponentConstructorParams);
+    /**
+     * Initializes the plugin context and debug controller.
+     */
+    onload(): void;
+}
+export {};

package/dist/lib/esm/components/plugin-context-component.mjs

@@ -0,0 +1,86 @@
+/*
+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 { Library } from "@mnaoumov/typescript-lib/library";
+import { ObsidianLibrary } from "../library.mjs";
+import {
+  initDebugController,
+  initPluginContext
+} from "../plugin/plugin-context.mjs";
+import { AllWindowsEventComponent } from "./all-windows-event-component.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+class PluginContextComponent extends ComponentEx {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * The plugin ID used to initialize the plugin context and debug controller.
+   */
+  pluginId;
+  /**
+   * Creates a new plugin context component.
+   *
+   * @param params - The constructor parameters.
+   */
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.pluginId = params.pluginId;
+  }
+  /**
+   * Initializes the plugin context and debug controller.
+   */
+  onload() {
+    initPluginContext(this.pluginId);
+    this.register(() => {
+      Library.resetToDefault();
+      ObsidianLibrary.resetToDefault();
+    });
+    this.addChild(new AllWindowsEventComponent(this.app)).registerAllWindowsHandler((win) => {
+      initDebugController(win, this);
+    });
+  }
+}
+export {
+  PluginContextComponent
+};
+//# sourceMappingURL=data:application/json;base64,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