@stream-mdx/react 0.4.0 → 1.0.0

package/dist/components/katex-math.cjs

@@ -0,0 +1,220 @@
+"use client";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+
+// src/components/katex-math.tsx
+var katex_math_exports = {};
+__export(katex_math_exports, {
+  DocumentMathMacroScope: () => DocumentMathMacroScope,
+  DocumentMathMacroScopeContext: () => DocumentMathMacroScopeContext,
+  KaTeXBlockMath: () => KaTeXBlockMath,
+  KaTeXInlineMath: () => KaTeXInlineMath,
+  MathExpressionCompletenessContext: () => MathExpressionCompletenessContext,
+  loadKaTeX: () => loadKaTeX
+});
+module.exports = __toCommonJS(katex_math_exports);
+var import_react = require("react"), import_jsx_runtime = require("react/jsx-runtime"), katexPromise = null;
+async function loadKaTeX() {
+  return katexPromise || (katexPromise = import("katex").then((mod) => mod && typeof mod == "object" && "default" in mod && mod.default ? mod.default : mod)), katexPromise;
+}
+var DOCUMENT_POSITION_PRECEDING = 2, DOCUMENT_POSITION_FOLLOWING = 4, DocumentMathMacroScope = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Set();
+    this.orderedEntries = [];
+    this.macroSnapshots = [];
+    this.katex = null;
+    this.loadError = null;
+    this.loading = !1;
+    this.disposed = !1;
+  }
+  register(element, tex, displayMode, complete, publish) {
+    let entry = { element, tex, displayMode, complete, publish };
+    return this.entries.add(entry), this.refresh(), () => {
+      this.entries.delete(entry) && this.refresh();
+    };
+  }
+  dispose() {
+    this.disposed = !0, this.entries.clear(), this.orderedEntries = [], this.macroSnapshots = [];
+  }
+  refresh() {
+    if (!this.disposed) {
+      if (this.loadError) {
+        for (let entry of this.entries)
+          entry.publish({ tex: entry.tex, displayMode: entry.displayMode, scope: this, error: this.loadError });
+        return;
+      }
+      if (this.katex) {
+        this.recompute(this.katex);
+        return;
+      }
+      this.loading || (this.loading = !0, loadKaTeX().then((katex) => {
+        this.disposed || (this.katex = katex, this.refresh());
+      }).catch((reason) => {
+        if (!this.disposed) {
+          this.loadError = reason instanceof Error ? reason : new Error(String(reason));
+          for (let entry of this.entries)
+            entry.publish({ tex: entry.tex, displayMode: entry.displayMode, scope: this, error: this.loadError });
+        }
+      }).finally(() => {
+        this.loading = !1;
+      }));
+    }
+  }
+  recompute(katex) {
+    let nextEntries = [...this.entries].sort((left, right) => {
+      let position = left.element.compareDocumentPosition(right.element);
+      return position & DOCUMENT_POSITION_FOLLOWING ? -1 : position & DOCUMENT_POSITION_PRECEDING ? 1 : 0;
+    }), unchangedPrefix = 0;
+    for (; unchangedPrefix < this.orderedEntries.length && unchangedPrefix < nextEntries.length && this.orderedEntries[unchangedPrefix] === nextEntries[unchangedPrefix]; )
+      unchangedPrefix += 1;
+    let macros = unchangedPrefix > 0 ? { ...this.macroSnapshots[unchangedPrefix - 1] } : {};
+    this.orderedEntries = nextEntries, this.macroSnapshots.length = unchangedPrefix;
+    for (let index = unchangedPrefix; index < nextEntries.length; index += 1) {
+      let entry = nextEntries[index], preparation = null;
+      if (entry.complete) {
+        let nextMacros = { ...macros };
+        try {
+          let html = katex.renderToString(entry.tex, {
+            displayMode: entry.displayMode,
+            throwOnError: !1,
+            trust: !1,
+            maxExpand: 1e3,
+            macros: nextMacros
+          });
+          macros = nextMacros, preparation = { tex: entry.tex, displayMode: entry.displayMode, scope: this, html };
+        } catch (reason) {
+          preparation = {
+            tex: entry.tex,
+            displayMode: entry.displayMode,
+            scope: this,
+            error: reason instanceof Error ? reason : new Error(String(reason))
+          };
+        }
+      }
+      this.macroSnapshots[index] = { ...macros }, entry.publish(preparation);
+    }
+  }
+}, DocumentMathMacroScopeContext = (0, import_react.createContext)(null), MathExpressionCompletenessContext = (0, import_react.createContext)(!0), MathEngineOutputView = ({ engine, tex, displayMode }) => {
+  let output = (0, import_react.useMemo)(
+    () => engine.render(tex, { displayMode }),
+    [engine, engine.id, tex, displayMode]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: output });
+};
+function useMathPreparation(tex, displayMode, elementRef, enabled) {
+  let scope = (0, import_react.useContext)(DocumentMathMacroScopeContext), complete = (0, import_react.useContext)(MathExpressionCompletenessContext), [preparation, setPreparation] = (0, import_react.useState)(null);
+  return (0, import_react.useEffect)(() => {
+    if (!enabled) return;
+    let active = !0;
+    if (scope) {
+      let element = elementRef.current;
+      return element ? scope.register(element, tex, displayMode, complete, (result) => {
+        active && setPreparation(result);
+      }) : () => {
+        active = !1;
+      };
+    }
+    return (async () => {
+      try {
+        let html = (await loadKaTeX()).renderToString(tex, {
+          displayMode,
+          throwOnError: !1,
+          trust: !1,
+          maxExpand: 1e3
+        });
+        active && setPreparation({ tex, displayMode, scope: null, html });
+      } catch (reason) {
+        active && setPreparation({
+          tex,
+          displayMode,
+          scope: null,
+          error: reason instanceof Error ? reason : new Error(String(reason))
+        });
+      }
+    })(), () => {
+      active = !1;
+    };
+  }, [tex, displayMode, scope, complete, elementRef, enabled]), scope && !complete ? null : preparation?.tex === tex && preparation.displayMode === displayMode && preparation.scope === scope ? preparation : null;
+}
+var KaTeXInlineMath = ({ tex, className = "", fallback, engine }) => {
+  let elementRef = (0, import_react.useRef)(null), preparation = useMathPreparation(tex, !1, elementRef, !engine);
+  return engine ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: `math-inline ${className}`.trim(), "data-tex": tex, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MathEngineOutputView, { engine, tex, displayMode: !1 }) }) : preparation && "error" in preparation && fallback ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: fallback(tex, preparation.error) }) : preparation && "html" in preparation ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "span",
+    {
+      ref: elementRef,
+      className: `math-inline katex-inline ${className}`.trim(),
+      "data-tex": tex,
+      dangerouslySetInnerHTML: { __html: preparation.html }
+    }
+  ) : /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { ref: elementRef, className: `math-inline ${className}`.trim(), "data-tex": tex, children: [
+    "$",
+    tex,
+    "$"
+  ] });
+};
+KaTeXInlineMath.displayName = "KaTeXInlineMath";
+var KaTeXBlockMath = ({ tex, className = "", fallback, engine }) => {
+  let elementRef = (0, import_react.useRef)(null), preparation = useMathPreparation(tex, !0, elementRef, !engine);
+  return engine ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "div",
+    {
+      className: `math-display markdown-math-display ${className}`.trim(),
+      "data-tex": tex,
+      style: { overflowX: "auto" },
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MathEngineOutputView, { engine, tex, displayMode: !0 })
+    }
+  ) : preparation && "error" in preparation && fallback ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: fallback(tex, preparation.error) }) : preparation && "html" in preparation ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "div",
+    {
+      ref: elementRef,
+      className: `math-display katex-block markdown-math-display ${className}`.trim(),
+      "data-tex": tex,
+      style: { overflowX: "auto" },
+      dangerouslySetInnerHTML: { __html: preparation.html }
+    }
+  ) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "div",
+    {
+      ref: elementRef,
+      className: `math-display markdown-math-display ${className}`.trim(),
+      "data-tex": tex,
+      style: { overflowX: "auto" },
+      children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "math-display-content", children: [
+        "$$",
+        tex,
+        "$$"
+      ] })
+    }
+  );
+};
+KaTeXBlockMath.displayName = "KaTeXBlockMath";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DocumentMathMacroScope,
+  DocumentMathMacroScopeContext,
+  KaTeXBlockMath,
+  KaTeXInlineMath,
+  MathExpressionCompletenessContext,
+  loadKaTeX
+});

