@mnaoumov/obsidian-lib 6.2.1 → 6.3.0

package/dist/lib/cjs/components/file-explorer-root-menu-component.cjs

@@ -0,0 +1,343 @@
+/*
+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 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;
+}
+
+ensureBrowserProcess();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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);
+    }
+    const app = globalThis.app;
+    if (app?.isMobile) {
+      if (id === "process" || id === "node:process") {
+        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);
+      }
+    }
+    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 file_explorer_root_menu_component_exports = {};
+__export(file_explorer_root_menu_component_exports, {
+  FileExplorerRootMenuComponent: () => FileExplorerRootMenuComponent,
+  FileExplorerRootMenuSpot: () => FileExplorerRootMenuSpot,
+  VAULT_NAME_SELECTORS: () => VAULT_NAME_SELECTORS
+});
+module.exports = __toCommonJS(file_explorer_root_menu_component_exports);
+var import_async = require('@mnaoumov/typescript-lib/async');
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_implementations = require('@obsidian-typings/obsidian-public-latest/implementations');
+var import_obsidian = require('obsidian');
+var import_obsidian_lib_state = require('../obsidian-lib-state.cjs');
+var import_component_ex = require('./component-ex.cjs');
+var import_monkey_around_component = require('./monkey-around-component.cjs');
+const VAULT_NAME_SELECTORS = [
+  ".workspace-drawer-vault-switcher",
+  ".workspace-drawer-header-name"
+];
+const FILE_EXPLORER_MENU_SOURCE = "file-explorer-context-menu";
+const ROOT_UNSAFE_ITEM_TITLE_KEYS = [
+  "plugins.file-explorer.action-move-folder",
+  "plugins.file-explorer.menu-opt-delete",
+  "plugins.file-explorer.menu-opt-make-copy",
+  "plugins.file-explorer.menu-opt-rename",
+  "plugins.search.menu-opt-search-in-folder"
+];
+const SHARED_STATE_KEY = "fileExplorerRootMenuByAppV1";
+var FileExplorerRootMenuSpot = /* @__PURE__ */ ((FileExplorerRootMenuSpot2) => {
+  FileExplorerRootMenuSpot2["EmptyArea"] = "empty-area";
+  FileExplorerRootMenuSpot2["VaultName"] = "vault-name";
+  return FileExplorerRootMenuSpot2;
+})(FileExplorerRootMenuSpot || {});
+class FileExplorerRootMenuComponent extends import_component_ex.ComponentEx {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * Called each time the vault-root menu is about to be shown.
+   */
+  handler;
+  /**
+   * Whether the root is presented as an ordinary folder while its menu is built.
+   */
+  shouldPresentRootAsFolder;
+  /**
+   * Creates a new file explorer root menu component.
+   *
+   * @param params - The parameters.
+   */
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this.handler = params.handler;
+    this.shouldPresentRootAsFolder = params.shouldPresentRootAsFolder ?? false;
+  }
+  /**
+   * Subscribes to the shared installation, installing it when nobody has yet.
+   */
+  onload() {
+    super.onload();
+    const state = getSharedState(this.app);
+    const subscription = {
+      handler: this.handler,
+      install: () => installRootMenu(this.app, state),
+      shouldPresentRootAsFolder: this.shouldPresentRootAsFolder
+    };
+    state.subscriptions.push(subscription);
+    state.installation ??= { owner: subscription, uninstall: subscription.install() };
+    this.register(() => {
+      state.subscriptions.splice(state.subscriptions.indexOf(subscription), 1);
+      if (state.installation?.owner !== subscription) {
+        return;
+      }
+      state.installation.uninstall();
+      const nextOwner = state.subscriptions[0];
+      state.installation = nextOwner ? { owner: nextOwner, uninstall: nextOwner.install() } : null;
+    });
+  }
+}
+function dispatch(state, params) {
+  if (state.subscriptions.some((subscription) => subscription.shouldPresentRootAsFolder)) {
+    removeRootUnsafeItems(params.menu);
+  }
+  for (const subscription of [...state.subscriptions]) {
+    try {
+      subscription.handler(params);
+    } catch (error) {
+      console.error("A file explorer root menu handler failed", error);
+    }
+  }
+}
+function dispatchBeforeShow(state, params) {
+  const uninstallShowPatch = (0, import_monkey_around_component.around)(params.menu, {
+    showAtMouseEvent: (next) => function patchedShowAtMouseEvent(showMouseEvent) {
+      uninstallShowPatch();
+      dispatch(state, params);
+      return params.menu.items.length === 0 ? this : next.call(this, showMouseEvent);
+    }
+  });
+}
+function getFileExplorerLeaf(app) {
+  return app.workspace.getLeavesOfType(import_implementations.ViewType.FileExplorer)[0] ?? null;
+}
+function getSharedState(app) {
+  const statesByApp = (0, import_obsidian_lib_state.getObsidianLibState)(SHARED_STATE_KEY, /* @__PURE__ */ new WeakMap()).value;
+  let state = statesByApp.get(app);
+  if (!state) {
+    state = { installation: null, subscriptions: [] };
+    statesByApp.set(app, state);
+  }
+  return state;
+}
+function installRootMenu(app, state) {
+  let isUninstalled = false;
+  let pendingSpot = null;
+  let uninstallPatch = null;
+  function tryPatch() {
+    if (isUninstalled || uninstallPatch) {
+      return;
+    }
+    const view = getFileExplorerLeaf(app)?.view;
+    if (!isFileExplorerView(view)) {
+      return;
+    }
+    uninstallPatch = (0, import_monkey_around_component.around)((0, import_object_utils.getPrototypeOf)(view), {
+      onFileContextMenu: (next) => function patchedOnFileContextMenu(mouseEvent, file) {
+        if (!(file instanceof import_obsidian.TFolder) || !file.isRoot()) {
+          next.call(this, mouseEvent, file);
+          return;
+        }
+        openRootMenu({
+          mouseEvent,
+          openNative: () => {
+            next.call(this, mouseEvent, file);
+          },
+          rootFolder: file,
+          spot: pendingSpot ?? "empty-area" /* EmptyArea */
+        });
+      }
+    });
+  }
+  function openRootMenu(params) {
+    const { mouseEvent, openNative, rootFolder, spot } = params;
+    const eventRef = app.workspace.on("file-menu", (menu, file, source) => {
+      if (file !== rootFolder || source !== FILE_EXPLORER_MENU_SOURCE) {
+        return;
+      }
+      app.workspace.offref(eventRef);
+      dispatchBeforeShow(state, { menu, mouseEvent, rootFolder, spot });
+    });
+    const restoreIsRoot = state.subscriptions.some((subscription) => subscription.shouldPresentRootAsFolder) ? presentAsFolder(rootFolder) : null;
+    try {
+      openNative();
+    } finally {
+      restoreIsRoot?.();
+      app.workspace.offref(eventRef);
+    }
+  }
+  function openFromVaultName(mouseEvent) {
+    const isOnVaultName = mouseEvent.composedPath().some((target) => target instanceof HTMLElement && VAULT_NAME_SELECTORS.some((selector) => target.matches(selector)));
+    if (!isOnVaultName) {
+      return;
+    }
+    const vaultMenu = import_obsidian.Menu.forEvent(mouseEvent);
+    const rootFolder = app.vault.getRoot();
+    const leaf = getFileExplorerLeaf(app);
+    if (!leaf || state.subscriptions.every((subscription) => !subscription.shouldPresentRootAsFolder)) {
+      dispatchBeforeShow(state, { menu: vaultMenu, mouseEvent, rootFolder, spot: "vault-name" /* VaultName */ });
+      return;
+    }
+    function suppressVaultMenuShow() {
+      uninstallVaultMenuShowPatch();
+      return vaultMenu;
+    }
+    const uninstallVaultMenuShowPatch = (0, import_monkey_around_component.around)(vaultMenu, { showAtMouseEvent: () => suppressVaultMenuShow });
+    (0, import_async.invokeAsyncSafely)(async () => {
+      await leaf.loadIfDeferred();
+      const view = leaf.view;
+      if (isUninstalled || !isFileExplorerView(view)) {
+        return;
+      }
+      tryPatch();
+      view.tree.clearSelectedDoms();
+      pendingSpot = "vault-name" /* VaultName */;
+      try {
+        view.onFileContextMenu(mouseEvent, rootFolder);
+      } finally {
+        pendingSpot = null;
+      }
+    });
+  }
+  tryPatch();
+  const layoutChangeEventRef = app.workspace.on("layout-change", tryPatch);
+  app.workspace.onLayoutReady(tryPatch);
+  const doc = app.workspace.containerEl.doc;
+  doc.addEventListener("contextmenu", openFromVaultName, { capture: true });
+  return () => {
+    isUninstalled = true;
+    uninstallPatch?.();
+    app.workspace.offref(layoutChangeEventRef);
+    doc.removeEventListener("contextmenu", openFromVaultName, { capture: true });
+  };
+}
+function isFileExplorerView(view) {
+  return typeof view?.onFileContextMenu === "function";
+}
+function presentAsFolder(rootFolder) {
+  const ownIsRootDescriptor = Object.getOwnPropertyDescriptor(rootFolder, "isRoot");
+  rootFolder.isRoot = () => false;
+  return () => {
+    if (ownIsRootDescriptor) {
+      Object.defineProperty(rootFolder, "isRoot", ownIsRootDescriptor);
+    } else {
+      delete rootFolder.isRoot;
+    }
+  };
+}
+function removeRootUnsafeItems(menu) {
+  const unsafeTitles = new Set(ROOT_UNSAFE_ITEM_TITLE_KEYS.map((key) => activeWindow.i18next.t(key)));
+  menu.items = menu.items.filter((item) => !(item instanceof import_obsidian.MenuItem) || !unsafeTitles.has(item.titleEl.textContent));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileExplorerRootMenuComponent,
+  FileExplorerRootMenuSpot,
+  VAULT_NAME_SELECTORS
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/file-explorer-root-menu-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Opens and extends the core File Explorer's context menu for the vault root, at the two spots that stand for it: the\n * vault name at the top of the left sidebar, and the empty area below the file list.\n *\n * Obsidian already opens a menu for the empty area: the view's own `contextmenu` listener on its files container calls\n * `onFileContextMenu(evt, vault.getRoot())`, which builds a {@link Menu}, triggers `file-menu` with the root folder and\n * the source `file-explorer-context-menu`, and shows it. The vault name (`.workspace-drawer-vault-switcher` on desktop,\n * `.workspace-drawer-header-name` on mobile, where Obsidian builds no switcher) opens a different menu: on desktop\n * Obsidian adds `Show in system explorer` and `Copy path` to the per-event menu `Menu.forEvent` hands out. The handlers\n * get that menu, so a right-click there never opens a second one. A subscriber that presents the root as a folder\n * replaces it with the root's folder menu instead. Read from Obsidian `1.15.0`.\n *\n * Every plugin bundles its own copy of this library, and several of them may want this menu. Two copies patching the\n * same prototype and listening on the same element would open it twice, so there is ONE installation per {@link App},\n * kept in the shared-state bag under a versioned key and owned by one subscriber. When the owner unloads while others\n * remain, the next subscriber installs it again from its own copy. What crosses that boundary is a wire format between\n * copies of different versions: plain objects and plain functions only, read structurally, and a change to what a field\n * means moves to a new key rather than reinterpreting the old one.\n */\n\nimport type { FileExplorerView } from '@obsidian-typings/obsidian-public-latest';\nimport type {\n  App,\n  TAbstractFile,\n  WorkspaceLeaf\n} from 'obsidian';\n\nimport { invokeAsyncSafely } from '@mnaoumov/typescript-lib/async';\nimport { getPrototypeOf } from '@mnaoumov/typescript-lib/object-utils';\nimport { ViewType } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport {\n  Menu,\n  MenuItem,\n  TFolder\n} from 'obsidian';\n\nimport { getObsidianLibState } from '../obsidian-lib-state.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { around } from './monkey-around-component.ts';\n\n/**\n * The elements that stand for the vault root at the top of the left sidebar, in priority order. Obsidian builds\n * `.workspace-drawer-vault-switcher` only on desktop; on mobile the vault name is the drawer header instead.\n */\nexport const VAULT_NAME_SELECTORS = [\n  '.workspace-drawer-vault-switcher',\n  '.workspace-drawer-header-name'\n] as const;\n\n/**\n * The `source` Obsidian passes with `file-menu` when the File Explorer opens a menu.\n */\nconst FILE_EXPLORER_MENU_SOURCE = 'file-explorer-context-menu';\n\n/**\n * The menu items that must not act on the vault root, by the localization key of their title. They appear only when\n * the root is presented as an ordinary folder, from Obsidian itself or from another plugin's `file-menu` handler.\n */\nconst ROOT_UNSAFE_ITEM_TITLE_KEYS = [\n  'plugins.file-explorer.action-move-folder',\n  'plugins.file-explorer.menu-opt-delete',\n  'plugins.file-explorer.menu-opt-make-copy',\n  'plugins.file-explorer.menu-opt-rename',\n  'plugins.search.menu-opt-search-in-folder'\n] as const;\n\nconst SHARED_STATE_KEY = 'fileExplorerRootMenuByAppV1';\n\n/**\n * Which spot of the File Explorer the vault-root menu was opened from.\n */\nexport enum FileExplorerRootMenuSpot {\n  /**\n   * The empty area below the file list.\n   */\n  EmptyArea = 'empty-area',\n\n  /**\n   * The vault name at the top of the left sidebar.\n   */\n  VaultName = 'vault-name'\n}\n\n/**\n * Parameters for {@link FileExplorerRootMenuComponent}.\n */\nexport interface FileExplorerRootMenuComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * Called each time the vault-root menu is about to be shown.\n   */\n  readonly handler: FileExplorerRootMenuHandler;\n\n  /**\n   * Whether the root is presented as an ordinary folder while its menu is built, so that Obsidian and other plugins add\n   * the items they add to any folder. The items that must not act on the root (rename, delete, move, make a copy and\n   * search in folder) are removed again before the menu is shown. On the vault name, the root's folder menu then replaces\n   * Obsidian's vault menu. It holds while any subscriber asks for it.\n   *\n   * @default `false`\n   */\n  readonly shouldPresentRootAsFolder?: boolean;\n}\n\n/**\n * A handler of the vault-root menu.\n *\n * @param params - The parameters.\n */\nexport type FileExplorerRootMenuHandler = (params: FileExplorerRootMenuHandlerParams) => void;\n\n/**\n * Parameters for a {@link FileExplorerRootMenuHandler}.\n *\n * The shape is part of the wire format between copies of this library: fields are only ever added.\n */\nexport interface FileExplorerRootMenuHandlerParams {\n  /**\n   * The menu, about to be shown: the root's folder menu, after every `file-menu` handler has run, or on the vault name the\n   * vault menu Obsidian builds there. A menu still empty after every handler is not shown.\n   */\n  readonly menu: Menu;\n\n  /**\n   * The right-click or long-press that opened the menu.\n   */\n  readonly mouseEvent: MouseEvent;\n\n  /**\n   * The vault root.\n   */\n  readonly rootFolder: TFolder;\n\n  /**\n   * Which spot the menu was opened from.\n   */\n  readonly spot: FileExplorerRootMenuSpot;\n}\n\ninterface FileExplorerRootMenuInstallation {\n  readonly owner: FileExplorerRootMenuSubscription;\n  uninstall: () => void;\n}\n\ninterface FileExplorerRootMenuSharedState {\n  installation: FileExplorerRootMenuInstallation | null;\n  readonly subscriptions: FileExplorerRootMenuSubscription[];\n}\n\ninterface FileExplorerRootMenuSubscription {\n  handler: (params: FileExplorerRootMenuHandlerParams) => void;\n  install: () => () => void;\n  readonly shouldPresentRootAsFolder: boolean;\n}\n\ninterface FileExplorerViewWithContextMenu extends FileExplorerView {\n  onFileContextMenu: (mouseEvent: MouseEvent, file: TAbstractFile) => void;\n}\n\ninterface OpenRootMenuParams {\n  readonly mouseEvent: MouseEvent;\n  readonly openNative: () => void;\n  readonly rootFolder: TFolder;\n  readonly spot: FileExplorerRootMenuSpot;\n}\n\n/**\n * Hands the core File Explorer's vault-root menu to a handler, and opens that menu from the vault name too.\n *\n * Any number of these, in any number of plugins, share one installation per {@link App}.\n */\nexport class FileExplorerRootMenuComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * Called each time the vault-root menu is about to be shown.\n   */\n  protected readonly handler: FileExplorerRootMenuHandler;\n\n  /**\n   * Whether the root is presented as an ordinary folder while its menu is built.\n   */\n  protected readonly shouldPresentRootAsFolder: boolean;\n\n  /**\n   * Creates a new file explorer root menu component.\n   *\n   * @param params - The parameters.\n   */\n  public constructor(params: FileExplorerRootMenuComponentConstructorParams) {\n    super();\n    this.app = params.app;\n    this.handler = params.handler;\n    this.shouldPresentRootAsFolder = params.shouldPresentRootAsFolder ?? false;\n  }\n\n  /**\n   * Subscribes to the shared installation, installing it when nobody has yet.\n   */\n  public override onload(): void {\n    super.onload();\n\n    const state = getSharedState(this.app);\n    const subscription: FileExplorerRootMenuSubscription = {\n      handler: this.handler,\n      install: () => installRootMenu(this.app, state),\n      shouldPresentRootAsFolder: this.shouldPresentRootAsFolder\n    };\n    state.subscriptions.push(subscription);\n    state.installation ??= { owner: subscription, uninstall: subscription.install() };\n\n    this.register(() => {\n      state.subscriptions.splice(state.subscriptions.indexOf(subscription), 1);\n      if (state.installation?.owner !== subscription) {\n        return;\n      }\n\n      state.installation.uninstall();\n      const nextOwner = state.subscriptions[0];\n      state.installation = nextOwner ? { owner: nextOwner, uninstall: nextOwner.install() } : null;\n    });\n  }\n}\n\nfunction dispatch(state: FileExplorerRootMenuSharedState, params: FileExplorerRootMenuHandlerParams): void {\n  if (state.subscriptions.some((subscription) => subscription.shouldPresentRootAsFolder)) {\n    removeRootUnsafeItems(params.menu);\n  }\n\n  // A snapshot: a handler may unload its own component, or another one, while the menu is dispatched.\n  // eslint-disable-next-line unicorn/no-useless-spread -- The copy is the point: the list may change during the loop.\n  for (const subscription of [...state.subscriptions]) {\n    try {\n      subscription.handler(params);\n    } catch (error) {\n      console.error('A file explorer root menu handler failed', error);\n    }\n  }\n}\n\nfunction dispatchBeforeShow(state: FileExplorerRootMenuSharedState, params: FileExplorerRootMenuHandlerParams): void {\n  const uninstallShowPatch = around(params.menu, {\n    showAtMouseEvent: (next) =>\n      function patchedShowAtMouseEvent(this: Menu, showMouseEvent: MouseEvent): Menu {\n        uninstallShowPatch();\n        dispatch(state, params);\n        return params.menu.items.length === 0 ? this : next.call(this, showMouseEvent);\n      }\n  });\n}\n\nfunction getFileExplorerLeaf(app: App): null | WorkspaceLeaf {\n  return app.workspace.getLeavesOfType(ViewType.FileExplorer)[0] ?? null;\n}\n\nfunction getSharedState(app: App): FileExplorerRootMenuSharedState {\n  const statesByApp = getObsidianLibState(SHARED_STATE_KEY, new WeakMap<App, FileExplorerRootMenuSharedState>()).value;\n  let state = statesByApp.get(app);\n  if (!state) {\n    state = { installation: null, subscriptions: [] };\n    statesByApp.set(app, state);\n  }\n  return state;\n}\n\nfunction installRootMenu(app: App, state: FileExplorerRootMenuSharedState): () => void {\n  let isUninstalled = false;\n  let pendingSpot: FileExplorerRootMenuSpot | null = null;\n  let uninstallPatch: (() => void) | null = null;\n\n  function tryPatch(): void {\n    if (isUninstalled || uninstallPatch) {\n      return;\n    }\n\n    const view = getFileExplorerLeaf(app)?.view;\n    if (!isFileExplorerView(view)) {\n      return;\n    }\n\n    uninstallPatch = around(getPrototypeOf(view), {\n      onFileContextMenu: (next) =>\n        function patchedOnFileContextMenu(this: FileExplorerViewWithContextMenu, mouseEvent: MouseEvent, file: TAbstractFile): void {\n          if (!(file instanceof TFolder) || !file.isRoot()) {\n            next.call(this, mouseEvent, file);\n            return;\n          }\n\n          openRootMenu({\n            mouseEvent,\n            openNative: () => {\n              next.call(this, mouseEvent, file);\n            },\n            rootFolder: file,\n            spot: pendingSpot ?? FileExplorerRootMenuSpot.EmptyArea\n          });\n        }\n    });\n  }\n\n  function openRootMenu(params: OpenRootMenuParams): void {\n    const { mouseEvent, openNative, rootFolder, spot } = params;\n    const eventRef = app.workspace.on('file-menu', (menu, file, source) => {\n      if (file !== rootFolder || source !== FILE_EXPLORER_MENU_SOURCE) {\n        return;\n      }\n\n      app.workspace.offref(eventRef);\n      dispatchBeforeShow(state, { menu, mouseEvent, rootFolder, spot });\n    });\n\n    const restoreIsRoot = state.subscriptions.some((subscription) => subscription.shouldPresentRootAsFolder)\n      ? presentAsFolder(rootFolder)\n      : null;\n\n    try {\n      openNative();\n    } finally {\n      restoreIsRoot?.();\n      app.workspace.offref(eventRef);\n    }\n  }\n\n  function openFromVaultName(mouseEvent: MouseEvent): void {\n    const isOnVaultName = mouseEvent.composedPath().some((target) => target instanceof HTMLElement && VAULT_NAME_SELECTORS.some((selector) => target.matches(selector)));\n    if (!isOnVaultName) {\n      return;\n    }\n\n    // `Menu.forEvent` hands every listener of one event the same menu and shows it on the next task. Obsidian's own\n    // listener on the vault name adds its vault items to it after this capture-phase one has run.\n    const vaultMenu = Menu.forEvent(mouseEvent);\n    const rootFolder = app.vault.getRoot();\n    const leaf = getFileExplorerLeaf(app);\n    if (!leaf || state.subscriptions.every((subscription) => !subscription.shouldPresentRootAsFolder)) {\n      dispatchBeforeShow(state, { menu: vaultMenu, mouseEvent, rootFolder, spot: FileExplorerRootMenuSpot.VaultName });\n      return;\n    }\n\n    // Presented as a folder, the root's folder menu replaces the vault menu rather than opening on top of it.\n    function suppressVaultMenuShow(): Menu {\n      uninstallVaultMenuShowPatch();\n      return vaultMenu;\n    }\n    const uninstallVaultMenuShowPatch = around(vaultMenu, { showAtMouseEvent: () => suppressVaultMenuShow });\n    invokeAsyncSafely(async () => {\n      await leaf.loadIfDeferred();\n      const view = leaf.view;\n      if (isUninstalled || !isFileExplorerView(view)) {\n        return;\n      }\n\n      tryPatch();\n      view.tree.clearSelectedDoms();\n      pendingSpot = FileExplorerRootMenuSpot.VaultName;\n      try {\n        view.onFileContextMenu(mouseEvent, rootFolder);\n      } finally {\n        pendingSpot = null;\n      }\n    });\n  }\n\n  tryPatch();\n  const layoutChangeEventRef = app.workspace.on('layout-change', tryPatch);\n  app.workspace.onLayoutReady(tryPatch);\n  const doc = app.workspace.containerEl.doc;\n  doc.addEventListener('contextmenu', openFromVaultName, { capture: true });\n\n  return () => {\n    isUninstalled = true;\n    uninstallPatch?.();\n    app.workspace.offref(layoutChangeEventRef);\n    doc.removeEventListener('contextmenu', openFromVaultName, { capture: true });\n  };\n}\n\nfunction isFileExplorerView(view: unknown): view is FileExplorerViewWithContextMenu {\n  return typeof (view as Partial<FileExplorerViewWithContextMenu> | undefined)?.onFileContextMenu === 'function';\n}\n\nfunction presentAsFolder(rootFolder: TFolder): () => void {\n  const ownIsRootDescriptor = Object.getOwnPropertyDescriptor(rootFolder, 'isRoot');\n  rootFolder.isRoot = (): boolean => false;\n  return () => {\n    if (ownIsRootDescriptor) {\n      Object.defineProperty(rootFolder, 'isRoot', ownIsRootDescriptor);\n    } else {\n      delete (rootFolder as Partial<TFolder>).isRoot;\n    }\n  };\n}\n\nfunction removeRootUnsafeItems(menu: Menu): void {\n  const unsafeTitles = new Set<null | string>(ROOT_UNSAFE_ITEM_TITLE_KEYS.map((key) => activeWindow.i18next.t(key)));\n  menu.items = menu.items.filter((item) => !(item instanceof MenuItem) || !unsafeTitles.has(item.titleEl.textContent));\n}\n"],"mappings":"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","names":["FileExplorerRootMenuSpot"]}

package/dist/lib/cjs/components/file-explorer-root-menu-component.d.cts

@@ -0,0 +1,125 @@
+/// <reference path="../library-references.d.cts" />
+/// <reference lib="dom" />
+/**
+ * @file
+ *
+ * Opens and extends the core File Explorer's context menu for the vault root, at the two spots that stand for it: the
+ * vault name at the top of the left sidebar, and the empty area below the file list.
+ *
+ * Obsidian already opens a menu for the empty area: the view's own `contextmenu` listener on its files container calls
+ * `onFileContextMenu(evt, vault.getRoot())`, which builds a {@link Menu}, triggers `file-menu` with the root folder and
+ * the source `file-explorer-context-menu`, and shows it. The vault name (`.workspace-drawer-vault-switcher` on desktop,
+ * `.workspace-drawer-header-name` on mobile, where Obsidian builds no switcher) opens a different menu: on desktop
+ * Obsidian adds `Show in system explorer` and `Copy path` to the per-event menu `Menu.forEvent` hands out. The handlers
+ * get that menu, so a right-click there never opens a second one. A subscriber that presents the root as a folder
+ * replaces it with the root's folder menu instead. Read from Obsidian `1.15.0`.
+ *
+ * Every plugin bundles its own copy of this library, and several of them may want this menu. Two copies patching the
+ * same prototype and listening on the same element would open it twice, so there is ONE installation per {@link App},
+ * kept in the shared-state bag under a versioned key and owned by one subscriber. When the owner unloads while others
+ * remain, the next subscriber installs it again from its own copy. What crosses that boundary is a wire format between
+ * copies of different versions: plain objects and plain functions only, read structurally, and a change to what a field
+ * means moves to a new key rather than reinterpreting the old one.
+ */
+import type { App } from 'obsidian' with { 'resolution-mode': 'import' };
+import { Menu, TFolder } from 'obsidian';
+import { ComponentEx } from './component-ex.cjs';
+/**
+ * The elements that stand for the vault root at the top of the left sidebar, in priority order. Obsidian builds
+ * `.workspace-drawer-vault-switcher` only on desktop; on mobile the vault name is the drawer header instead.
+ */
+export declare const VAULT_NAME_SELECTORS: readonly [".workspace-drawer-vault-switcher", ".workspace-drawer-header-name"];
+/**
+ * Which spot of the File Explorer the vault-root menu was opened from.
+ */
+export declare enum FileExplorerRootMenuSpot {
+    /**
+     * The empty area below the file list.
+     */
+    EmptyArea = "empty-area",
+    /**
+     * The vault name at the top of the left sidebar.
+     */
+    VaultName = "vault-name"
+}
+/**
+ * Parameters for {@link FileExplorerRootMenuComponent}.
+ */
+export interface FileExplorerRootMenuComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * Called each time the vault-root menu is about to be shown.
+     */
+    readonly handler: FileExplorerRootMenuHandler;
+    /**
+     * Whether the root is presented as an ordinary folder while its menu is built, so that Obsidian and other plugins add
+     * the items they add to any folder. The items that must not act on the root (rename, delete, move, make a copy and
+     * search in folder) are removed again before the menu is shown. On the vault name, the root's folder menu then replaces
+     * Obsidian's vault menu. It holds while any subscriber asks for it.
+     *
+     * @default `false`
+     */
+    readonly shouldPresentRootAsFolder?: boolean;
+}
+/**
+ * A handler of the vault-root menu.
+ *
+ * @param params - The parameters.
+ */
+export type FileExplorerRootMenuHandler = (params: FileExplorerRootMenuHandlerParams) => void;
+/**
+ * Parameters for a {@link FileExplorerRootMenuHandler}.
+ *
+ * The shape is part of the wire format between copies of this library: fields are only ever added.
+ */
+export interface FileExplorerRootMenuHandlerParams {
+    /**
+     * The menu, about to be shown: the root's folder menu, after every `file-menu` handler has run, or on the vault name the
+     * vault menu Obsidian builds there. A menu still empty after every handler is not shown.
+     */
+    readonly menu: Menu;
+    /**
+     * The right-click or long-press that opened the menu.
+     */
+    readonly mouseEvent: MouseEvent;
+    /**
+     * The vault root.
+     */
+    readonly rootFolder: TFolder;
+    /**
+     * Which spot the menu was opened from.
+     */
+    readonly spot: FileExplorerRootMenuSpot;
+}
+/**
+ * Hands the core File Explorer's vault-root menu to a handler, and opens that menu from the vault name too.
+ *
+ * Any number of these, in any number of plugins, share one installation per {@link App}.
+ */
+export declare class FileExplorerRootMenuComponent extends ComponentEx {
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    /**
+     * Called each time the vault-root menu is about to be shown.
+     */
+    protected readonly handler: FileExplorerRootMenuHandler;
+    /**
+     * Whether the root is presented as an ordinary folder while its menu is built.
+     */
+    protected readonly shouldPresentRootAsFolder: boolean;
+    /**
+     * Creates a new file explorer root menu component.
+     *
+     * @param params - The parameters.
+     */
+    constructor(params: FileExplorerRootMenuComponentConstructorParams);
+    /**
+     * Subscribes to the shared installation, installing it when nobody has yet.
+     */
+    onload(): void;
+}

