obsidian-dev-utils 49.0.3 → 51.0.1

package/dist/lib/cjs/obsidian/markdown.cjs

@@ -0,0 +1,251 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@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.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, @typescript-eslint/no-unnecessary-condition -- We need access to app here which might not be available yet.
+    if (globalThis?.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 globalThis.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 markdown_exports = {};
+__export(markdown_exports, {
+  fullRender: () => fullRender,
+  markdownToHtml: () => markdownToHtml,
+  registerLinkHandlers: () => registerLinkHandlers,
+  renderExternalLink: () => renderExternalLink,
+  renderInternalLink: () => renderInternalLink
+});
+module.exports = __toCommonJS(markdown_exports);
+var import_obsidian = require('obsidian');
+var import_implementations = require('obsidian-typings/implementations');
+var import_html_element = require('../html-element.cjs');
+var import_getDomEventsHandlersConstructor = require('./constructors/getDomEventsHandlersConstructor.cjs');
+var import_file_system = require('./file-system.cjs');
+var import_monkey_around = require('./monkey-around.cjs');
+let domEventsHandlersConstructor = null;
+class FixedZIndexDomEventsHandlersInfo {
+  constructor(app, path, el) {
+    this.app = app;
+    this.path = path;
+    if (el.isConnected) {
+      this.updateZIndex(el);
+    } else {
+      el.onNodeInserted(() => {
+        this.updateZIndex(el);
+      });
+    }
+  }
+  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;
+  zIndex;
+  updateZIndex(el) {
+    this.zIndex = (0, import_html_element.getZIndex)(el) + 1;
+  }
+}
+async function fullRender(params) {
+  const sourcePath = params.sourcePath ?? "/";
+  let shouldUnloadComponent = false;
+  let component;
+  if (params.component) {
+    component = params.component;
+  } else {
+    component = new import_obsidian.Component();
+    component.load();
+    shouldUnloadComponent = true;
+  }
+  await (0, import_monkey_around.invokeWithPatchAsync)(params.app.embedRegistry.embedByExtension, {
+    md: (next) => (context, file, subpath) => {
+      context.displayMode = false;
+      return next(context, file, subpath);
+    }
+  }, async () => {
+    await import_obsidian.MarkdownRenderer.render(params.app, params.markdown, params.el, sourcePath, component);
+  });
+  if (shouldUnloadComponent) {
+    component.unload();
+  }
+  if (params.shouldRegisterLinkHandlers) {
+    await registerLinkHandlers(params.app, params.el, params.sourcePath);
+  }
+}
+async function markdownToHtml(app, markdown, sourcePath) {
+  const component = new import_obsidian.Component();
+  component.load();
+  const renderDiv = createDiv();
+  await import_obsidian.MarkdownRenderer.render(app, markdown, renderDiv, sourcePath ?? "", component);
+  const html = renderDiv.innerHTML;
+  component.unload();
+  return html;
+}
+async function registerLinkHandlers(app, el, sourcePath) {
+  domEventsHandlersConstructor ??= await (0, import_getDomEventsHandlersConstructor.getDomEventsHandlersConstructor)(app);
+  import_obsidian.MarkdownPreviewRenderer.registerDomEvents(
+    el,
+    new domEventsHandlersConstructor(new FixedZIndexDomEventsHandlersInfo(app, sourcePath ?? "", el))
+  );
+}
+async function renderExternalLink(app, url, displayText) {
+  displayText ??= url;
+  const wrapperEl = createSpan();
+  await fullRender({
+    app,
+    el: wrapperEl,
+    markdown: `[${displayText}](${url})`
+  });
+  const aEl = wrapperEl.find("a");
+  await registerLinkHandlers(app, aEl);
+  return aEl;
+}
+async function renderInternalLink(app, pathOrAbstractFile, displayText) {
+  const abstractFile = (0, import_file_system.getAbstractFileOrNull)(app, pathOrAbstractFile);
+  const path = (0, import_file_system.getPath)(app, pathOrAbstractFile);
+  displayText ??= path;
+  if ((0, import_file_system.isFolder)(abstractFile)) {
+    return createEl("a", { text: displayText }, (aEl2) => {
+      aEl2.addEventListener("click", (evt) => {
+        evt.preventDefault();
+        app.internalPlugins.getEnabledPluginById(import_implementations.InternalPluginName.FileExplorer)?.revealInFolder(abstractFile);
+      });
+    });
+  }
+  const wrapperEl = createSpan();
+  await fullRender({
+    app,
+    el: wrapperEl,
+    markdown: `[[${path}|${displayText}]]`
+  });
+  const aEl = wrapperEl.find("a");
+  await registerLinkHandlers(app, aEl);
+  return aEl;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fullRender,
+  markdownToHtml,
+  registerLinkHandlers,
+  renderExternalLink,
+  renderInternalLink
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/obsidian/markdown.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\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 { App } from 'obsidian';\nimport type {\n  DomEventsHandlersConstructor,\n  DomEventsHandlersInfo,\n  EmbedCreator\n} from 'obsidian-typings';\n\nimport {\n  Component,\n  HoverPopover,\n  MarkdownPreviewRenderer,\n  MarkdownRenderer\n} from 'obsidian';\nimport { InternalPluginName } from 'obsidian-typings/implementations';\n\nimport type { PathOrAbstractFile } from './file-system.ts';\n\nimport { getZIndex } from '../html-element.ts';\nimport { getDomEventsHandlersConstructor } from './constructors/getDomEventsHandlersConstructor.ts';\nimport {\n  getAbstractFileOrNull,\n  getPath,\n  isFolder\n} from './file-system.ts';\nimport { invokeWithPatchAsync } from './monkey-around.ts';\n\nlet domEventsHandlersConstructor: DomEventsHandlersConstructor | null = null;\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  readonly shouldRegisterLinkHandlers?: boolean;\n\n  /**\n   * The source path to resolve relative links.\n   */\n  readonly sourcePath?: string;\n}\n\nclass FixedZIndexDomEventsHandlersInfo implements DomEventsHandlersInfo {\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 zIndex?: number;\n\n  public constructor(public readonly app: App, public readonly path: string, el: HTMLElement) {\n    if (el.isConnected) {\n      this.updateZIndex(el);\n    } else {\n      el.onNodeInserted(() => {\n        this.updateZIndex(el);\n      });\n    }\n  }\n\n  private updateZIndex(el: HTMLElement): void {\n    this.zIndex = getZIndex(el) + 1;\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  await invokeWithPatchAsync(params.app.embedRegistry.embedByExtension, {\n    md: (next: EmbedCreator): EmbedCreator => (context, file, subpath) => {\n      context.displayMode = false;\n      return next(context, file, subpath);\n    }\n  }, async () => {\n    await MarkdownRenderer.render(params.app, params.markdown, params.el, sourcePath, component);\n  });\n\n  if (shouldUnloadComponent) {\n    component.unload();\n  }\n\n  if (params.shouldRegisterLinkHandlers) {\n    await registerLinkHandlers(params.app, params.el, params.sourcePath);\n  }\n}\n\n/**\n * Converts Markdown to HTML.\n *\n * @param app - The Obsidian app instance.\n * @param markdown - The Markdown string to convert.\n * @param sourcePath - (optional) The source path to resolve relative links.\n * @returns The HTML string.\n */\nexport async function markdownToHtml(app: App, markdown: string, sourcePath?: string): Promise<string> {\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 app - The Obsidian app instance.\n * @param el - The HTMLElement to register link handlers for.\n * @param sourcePath - The source path to resolve relative links from.\n */\nexport async function registerLinkHandlers(app: App, el: HTMLElement, sourcePath?: string): Promise<void> {\n  // eslint-disable-next-line require-atomic-updates -- No race condition.\n  domEventsHandlersConstructor ??= await getDomEventsHandlersConstructor(app);\n  MarkdownPreviewRenderer.registerDomEvents(\n    el,\n    new domEventsHandlersConstructor(new FixedZIndexDomEventsHandlersInfo(app, sourcePath ?? '', el))\n  );\n}\n\n/**\n * Renders an external link.\n *\n * @param app - The Obsidian app instance.\n * @param url - The URL to render the external link for.\n * @param displayText - The text to display for the external link.\n * @returns The HTMLAnchorElement containing the rendered external link.\n */\nexport async function renderExternalLink(app: App, url: string, displayText?: string): Promise<HTMLAnchorElement> {\n  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  await registerLinkHandlers(app, aEl);\n  return aEl;\n}\n\n/**\n * Renders an internal link.\n *\n * @param app - The Obsidian app instance.\n * @param pathOrAbstractFile - The path or abstract file to render the internal link for.\n * @param displayText - The text to display for the internal link.\n * @returns The HTMLAnchorElement containing the rendered internal link.\n */\nexport async function renderInternalLink(app: App, pathOrAbstractFile: PathOrAbstractFile, displayText?: string): Promise<HTMLAnchorElement> {\n  const abstractFile = getAbstractFileOrNull(app, pathOrAbstractFile);\n  const path = getPath(app, pathOrAbstractFile);\n  displayText ??= path;\n  if (isFolder(abstractFile)) {\n    return createEl('a', { text: displayText }, (aEl) => {\n      aEl.addEventListener('click', (evt) => {\n        evt.preventDefault();\n        app.internalPlugins.getEnabledPluginById(InternalPluginName.FileExplorer)?.revealInFolder(abstractFile);\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  await registerLinkHandlers(app, aEl);\n  return aEl;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["aEl"]
}


package/dist/lib/cjs/obsidian/markdown.d.cts

@@ -0,0 +1,79 @@
+/**
+ * @packageDocumentation
+ *
+ * This module provides utility functions for processing Markdown content in Obsidian.
+ */
+import type { App } from 'obsidian';
+import { Component } from 'obsidian';
+import type { PathOrAbstractFile } from './file-system.cjs';
+/**
+ * The params for the full render.
+ */
+export interface FullRenderParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The Component instance to use for the render.
+     */
+    readonly component?: Component;
+    /**
+     * The HTMLElement to render to.
+     */
+    readonly el: HTMLElement;
+    /**
+     * The Markdown string to render.
+     */
+    readonly markdown: string;
+    /**
+     * Whether to register link handlers for the rendered element.
+     */
+    readonly shouldRegisterLinkHandlers?: boolean;
+    /**
+     * The source path to resolve relative links.
+     */
+    readonly sourcePath?: string;
+}
+/**
+ * Render the markdown and embeds.
+ *
+ * @param params - The parameters for the full render.
+ * @returns The {@link Promise} that resolves when the full render is complete.
+ */
+export declare function fullRender(params: FullRenderParams): Promise<void>;
+/**
+ * Converts Markdown to HTML.
+ *
+ * @param app - The Obsidian app instance.
+ * @param markdown - The Markdown string to convert.
+ * @param sourcePath - (optional) The source path to resolve relative links.
+ * @returns The HTML string.
+ */
+export declare function markdownToHtml(app: App, markdown: string, sourcePath?: string): Promise<string>;
+/**
+ * Registers link handlers for the given element.
+ *
+ * @param app - The Obsidian app instance.
+ * @param el - The HTMLElement to register link handlers for.
+ * @param sourcePath - The source path to resolve relative links from.
+ */
+export declare function registerLinkHandlers(app: App, el: HTMLElement, sourcePath?: string): Promise<void>;
+/**
+ * Renders an external link.
+ *
+ * @param app - The Obsidian app instance.
+ * @param url - The URL to render the external link for.
+ * @param displayText - The text to display for the external link.
+ * @returns The HTMLAnchorElement containing the rendered external link.
+ */
+export declare function renderExternalLink(app: App, url: string, displayText?: string): Promise<HTMLAnchorElement>;
+/**
+ * Renders an internal link.
+ *
+ * @param app - The Obsidian app instance.
+ * @param pathOrAbstractFile - The path or abstract file to render the internal link for.
+ * @param displayText - The text to display for the internal link.
+ * @returns The HTMLAnchorElement containing the rendered internal link.
+ */
+export declare function renderInternalLink(app: App, pathOrAbstractFile: PathOrAbstractFile, displayText?: string): Promise<HTMLAnchorElement>;