package/dist/components/katex-math.d.cts

@@ -0,0 +1,10 @@
+import 'react';
+export { au as DocumentMathMacroScope, av as DocumentMathMacroScopeContext, az as KaTeXBlockMath, ay as KaTeXInlineMath, ax as KaTeXMathProps, aw as MathExpressionCompletenessContext, at as loadKaTeX } from '../index-Cmne1yUK.cjs';
+import './bottom-stick-scroll-area.cjs';
+import 'react/jsx-runtime';
+import './diff-renderer.cjs';
+import '@stream-mdx/core';
+import '@stream-mdx/protocol';
+import '../trusted-mdx-contract-ElKpkDI5.cjs';
+import '@stream-mdx/worker/engine';
+import '../renderer/virtualized-code.cjs';

package/dist/components/katex-math.d.ts

@@ -0,0 +1,10 @@
+import 'react';
+export { au as DocumentMathMacroScope, av as DocumentMathMacroScopeContext, az as KaTeXBlockMath, ay as KaTeXInlineMath, ax as KaTeXMathProps, aw as MathExpressionCompletenessContext, at as loadKaTeX } from '../index-D7dyyu3q.js';
+import './bottom-stick-scroll-area.js';
+import 'react/jsx-runtime';
+import './diff-renderer.js';
+import '@stream-mdx/core';
+import '@stream-mdx/protocol';
+import '../trusted-mdx-contract-ElKpkDI5.js';
+import '@stream-mdx/worker/engine';
+import '../renderer/virtualized-code.js';