package/dist/lib/cjs/components/index.cjs

@@ -107,6 +107,7 @@ __export(components_exports, {
   "core-plugin-toggle-component": () => core_plugin_toggle_component,
   "disposable-component": () => disposable_component,
   "embed-extensions-component": () => embed_extensions_component,
+  "file-explorer-root-menu-component": () => file_explorer_root_menu_component,
   "generate-markdown-link-default-params-component": () => generate_markdown_link_default_params_component,
   "layout-ready-component": () => layout_ready_component,
   "menu-event-registrar-component": () => menu_event_registrar_component,
@@ -138,6 +139,7 @@ var console_debug_component = __toESM(((module) => module && module.__esModule &
 var core_plugin_toggle_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./core-plugin-toggle-component.cjs')), 1);
 var disposable_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./disposable-component.cjs')), 1);
 var embed_extensions_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./embed-extensions-component.cjs')), 1);
+var file_explorer_root_menu_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./file-explorer-root-menu-component.cjs')), 1);
 var generate_markdown_link_default_params_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./generate-markdown-link-default-params-component.cjs')), 1);
 var layout_ready_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./layout-ready-component.cjs')), 1);
 var menu_event_registrar_component = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./menu-event-registrar-component.cjs')), 1);
@@ -169,6 +171,7 @@ var templates_language_component = __toESM(((module) => module && module.__esMod
   "core-plugin-toggle-component": null,
   "disposable-component": null,
   "embed-extensions-component": null,
+  "file-explorer-root-menu-component": null,
   "generate-markdown-link-default-params-component": null,
   "layout-ready-component": null,
   "menu-event-registrar-component": null,
@@ -189,4 +192,4 @@ var templates_language_component = __toESM(((module) => module && module.__esMod
   "syntax-highlighting-component": null,
   "templates-language-component": null
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/components/index.d.cts

@@ -9,6 +9,7 @@ export * as 'console-debug-component' from './console-debug-component.cjs';
 export * as 'core-plugin-toggle-component' from './core-plugin-toggle-component.cjs';
 export * as 'disposable-component' from './disposable-component.cjs';
 export * as 'embed-extensions-component' from './embed-extensions-component.cjs';
+export * as 'file-explorer-root-menu-component' from './file-explorer-root-menu-component.cjs';
 export * as 'generate-markdown-link-default-params-component' from './generate-markdown-link-default-params-component.cjs';
 export * as 'layout-ready-component' from './layout-ready-component.cjs';
 export * as 'menu-event-registrar-component' from './menu-event-registrar-component.cjs';