@mnaoumov/obsidian-lib 0.0.0 → 1.0.0

package/dist/lib/esm/markdown.mjs

@@ -0,0 +1,399 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+import {
+  invokeAsyncSafely,
+  sleep
+} from "@mnaoumov/typescript-lib/async";
+import {
+  getZIndex,
+  waitUntilConnected
+} from "@mnaoumov/typescript-lib/html-element";
+import { normalizeOptionalProperties } from "@mnaoumov/typescript-lib/object-utils";
+import { isUrl } from "@mnaoumov/typescript-lib/url";
+import { InternalPluginName } from "@obsidian-typings/obsidian-public-latest/implementations";
+import { t } from "i18next";
+import {
+  Component,
+  HoverPopover,
+  Keymap,
+  MarkdownPreviewRenderer,
+  MarkdownRenderer,
+  Menu,
+  Notice
+} from "obsidian";
+import { MonkeyAroundComponent } from "./components/monkey-around-component.mjs";
+import { revealInFileExplorer } from "./file-explorer.mjs";
+import {
+  getAbstractFileOrNull,
+  getPath,
+  isFile,
+  isFolder
+} from "./file-system.mjs";
+import {
+  resolveFolderNote,
+  resolveFolderNoteConfig
+} from "./folder-note.mjs";
+const DELAY_BEFORE_OPEN_IN_MILLISECONDS = 200;
+const EXTERNAL_LINK_MENU_SECTIONS = [
+  "title",
+  "open",
+  "selection",
+  "clipboard",
+  "info",
+  "action",
+  "view",
+  "",
+  "danger"
+];
+const INTERNAL_LINK_MENU_SECTIONS = [
+  "title",
+  "open",
+  "action",
+  "clipboard",
+  "view",
+  "info",
+  "",
+  "danger"
+];
+class EmbedByExtensionMdPatchComponent extends MonkeyAroundComponent {
+  constructor(embedByExtension) {
+    super();
+    this.embedByExtension = embedByExtension;
+  }
+  embedByExtension;
+  onload() {
+    this.registerMethodPatch({
+      $object: this.embedByExtension,
+      methodName: "md",
+      patchHandler: ({
+        fallback,
+        originalArguments: [context]
+      }) => {
+        context.displayMode = false;
+        return fallback();
+      }
+    });
+  }
+}
+class FixedZIndexDomEventsHandlersInfo {
+  app;
+  path;
+  get hoverPopover() {
+    return this._hoverPopover;
+  }
+  set hoverPopover(hoverPopover) {
+    this._hoverPopover = hoverPopover;
+    if (hoverPopover && this.zIndex !== void 0) {
+      hoverPopover.hoverEl.setCssStyles({
+        zIndex: String(this.zIndex)
+      });
+    }
+  }
+  _hoverPopover = null;
+  el;
+  zIndex;
+  constructor(params) {
+    this.app = params.app;
+    this.path = params.path;
+    this.el = params.el;
+    invokeAsyncSafely(async () => {
+      await waitUntilConnected(this.el);
+      this.updateZIndex(this.el);
+    });
+  }
+  updateZIndex(element) {
+    this.zIndex = getZIndex(element) + 1;
+  }
+}
+class LinkDomEventsHandlers {
+  constructor(info) {
+    this.info = info;
+  }
+  info;
+  onExternalLinkClick($event, targetEl, linkText) {
+    $event.preventDefault();
+    if (!isUrl(linkText)) {
+      new Notice(t(($) => $.obsidianDevUtils.notices.failedToOpenUrl, { url: linkText }));
+      return;
+    }
+    const modifierPaneType = Keymap.isModEvent($event);
+    targetEl.win.open(linkText, typeof modifierPaneType === "boolean" ? "" : modifierPaneType);
+  }
+  onExternalLinkRightClick($event, targetEl, linkText) {
+    const menu = Menu.forEvent($event);
+    menu.addSections(EXTERNAL_LINK_MENU_SECTIONS);
+    addCopyMenuItem(menu, targetEl);
+    this.info.app.workspace.handleExternalLinkContextMenu(menu, linkText);
+  }
+  onInternalLinkClick($event, _targetEl, linkText) {
+    $event.preventDefault();
+    invokeAsyncSafely(() => this.info.app.workspace.openLinkText(linkText, this.info.path, Keymap.isModEvent($event)));
+  }
+  onInternalLinkDrag($event, _targetEl, linkText, title) {
+    const dragManager = this.info.app.dragManager;
+    dragManager.onDragStart($event, dragManager.dragLink($event, linkText, this.info.path, title));
+  }
+  onInternalLinkMouseover($event, targetEl, linkText) {
+    this.info.app.workspace.trigger("hover-link", {
+      event: $event,
+      hoverParent: this.info,
+      linktext: linkText,
+      source: "preview",
+      sourcePath: this.info.path,
+      targetEl
+    });
+  }
+  onInternalLinkRightClick($event, targetEl, linkText) {
+    const menu = Menu.forEvent($event);
+    menu.setParentElement(targetEl);
+    menu.addSections(INTERNAL_LINK_MENU_SECTIONS);
+    addCopyMenuItem(menu, targetEl);
+    this.info.app.workspace.handleLinkContextMenu(menu, linkText, this.info.path);
+  }
+  onTagClick(_$event, _targetEl, tag) {
+    this.info.app.internalPlugins.getEnabledPluginById(InternalPluginName.GlobalSearch)?.openGlobalSearch(`tag:${tag}`);
+  }
+}
+async function fullRender(params) {
+  var _stack = [];
+  try {
+    const sourcePath = params.sourcePath ?? "/";
+    let shouldUnloadComponent = false;
+    let component;
+    if (params.component) {
+      component = params.component;
+    } else {
+      component = new Component();
+      component.load();
+      shouldUnloadComponent = true;
+    }
+    const _ = __using(_stack, component.addChild(new EmbedByExtensionMdPatchComponent(params.app.embedRegistry.embedByExtension)));
+    await MarkdownRenderer.render(params.app, params.markdown, params.el, sourcePath, component);
+    if (shouldUnloadComponent) {
+      component.unload();
+    }
+    if (params.shouldRegisterLinkHandlers) {
+      registerLinkHandlers(normalizeOptionalProperties({
+        app: params.app,
+        el: params.el,
+        sourcePath: params.sourcePath
+      }));
+    }
+  } catch (_2) {
+    var _error = _2, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+async function markdownToHtml(params) {
+  const {
+    app,
+    markdown,
+    sourcePath
+  } = params;
+  const component = new Component();
+  component.load();
+  const renderDiv = createDiv();
+  await MarkdownRenderer.render(app, markdown, renderDiv, sourcePath ?? "", component);
+  const html = renderDiv.innerHTML;
+  component.unload();
+  return html;
+}
+function registerLinkHandlers(params) {
+  const {
+    app,
+    el,
+    sourcePath
+  } = params;
+  MarkdownPreviewRenderer.registerDomEvents(
+    el,
+    new LinkDomEventsHandlers(
+      new FixedZIndexDomEventsHandlersInfo({
+        app,
+        el,
+        path: sourcePath ?? ""
+      })
+    )
+  );
+}
+async function renderExternalLink(params) {
+  const {
+    app,
+    url
+  } = params;
+  const displayText = params.displayText ?? url;
+  const wrapperEl = createSpan();
+  await fullRender({
+    app,
+    el: wrapperEl,
+    markdown: `[${displayText}](${url})`
+  });
+  const aEl = wrapperEl.find("a");
+  registerLinkHandlers({
+    app,
+    el: aEl
+  });
+  return aEl;
+}
+async function renderInternalLink(params) {
+  const {
+    afterReveal,
+    app,
+    folderNote,
+    pathOrAbstractFile,
+    shouldRevealFile
+  } = params;
+  function reveal(abstractFileToReveal) {
+    invokeAsyncSafely(async () => {
+      await revealInFileExplorer({ abstractFile: abstractFileToReveal, app });
+      await afterReveal?.();
+    });
+  }
+  const abstractFile = getAbstractFileOrNull({ app, pathOrFile: pathOrAbstractFile });
+  const path = getPath(app, pathOrAbstractFile);
+  const displayText = params.displayText ?? path;
+  if (isFolder(abstractFile)) {
+    return createEl("a", { text: displayText }, (aEl2) => {
+      aEl2.addEventListener("click", ($event) => {
+        $event.preventDefault();
+        const config = resolveFolderNoteConfig({ app, ...folderNote });
+        const folderNoteFile = resolveFolderNote({ app, config, folder: abstractFile });
+        reveal(folderNoteFile && !config.isHidden ? folderNoteFile : abstractFile);
+        if (folderNoteFile) {
+          invokeAsyncSafely(() => openAfterSettling(app, folderNoteFile));
+        }
+      });
+    });
+  }
+  const wrapperEl = createSpan();
+  await fullRender({
+    app,
+    el: wrapperEl,
+    markdown: `[[${path}|${displayText}]]`
+  });
+  const aEl = wrapperEl.find("a");
+  registerLinkHandlers({
+    app,
+    el: aEl
+  });
+  if (shouldRevealFile ?? false) {
+    aEl.addEventListener("click", () => {
+      const file = getAbstractFileOrNull({ app, pathOrFile: pathOrAbstractFile });
+      if (isFile(file)) {
+        reveal(file);
+      }
+    });
+  }
+  return aEl;
+}
+function addCopyMenuItem(menu, targetEl) {
+  menu.addItem((item) => {
+    item.setSection("clipboard").setTitle(t(($) => $.obsidianDevUtils.menu.copy)).setIcon("lucide-copy").onClick(() => {
+      invokeAsyncSafely(() => targetEl.win.navigator.clipboard.writeText(targetEl.getText()));
+    });
+  });
+}
+async function openAfterSettling(app, file) {
+  await sleep({ milliseconds: DELAY_BEFORE_OPEN_IN_MILLISECONDS });
+  await app.workspace.getLeaf().openFile(file, { active: true });
+}
+export {
+  fullRender,
+  markdownToHtml,
+  registerLinkHandlers,
+  renderExternalLink,
+  renderInternalLink
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/markdown.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides utility functions for processing Markdown content in Obsidian.\n */\n\n/* v8 ignore start -- Deeply coupled to Obsidian runtime; requires running vault for meaningful testing. */\n\nimport type {\n  DomEventsHandlers,\n  DomEventsHandlersInfo,\n  EmbedRegistryEmbedByExtensionRecord\n} from '@obsidian-typings/obsidian-public-latest';\nimport type {\n  App,\n  TAbstractFile,\n  TFile,\n  TFolder\n} from 'obsidian';\n\nimport {\n  invokeAsyncSafely,\n  sleep\n} from '@mnaoumov/typescript-lib/async';\nimport {\n  getZIndex,\n  waitUntilConnected\n} from '@mnaoumov/typescript-lib/html-element';\nimport { normalizeOptionalProperties } from '@mnaoumov/typescript-lib/object-utils';\nimport { isUrl } from '@mnaoumov/typescript-lib/url';\nimport { InternalPluginName } from '@obsidian-typings/obsidian-public-latest/implementations';\nimport { t } from 'i18next';\nimport {\n  Component,\n  HoverPopover,\n  Keymap,\n  MarkdownPreviewRenderer,\n  MarkdownRenderer,\n  Menu,\n  Notice\n} from 'obsidian';\n\nimport type { PathOrAbstractFile } from './file-system.ts';\nimport type { FolderNoteLocation } from './folder-note.ts';\n\nimport { MonkeyAroundComponent } from './components/monkey-around-component.ts';\nimport { revealInFileExplorer } from './file-explorer.ts';\nimport {\n  getAbstractFileOrNull,\n  getPath,\n  isFile,\n  isFolder\n} from './file-system.ts';\nimport {\n  resolveFolderNote,\n  resolveFolderNoteConfig\n} from './folder-note.ts';\n\n/**\n * How long to let Obsidian settle before opening a folder note. The click can land right after an\n * operation that created, rewrote and trashed notes, and opening into the middle of Obsidian's own\n * reaction to that shows the note before its metadata has caught up.\n */\nconst DELAY_BEFORE_OPEN_IN_MILLISECONDS = 200;\n\n/**\n * The sections an external link's context menu declares, in Obsidian's own order. The order is what\n * {@link Menu.sort} groups the items by, so it has to match what\n * {@link Workspace.handleExternalLinkContextMenu} and every `url-menu` listener expect to fill.\n */\nconst EXTERNAL_LINK_MENU_SECTIONS = [\n  'title',\n  'open',\n  'selection',\n  'clipboard',\n  'info',\n  'action',\n  'view',\n  '',\n  'danger'\n];\n\n/**\n * The sections an internal link's context menu declares, in Obsidian's own order. See\n * {@link EXTERNAL_LINK_MENU_SECTIONS} \u2014 the counterpart for `file-menu` listeners.\n */\nconst INTERNAL_LINK_MENU_SECTIONS = [\n  'title',\n  'open',\n  'action',\n  'clipboard',\n  'view',\n  'info',\n  '',\n  'danger'\n];\n\n/**\n * The params for the full render.\n */\nexport interface FullRenderParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The Component instance to use for the render.\n   */\n  readonly component?: Component;\n\n  /**\n   * The HTMLElement to render to.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The Markdown string to render.\n   */\n  readonly markdown: string;\n\n  /**\n   * Whether to register link handlers for the rendered element.\n   *\n   * @default `false`\n   */\n  readonly shouldRegisterLinkHandlers?: boolean;\n\n  /**\n   * The source path to resolve relative links.\n   *\n   * @default `'/'`\n   */\n  readonly sourcePath?: string;\n}\n\n/**\n * Parameters for {@link markdownToHtml}.\n */\nexport interface MarkdownToHtmlParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The Markdown string to convert.\n   */\n  readonly markdown: string;\n\n  /**\n   * The source path to resolve relative links.\n   *\n   * @default `''`\n   */\n  readonly sourcePath?: string;\n}\n\n/**\n * Parameters for {@link registerLinkHandlers}.\n */\nexport interface RegisterLinkHandlersParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The HTMLElement to register link handlers for.\n   */\n  readonly el: HTMLElement;\n\n  /**\n   * The source path to resolve relative links from.\n   *\n   * @default `''`\n   */\n  readonly sourcePath?: string;\n}\n\n/**\n * Parameters for {@link renderExternalLink}.\n */\nexport interface RenderExternalLinkParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The text to display for the external link.\n   */\n  readonly displayText?: string;\n\n  /**\n   * The URL to render the external link for.\n   */\n  readonly url: string;\n}\n\n/**\n * The folder-note setup {@link renderInternalLink} resolves a folder link's note with \u2014 everything\n * {@link resolveFolderNoteConfig} takes except the app, which the link already carries.\n */\nexport interface RenderInternalLinkFolderNoteOptions {\n  /**\n   * The extensions a folder note may carry. See {@link ResolveFolderNoteConfigParams.extensions}.\n   *\n   * @default `['md']`\n   */\n  readonly extensions?: readonly string[];\n\n  /**\n   * Whether the folder note is hidden in the file explorer. See\n   * {@link ResolveFolderNoteConfigParams.isHidden}.\n   *\n   * @default `false`\n   */\n  readonly isHidden?: boolean;\n\n  /**\n   * Where the note sits relative to its folder. See {@link ResolveFolderNoteConfigParams.location}.\n   *\n   * @default {@link FolderNoteLocation.Auto}\n   */\n  readonly location?: FolderNoteLocation;\n\n  /**\n   * Names the folder note of a folder. See {@link ResolveFolderNoteConfigParams.resolveName}.\n   *\n   * @param folder - The folder whose note is being named.\n   * @returns The note's name.\n   * @default `(folder) => folder.name`\n   */\n  readonly resolveName?: (folder: TFolder) => string;\n}\n\n/**\n * Parameters for {@link renderInternalLink}.\n */\nexport interface RenderInternalLinkParams {\n  /**\n   * Called after a click has revealed the link's destination in the file explorer, once the explorer has\n   * finished taking the focus for it \u2014 so this is where a caller moves the focus somewhere else.\n   *\n   * Awaited, and called only for a click that reveals: always for a folder link, and for a file link only\n   * with {@link RenderInternalLinkParams.shouldRevealFile} and a destination that exists. With the file\n   * explorer disabled it is still called, right away, since there is then nothing to wait for.\n   */\n  readonly afterReveal?: () => Promise<void> | void;\n\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The text to display for the internal link.\n   */\n  readonly displayText?: string;\n\n  /**\n   * How to answer which note is a folder's folder note, when the link names a FOLDER.\n   *\n   * Omitted means {@link FolderNoteLocation.Auto}: the installed `folder-notes` plugin's live\n   * configuration, or a note named after its folder, inside it, when that plugin is absent. Pass\n   * `{ location: FolderNoteLocation.None }` for a folder link that must only ever reveal.\n   *\n   * @default `{}`\n   */\n  readonly folderNote?: RenderInternalLinkFolderNoteOptions;\n\n  /**\n   * The path or abstract file to render the internal link for.\n   */\n  readonly pathOrAbstractFile: PathOrAbstractFile;\n\n  /**\n   * Whether clicking a FILE link also highlights that file in the file explorer, on top of the open\n   * Obsidian's own link handler performs.\n   *\n   * Opt-in, unlike the folder branch: a folder link has always revealed (revealing was all its click\n   * could mean), whereas a file link has always only opened \u2014 so turning this on by default would change\n   * what every existing caller's link does.\n   *\n   * @default `false`\n   */\n  readonly shouldRevealFile?: boolean;\n}\n\ninterface FixedZIndexDomEventsHandlersInfoConstructorParams {\n  readonly app: App;\n  readonly el: HTMLElement;\n  readonly path: string;\n}\n\nclass EmbedByExtensionMdPatchComponent extends MonkeyAroundComponent {\n  public constructor(private readonly embedByExtension: EmbedRegistryEmbedByExtensionRecord) {\n    super();\n  }\n\n  public override onload(): void {\n    this.registerMethodPatch({\n      $object: this.embedByExtension,\n      methodName: 'md',\n      patchHandler: ({\n        fallback,\n        originalArguments: [context]\n      }) => {\n        context.displayMode = false;\n        return fallback();\n      }\n    });\n  }\n}\n\nclass FixedZIndexDomEventsHandlersInfo implements DomEventsHandlersInfo {\n  public readonly app: App;\n  public readonly path: string;\n  public get hoverPopover(): HoverPopover | null {\n    return this._hoverPopover;\n  }\n\n  public set hoverPopover(hoverPopover: HoverPopover | null) {\n    this._hoverPopover = hoverPopover;\n    if (hoverPopover && this.zIndex !== undefined) {\n      hoverPopover.hoverEl.setCssStyles({\n        zIndex: String(this.zIndex)\n      });\n    }\n  }\n\n  private _hoverPopover: HoverPopover | null = null;\n\n  private readonly el: HTMLElement;\n\n  private zIndex?: number;\n\n  public constructor(params: FixedZIndexDomEventsHandlersInfoConstructorParams) {\n    this.app = params.app;\n    this.path = params.path;\n    this.el = params.el;\n\n    invokeAsyncSafely(async () => {\n      await waitUntilConnected(this.el);\n      this.updateZIndex(this.el);\n    });\n  }\n\n  private updateZIndex(element: HTMLElement): void {\n    this.zIndex = getZIndex(element) + 1;\n  }\n}\n\n/**\n * What a rendered link DOES when it is clicked, hovered, dragged or right-clicked.\n *\n * {@link MarkdownPreviewRenderer.registerDomEvents} only performs the DELEGATION half \u2014 which element an\n * event landed on, which link text it carries, and which of these methods to call. The half it does not\n * provide is this one, and Obsidian keeps its own implementation private: the only handle on it is the\n * instance a live preview view passes in. {@link getDomEventsHandlersConstructor} used to obtain it by\n * opening a real leaf on an arbitrary note and intercepting that call \u2014 which mutated the user's\n * workspace on EVERY consumer's load (a tab opening and closing, two `file-open` and two\n * `active-leaf-change` events, an unrelated note rendered in preview).\n *\n * These bodies are a port of that class, so nothing has to be opened. Keeping\n * {@link MarkdownPreviewRenderer.registerDomEvents} for the delegation is what keeps footnote links,\n * tags, external links, mod-click and drag behaving exactly as they do inside a real preview.\n */\nclass LinkDomEventsHandlers implements DomEventsHandlers {\n  public constructor(private readonly info: DomEventsHandlersInfo) {}\n\n  public onExternalLinkClick($event: MouseEvent, targetEl: HTMLElement, linkText: string): void {\n    $event.preventDefault();\n    if (!isUrl(linkText)) {\n      new Notice(t(($) => $.obsidianDevUtils.notices.failedToOpenUrl, { url: linkText }));\n      return;\n    }\n\n    const modifierPaneType = Keymap.isModEvent($event);\n    targetEl.win.open(linkText, typeof modifierPaneType === 'boolean' ? '' : modifierPaneType);\n  }\n\n  public onExternalLinkRightClick($event: MouseEvent, targetEl: HTMLElement, linkText: string): void {\n    const menu = Menu.forEvent($event);\n    menu.addSections(EXTERNAL_LINK_MENU_SECTIONS);\n    addCopyMenuItem(menu, targetEl);\n    this.info.app.workspace.handleExternalLinkContextMenu(menu, linkText);\n  }\n\n  public onInternalLinkClick($event: MouseEvent, _targetEl: HTMLElement, linkText: string): void {\n    $event.preventDefault();\n    invokeAsyncSafely(() => this.info.app.workspace.openLinkText(linkText, this.info.path, Keymap.isModEvent($event)));\n  }\n\n  public onInternalLinkDrag($event: DragEvent, _targetEl: HTMLElement, linkText: string, title?: string): void {\n    const dragManager = this.info.app.dragManager;\n    dragManager.onDragStart($event, dragManager.dragLink($event, linkText, this.info.path, title));\n  }\n\n  public onInternalLinkMouseover($event: MouseEvent, targetEl: HTMLElement, linkText: string): void {\n    // `hoverParent` is the info object itself, exactly as Obsidian passes its own \u2014 which is what keeps\n    // `FixedZIndexDomEventsHandlersInfo`'s popover z-index fix in play.\n    this.info.app.workspace.trigger('hover-link', {\n      event: $event,\n      hoverParent: this.info,\n      linktext: linkText,\n      source: 'preview',\n      sourcePath: this.info.path,\n      targetEl\n    });\n  }\n\n  public onInternalLinkRightClick($event: MouseEvent, targetEl: HTMLElement, linkText: string): void {\n    const menu = Menu.forEvent($event);\n    menu.setParentElement(targetEl);\n    menu.addSections(INTERNAL_LINK_MENU_SECTIONS);\n    addCopyMenuItem(menu, targetEl);\n    this.info.app.workspace.handleLinkContextMenu(menu, linkText, this.info.path);\n  }\n\n  public onTagClick(_$event: MouseEvent, _targetEl: HTMLElement, tag: string): void {\n    // `registerDomEvents` has already called `preventDefault()` for a tag click.\n    this.info.app.internalPlugins.getEnabledPluginById(InternalPluginName.GlobalSearch)?.openGlobalSearch(`tag:${tag}`);\n  }\n}\n\n/**\n * Render the markdown and embeds.\n *\n * @param params - The parameters for the full render.\n * @returns The {@link Promise} that resolves when the full render is complete.\n */\nexport async function fullRender(params: FullRenderParams): Promise<void> {\n  const sourcePath = params.sourcePath ?? '/';\n  let shouldUnloadComponent = false;\n  let component: Component;\n  if (params.component) {\n    component = params.component;\n  } else {\n    component = new Component();\n    component.load();\n    shouldUnloadComponent = true;\n  }\n\n  using _ = component.addChild(new EmbedByExtensionMdPatchComponent(params.app.embedRegistry.embedByExtension));\n\n  await MarkdownRenderer.render(params.app, params.markdown, params.el, sourcePath, component);\n\n  if (shouldUnloadComponent) {\n    component.unload();\n  }\n\n  if (params.shouldRegisterLinkHandlers) {\n    registerLinkHandlers(normalizeOptionalProperties<RegisterLinkHandlersParams>({\n      app: params.app,\n      el: params.el,\n      sourcePath: params.sourcePath\n    }));\n  }\n}\n\n/**\n * Converts Markdown to HTML.\n *\n * @param params - The parameters for the conversion.\n * @returns The HTML string.\n */\nexport async function markdownToHtml(params: MarkdownToHtmlParams): Promise<string> {\n  const {\n    app,\n    markdown,\n    sourcePath\n  } = params;\n  const component = new Component();\n  component.load();\n  const renderDiv = createDiv();\n  await MarkdownRenderer.render(app, markdown, renderDiv, sourcePath ?? '', component);\n  const html = renderDiv.innerHTML;\n  component.unload();\n  return html;\n}\n\n/**\n * Registers link handlers for the given element.\n *\n * @param params - The parameters for registering link handlers.\n */\nexport function registerLinkHandlers(params: RegisterLinkHandlersParams): void {\n  const {\n    app,\n    el,\n    sourcePath\n  } = params;\n  MarkdownPreviewRenderer.registerDomEvents(\n    el,\n    new LinkDomEventsHandlers(\n      new FixedZIndexDomEventsHandlersInfo({\n        app,\n        el,\n        path: sourcePath ?? ''\n      })\n    )\n  );\n}\n\n/**\n * Renders an external link.\n *\n * @param params - The parameters for rendering the external link.\n * @returns The HTMLAnchorElement containing the rendered external link.\n */\nexport async function renderExternalLink(params: RenderExternalLinkParams): Promise<HTMLAnchorElement> {\n  const {\n    app,\n    url\n  } = params;\n  const displayText = params.displayText ?? url;\n  const wrapperEl = createSpan();\n  await fullRender({\n    app,\n    el: wrapperEl,\n    markdown: `[${displayText}](${url})`\n  });\n  const aEl = wrapperEl.find('a') as HTMLAnchorElement;\n  registerLinkHandlers({\n    app,\n    el: aEl\n  });\n  return aEl;\n}\n\n/**\n * Renders an internal link.\n *\n * What clicking the rendered link does depends on what it names:\n *\n * - A FILE is opened by Obsidian's own link handler \u2014 and, with\n *   {@link RenderInternalLinkParams.shouldRevealFile}, additionally revealed in the file explorer.\n * - A FOLDER cannot be opened, so its FOLDER NOTE is \u2014 the note whose properties describe the folder\n *   itself, resolved through {@link resolveFolderNote} (by default from the installed `folder-notes`\n *   plugin's live configuration). The reveal lands on that note, unless the note is hidden in the\n *   explorer, in which case it lands on the folder \u2014 revealing a hidden note would highlight nothing.\n *   A folder with NO folder note reveals the folder and opens nothing: nothing here ever creates a note.\n *\n * Everything is resolved at CLICK time rather than at render time, deliberately: a rendered link outlives\n * the operation that produced it, so a destination renamed in between still reveals the right item, and a\n * folder note written after the link appeared is still found.\n *\n * @param params - The parameters for rendering the internal link.\n * @returns The HTMLAnchorElement containing the rendered internal link.\n */\nexport async function renderInternalLink(params: RenderInternalLinkParams): Promise<HTMLAnchorElement> {\n  const {\n    afterReveal,\n    app,\n    folderNote,\n    pathOrAbstractFile,\n    shouldRevealFile\n  } = params;\n\n  // A DOM listener cannot await, so the reveal, and the hook ordered after it, run detached.\n  function reveal(abstractFileToReveal: TAbstractFile): void {\n    invokeAsyncSafely(async () => {\n      await revealInFileExplorer({ abstractFile: abstractFileToReveal, app });\n      await afterReveal?.();\n    });\n  }\n  const abstractFile = getAbstractFileOrNull({ app, pathOrFile: pathOrAbstractFile });\n  const path = getPath(app, pathOrAbstractFile);\n  const displayText = params.displayText ?? path;\n  if (isFolder(abstractFile)) {\n    return createEl('a', { text: displayText }, (aEl) => {\n      aEl.addEventListener('click', ($event) => {\n        $event.preventDefault();\n        const config = resolveFolderNoteConfig({ app, ...folderNote });\n        const folderNoteFile = resolveFolderNote({ app, config, folder: abstractFile });\n        reveal(folderNoteFile && !config.isHidden ? folderNoteFile : abstractFile);\n        if (folderNoteFile) {\n          // A DOM listener cannot await, and the open has to outlive this handler: it settles first, for\n          // the click that lands right as an operation finishes writing.\n          invokeAsyncSafely(() => openAfterSettling(app, folderNoteFile));\n        }\n      });\n    });\n  }\n\n  const wrapperEl = createSpan();\n  await fullRender({\n    app,\n    el: wrapperEl,\n    markdown: `[[${path}|${displayText}]]`\n  });\n  const aEl = wrapperEl.find('a') as HTMLAnchorElement;\n  registerLinkHandlers({\n    app,\n    el: aEl\n  });\n  if (shouldRevealFile ?? false) {\n    aEl.addEventListener('click', () => {\n      // Layered ON TOP of Obsidian's own handler \u2014 no `preventDefault`, so the open is untouched. A path\n      // that resolves to nothing gets no reveal: an unresolved link has nothing to reveal, and clicking\n      // one CREATES the note it names.\n      const file = getAbstractFileOrNull({ app, pathOrFile: pathOrAbstractFile });\n      if (isFile(file)) {\n        reveal(file);\n      }\n    });\n  }\n  return aEl;\n}\n\n/**\n * Adds the `clipboard`-section Copy item every link context menu carries, copying the link's DISPLAY\n * text \u2014 which is what Obsidian's own menu copies, not the target path.\n *\n * @param menu - The menu to add the item to.\n * @param targetEl - The link element the menu was opened on.\n */\nfunction addCopyMenuItem(menu: Menu, targetEl: HTMLElement): void {\n  menu.addItem((item) => {\n    item\n      .setSection('clipboard')\n      .setTitle(t(($) => $.obsidianDevUtils.menu.copy))\n      .setIcon('lucide-copy')\n      .onClick(() => {\n        invokeAsyncSafely(() => targetEl.win.navigator.clipboard.writeText(targetEl.getText()));\n      });\n  });\n}\n\n/**\n * Opens a file in the active leaf, once the vault has settled.\n *\n * @param app - The Obsidian app instance.\n * @param file - The file to open.\n * @returns A {@link Promise} that resolves once the file is open.\n */\nasync function openAfterSettling(app: App, file: TFile): Promise<void> {\n  await sleep({ milliseconds: DELAY_BEFORE_OPEN_IN_MILLISECONDS });\n  await app.workspace.getLeaf().openFile(file, { active: true });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["_", "aEl"]
}


package/dist/lib/esm/menu-event-registrar.d.mts

@@ -0,0 +1,84 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Menu event registrar.
+ */
+import type { DisposableEx } from '@mnaoumov/typescript-lib/disposable';
+import type { Editor, MarkdownFileInfo, MarkdownView, Menu, TAbstractFile, WorkspaceLeaf } from 'obsidian';
+/**
+ * Handler for the editor context menu event.
+ *
+ * @param menu - The menu to add items to.
+ * @param editor - The editor instance.
+ * @param ctx - The markdown file context.
+ */
+export type EditorMenuEventHandler = (menu: Menu, editor: Editor, context: MarkdownFileInfo) => void;
+/**
+ * Handler for the single-file context menu event.
+ *
+ * @param menu - The menu to add items to.
+ * @param abstractFile - The file or folder.
+ * @param source - The source of the event.
+ * @param leaf - The workspace leaf, if available.
+ */
+export type FileMenuEventHandler = (menu: Menu, abstractFile: TAbstractFile, source: string, leaf?: WorkspaceLeaf) => void;
+/**
+ * Handler for the multi-file context menu event.
+ *
+ * @param menu - The menu to add items to.
+ * @param abstractFiles - The files or folders.
+ * @param source - The source of the event.
+ * @param leaf - The workspace leaf, if available.
+ */
+export type FilesMenuEventHandler = (menu: Menu, abstractFiles: TAbstractFile[], source: string, leaf?: WorkspaceLeaf) => void;
+/**
+ * Handler for the markdown viewport (margin) context menu event.
+ *
+ * This is the menu raised by right-clicking the empty space BESIDE the text — the one carrying
+ * `Readable line length` / `Line numbers` / `Inline title` — or the line-number gutter. It is a different
+ * menu from the editor one: with `Readable line length` on, the text is centred inside a narrower
+ * `.cm-sizer`, so a margin click lands outside the editor's `contentDOM` and `editor-menu` never fires.
+ *
+ * @param menu - The menu to add items to.
+ * @param view - The markdown view the menu was raised over.
+ * @param mode - The view mode (`'source'` or `'preview'`).
+ * @param source - What raised the menu. Obsidian 1.13.7 passes the literal `'gutter'` from BOTH of its
+ *                 trigger sites, for a margin click as well as a line-number-gutter one, so it does not
+ *                 currently distinguish the two. It is forwarded rather than dropped because it is part
+ *                 of the event's shape and may start carrying more than one value.
+ */
+export type MarkdownViewportMenuEventHandler = (menu: Menu, view: MarkdownView, mode: string, source: string) => void;
+/**
+ * Registers menu event handlers with lifecycle management.
+ */
+export interface MenuEventRegistrar {
+    /**
+     * Registers a handler for the editor context menu event.
+     *
+     * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed.
+     */
+    registerEditorMenuEventHandler: (handler: EditorMenuEventHandler) => DisposableEx;
+    /**
+     * Registers a handler for the single-file context menu event.
+     *
+     * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed.
+     */
+    registerFileMenuEventHandler: (handler: FileMenuEventHandler) => DisposableEx;
+    /**
+     * Registers a handler for the multi-file context menu event.
+     *
+     * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed.
+     */
+    registerFilesMenuEventHandler: (handler: FilesMenuEventHandler) => DisposableEx;
+    /**
+     * Registers a handler for the markdown viewport (margin) context menu event.
+     *
+     * @param handler - The handler to register.
+     * @returns A {@link DisposableEx} that unregisters the handler when disposed.
+     */
+    registerMarkdownViewportMenuEventHandler: (handler: MarkdownViewportMenuEventHandler) => DisposableEx;
+}

package/dist/lib/esm/menu-event-registrar.mjs

@@ -0,0 +1,50 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K