package/dist/components/katex-math.mjs

@@ -0,0 +1,188 @@
+"use client";
+
+// src/components/katex-math.tsx
+import { createContext, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var katexPromise = null;
+async function loadKaTeX() {
+  return katexPromise || (katexPromise = import("katex").then((mod) => mod && typeof mod == "object" && "default" in mod && mod.default ? mod.default : mod)), katexPromise;
+}
+var DOCUMENT_POSITION_PRECEDING = 2, DOCUMENT_POSITION_FOLLOWING = 4, DocumentMathMacroScope = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Set();
+    this.orderedEntries = [];
+    this.macroSnapshots = [];
+    this.katex = null;
+    this.loadError = null;
+    this.loading = !1;
+    this.disposed = !1;
+  }
+  register(element, tex, displayMode, complete, publish) {
+    let entry = { element, tex, displayMode, complete, publish };
+    return this.entries.add(entry), this.refresh(), () => {
+      this.entries.delete(entry) && this.refresh();
+    };
+  }
+  dispose() {
+    this.disposed = !0, this.entries.clear(), this.orderedEntries = [], this.macroSnapshots = [];
+  }
+  refresh() {
+    if (!this.disposed) {
+      if (this.loadError) {
+        for (let entry of this.entries)
+          entry.publish({ tex: entry.tex, displayMode: entry.displayMode, scope: this, error: this.loadError });
+        return;
+      }
+      if (this.katex) {
+        this.recompute(this.katex);
+        return;
+      }
+      this.loading || (this.loading = !0, loadKaTeX().then((katex) => {
+        this.disposed || (this.katex = katex, this.refresh());
+      }).catch((reason) => {
+        if (!this.disposed) {
+          this.loadError = reason instanceof Error ? reason : new Error(String(reason));
+          for (let entry of this.entries)
+            entry.publish({ tex: entry.tex, displayMode: entry.displayMode, scope: this, error: this.loadError });
+        }
+      }).finally(() => {
+        this.loading = !1;
+      }));
+    }
+  }
+  recompute(katex) {
+    let nextEntries = [...this.entries].sort((left, right) => {
+      let position = left.element.compareDocumentPosition(right.element);
+      return position & DOCUMENT_POSITION_FOLLOWING ? -1 : position & DOCUMENT_POSITION_PRECEDING ? 1 : 0;
+    }), unchangedPrefix = 0;
+    for (; unchangedPrefix < this.orderedEntries.length && unchangedPrefix < nextEntries.length && this.orderedEntries[unchangedPrefix] === nextEntries[unchangedPrefix]; )
+      unchangedPrefix += 1;
+    let macros = unchangedPrefix > 0 ? { ...this.macroSnapshots[unchangedPrefix - 1] } : {};
+    this.orderedEntries = nextEntries, this.macroSnapshots.length = unchangedPrefix;
+    for (let index = unchangedPrefix; index < nextEntries.length; index += 1) {
+      let entry = nextEntries[index], preparation = null;
+      if (entry.complete) {
+        let nextMacros = { ...macros };
+        try {
+          let html = katex.renderToString(entry.tex, {
+            displayMode: entry.displayMode,
+            throwOnError: !1,
+            trust: !1,
+            maxExpand: 1e3,
+            macros: nextMacros
+          });
+          macros = nextMacros, preparation = { tex: entry.tex, displayMode: entry.displayMode, scope: this, html };
+        } catch (reason) {
+          preparation = {
+            tex: entry.tex,
+            displayMode: entry.displayMode,
+            scope: this,
+            error: reason instanceof Error ? reason : new Error(String(reason))
+          };
+        }
+      }
+      this.macroSnapshots[index] = { ...macros }, entry.publish(preparation);
+    }
+  }
+}, DocumentMathMacroScopeContext = createContext(null), MathExpressionCompletenessContext = createContext(!0), MathEngineOutputView = ({ engine, tex, displayMode }) => {
+  let output = useMemo(
+    () => engine.render(tex, { displayMode }),
+    [engine, engine.id, tex, displayMode]
+  );
+  return /* @__PURE__ */ jsx(Fragment, { children: output });
+};
+function useMathPreparation(tex, displayMode, elementRef, enabled) {
+  let scope = useContext(DocumentMathMacroScopeContext), complete = useContext(MathExpressionCompletenessContext), [preparation, setPreparation] = useState(null);
+  return useEffect(() => {
+    if (!enabled) return;
+    let active = !0;
+    if (scope) {
+      let element = elementRef.current;
+      return element ? scope.register(element, tex, displayMode, complete, (result) => {
+        active && setPreparation(result);
+      }) : () => {
+        active = !1;
+      };
+    }
+    return (async () => {
+      try {
+        let html = (await loadKaTeX()).renderToString(tex, {
+          displayMode,
+          throwOnError: !1,
+          trust: !1,
+          maxExpand: 1e3
+        });
+        active && setPreparation({ tex, displayMode, scope: null, html });
+      } catch (reason) {
+        active && setPreparation({
+          tex,
+          displayMode,
+          scope: null,
+          error: reason instanceof Error ? reason : new Error(String(reason))
+        });
+      }
+    })(), () => {
+      active = !1;
+    };
+  }, [tex, displayMode, scope, complete, elementRef, enabled]), scope && !complete ? null : preparation?.tex === tex && preparation.displayMode === displayMode && preparation.scope === scope ? preparation : null;
+}
+var KaTeXInlineMath = ({ tex, className = "", fallback, engine }) => {
+  let elementRef = useRef(null), preparation = useMathPreparation(tex, !1, elementRef, !engine);
+  return engine ? /* @__PURE__ */ jsx("span", { className: `math-inline ${className}`.trim(), "data-tex": tex, children: /* @__PURE__ */ jsx(MathEngineOutputView, { engine, tex, displayMode: !1 }) }) : preparation && "error" in preparation && fallback ? /* @__PURE__ */ jsx(Fragment, { children: fallback(tex, preparation.error) }) : preparation && "html" in preparation ? /* @__PURE__ */ jsx(
+    "span",
+    {
+      ref: elementRef,
+      className: `math-inline katex-inline ${className}`.trim(),
+      "data-tex": tex,
+      dangerouslySetInnerHTML: { __html: preparation.html }
+    }
+  ) : /* @__PURE__ */ jsxs("span", { ref: elementRef, className: `math-inline ${className}`.trim(), "data-tex": tex, children: [
+    "$",
+    tex,
+    "$"
+  ] });
+};
+KaTeXInlineMath.displayName = "KaTeXInlineMath";
+var KaTeXBlockMath = ({ tex, className = "", fallback, engine }) => {
+  let elementRef = useRef(null), preparation = useMathPreparation(tex, !0, elementRef, !engine);
+  return engine ? /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `math-display markdown-math-display ${className}`.trim(),
+      "data-tex": tex,
+      style: { overflowX: "auto" },
+      children: /* @__PURE__ */ jsx(MathEngineOutputView, { engine, tex, displayMode: !0 })
+    }
+  ) : preparation && "error" in preparation && fallback ? /* @__PURE__ */ jsx(Fragment, { children: fallback(tex, preparation.error) }) : preparation && "html" in preparation ? /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: elementRef,
+      className: `math-display katex-block markdown-math-display ${className}`.trim(),
+      "data-tex": tex,
+      style: { overflowX: "auto" },
+      dangerouslySetInnerHTML: { __html: preparation.html }
+    }
+  ) : /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: elementRef,
+      className: `math-display markdown-math-display ${className}`.trim(),
+      "data-tex": tex,
+      style: { overflowX: "auto" },
+      children: /* @__PURE__ */ jsxs("span", { className: "math-display-content", children: [
+        "$$",
+        tex,
+        "$$"
+      ] })
+    }
+  );
+};
+KaTeXBlockMath.displayName = "KaTeXBlockMath";
+export {
+  DocumentMathMacroScope,
+  DocumentMathMacroScopeContext,
+  KaTeXBlockMath,
+  KaTeXInlineMath,
+  MathExpressionCompletenessContext,
+  loadKaTeX
+};