tiptap-markdown-react 0.18.0 → 0.19.0

package/dist/{extractToc-BaR6LP1f.js → extractToc-CGrBMGvM.js}

@@ -1,18 +1,21 @@
-import { Node, mergeAttributes, Mark } from "@tiptap/core";
+import { Node, mergeAttributes, Mark, Extension } from "@tiptap/core";
 import Code from "@tiptap/extension-code";
 import CodeBlockLowlight from "@tiptap/extension-code-block-lowlight";
+import Heading from "@tiptap/extension-heading";
 import Highlight from "@tiptap/extension-highlight";
 import Image from "@tiptap/extension-image";
+import Paragraph from "@tiptap/extension-paragraph";
 import Subscript from "@tiptap/extension-subscript";
 import Superscript from "@tiptap/extension-superscript";
 import { TableKit } from "@tiptap/extension-table";
 import TaskItem from "@tiptap/extension-task-item";
 import TaskList from "@tiptap/extension-task-list";
+import TextAlign from "@tiptap/extension-text-align";
 import { Color, TextStyle, FontSize } from "@tiptap/extension-text-style";
 import StarterKit from "@tiptap/starter-kit";
 import { createLowlight, common } from "lowlight";
 import { Plugin, PluginKey } from "@tiptap/pm/state";
-import { p as parseChartFenceBody, s as serializeChartPayload, n as normalizeChartMarkdown } from "./ReportContent-MgbebxPV.js";
+import { p as parseChartFenceBody, s as serializeChartPayload, n as normalizeChartMarkdown } from "./ReportContent-B8jIzhy3.js";
 import { InlineMath, BlockMath } from "@tiptap/extension-mathematics";
 import katex from "katex";
 const CitationRef = Node.create({
@@ -580,6 +583,176 @@ function parseCodeTokenAsChartOrCodeBlock(token, helpers, codeBlockName = "codeB
     token.text ? [helpers.createTextNode(token.text)] : []
   );
 }
+const IMAGE_ALIGN_VALUES = /* @__PURE__ */ new Set(["left", "center", "right"]);
+function normalizeImageAlign(value) {
+  return typeof value === "string" && IMAGE_ALIGN_VALUES.has(value) ? value : null;
+}
+const imageAlignAttribute = {
+  default: null,
+  parseHTML: (element) => normalizeImageAlign(element.getAttribute("data-align")),
+  renderHTML: (attributes) => {
+    const align = normalizeImageAlign(attributes.align);
+    return align ? { "data-align": align } : {};
+  }
+};
+const imageCaptionAttribute = {
+  default: null,
+  parseHTML: (element) => {
+    var _a;
+    const figure = element.closest("figure");
+    return normalizeImageCaption(
+      ((_a = figure == null ? void 0 : figure.querySelector("figcaption")) == null ? void 0 : _a.textContent) ?? null
+    );
+  },
+  renderHTML: () => ({})
+};
+function imageNodeHtml(output) {
+  const caption = normalizeImageCaption(output.attrs.caption);
+  if (!caption) return ["img", output.htmlAttributes];
+  return [
+    "figure",
+    { class: "tmr-image-figure" },
+    ["img", output.htmlAttributes],
+    ["figcaption", { class: "tmr-image-caption" }, caption]
+  ];
+}
+function imageFigureParseRule() {
+  return {
+    tag: "figure",
+    getAttrs: (element) => {
+      const img = element.querySelector("img");
+      if (!img) return false;
+      const caption = element.querySelector("figcaption");
+      return {
+        src: img.getAttribute("src"),
+        alt: img.getAttribute("alt"),
+        title: img.getAttribute("title"),
+        width: toPixel(img.getAttribute("width")),
+        height: toPixel(img.getAttribute("height")),
+        align: normalizeImageAlign(img.getAttribute("data-align")),
+        caption: normalizeImageCaption((caption == null ? void 0 : caption.textContent) ?? null)
+      };
+    }
+  };
+}
+function attrValue(attrs, name) {
+  const pattern = new RegExp(
+    `(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'=<>]+))`,
+    "i"
+  );
+  const match = pattern.exec(attrs);
+  if (!match) return null;
+  return match[1] ?? match[2] ?? match[3] ?? null;
+}
+const ENTITIES = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'"
+};
+function decodeEntities(text) {
+  return text.replace(/&(?:amp|lt|gt|quot|#39);/g, (m) => ENTITIES[m] ?? m);
+}
+function encodeAttr$1(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function encodeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function normalizeImageCaption(value) {
+  if (typeof value !== "string") return null;
+  const text = value.trim();
+  return text === "" ? null : text;
+}
+function toPixel(value) {
+  if (value == null) return null;
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.round(n) : null;
+}
+function imageRenderMarkdown(node) {
+  const attrs = node.attrs ?? {};
+  const src = typeof attrs.src === "string" ? attrs.src : "";
+  const alt = typeof attrs.alt === "string" ? attrs.alt : "";
+  const title = typeof attrs.title === "string" ? attrs.title : "";
+  const width = toPixel(attrs.width == null ? null : String(attrs.width));
+  const height = toPixel(attrs.height == null ? null : String(attrs.height));
+  const align = normalizeImageAlign(attrs.align);
+  const caption = normalizeImageCaption(attrs.caption);
+  if (width == null && height == null && !align && !caption) {
+    return title ? `![${alt}](${src} "${title}")` : `![${alt}](${src})`;
+  }
+  const parts = [`src="${encodeAttr$1(src)}"`];
+  if (alt) parts.push(`alt="${encodeAttr$1(alt)}"`);
+  if (title) parts.push(`title="${encodeAttr$1(title)}"`);
+  if (width != null) parts.push(`width="${width}"`);
+  if (height != null) parts.push(`height="${height}"`);
+  if (align) parts.push(`data-align="${align}"`);
+  const imgTag = `<img ${parts.join(" ")}>`;
+  if (!caption) return imgTag;
+  return `<figure>
+${imgTag}
+<figcaption>${encodeText(caption)}</figcaption>
+</figure>`;
+}
+function imageTokenFromImgTag(raw, attrsString, caption = null) {
+  const srcValue = attrValue(attrsString, "src");
+  if (!srcValue) return void 0;
+  const alt = attrValue(attrsString, "alt");
+  const title = attrValue(attrsString, "title");
+  return {
+    type: "image",
+    raw,
+    src: decodeEntities(srcValue),
+    alt: alt == null ? null : decodeEntities(alt),
+    title: title == null ? null : decodeEntities(title),
+    width: toPixel(attrValue(attrsString, "width")),
+    height: toPixel(attrValue(attrsString, "height")),
+    align: normalizeImageAlign(attrValue(attrsString, "data-align")),
+    caption
+  };
+}
+const imageMarkdownTokenizer = {
+  name: "image",
+  level: "block",
+  start(src) {
+    const figure = /<figure[\s>]/i.exec(src);
+    const img = /<img[\s>]/i.exec(src);
+    const indexes = [figure == null ? void 0 : figure.index, img == null ? void 0 : img.index].filter(
+      (index) => index != null
+    );
+    return indexes.length ? Math.min(...indexes) : -1;
+  },
+  tokenize(src) {
+    const figure = /^<figure\s*>([\s\S]*?)<\/figure\s*>/i.exec(src);
+    if (figure) {
+      const inner = figure[1] ?? "";
+      const img = /<img\s+([^>]*?)\s*\/?>/.exec(inner);
+      if (!img) return void 0;
+      const cap = /<figcaption[^>]*>([\s\S]*?)<\/figcaption\s*>/i.exec(inner);
+      const caption = cap ? normalizeImageCaption(
+        decodeEntities((cap[1] ?? "").replace(/<[^>]*>/g, ""))
+      ) : null;
+      return imageTokenFromImgTag(figure[0], img[1] ?? "", caption);
+    }
+    const match = /^<img\s+([^>]*?)\s*\/?>/.exec(src);
+    if (!match) return void 0;
+    return imageTokenFromImgTag(match[0], match[1] ?? "");
+  }
+};
+function imageParseMarkdown(token, helpers) {
+  const src = typeof token.src === "string" ? token.src : token.href ?? null;
+  const alt = typeof token.alt === "string" ? token.alt : token.text ?? null;
+  return helpers.createNode("image", {
+    src,
+    alt,
+    title: token.title ?? null,
+    width: token.width ?? null,
+    height: token.height ?? null,
+    align: token.align ?? null,
+    caption: normalizeImageCaption(token.caption)
+  });
+}
 const KATEX_OPTIONS = { throwOnError: false };
 let mathClickListener = null;
 function subscribeMathClick(listener) {
@@ -683,6 +856,196 @@ $$`;
   katexOptions: { ...KATEX_OPTIONS, displayMode: true },
   onClick: (node, pos) => emitClick("block", node, pos)
 });
+const INDENT_STEP_EM = 2;
+const TEXT_ALIGN_VALUES = /* @__PURE__ */ new Set(["left", "center", "right", "justify"]);
+function encodeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+const KNOWN_STYLE_KEYS = ["text-align", "margin-left", "line-height"];
+function paragraphStyleString(attrs) {
+  const parts = [];
+  const align = typeof attrs.textAlign === "string" ? attrs.textAlign : null;
+  if (align && TEXT_ALIGN_VALUES.has(align)) {
+    parts.push(`text-align: ${align}`);
+  }
+  const indent = Number(attrs.indent);
+  if (Number.isFinite(indent) && indent > 0) {
+    parts.push(`margin-left: ${indent * INDENT_STEP_EM}em`);
+  }
+  const lineHeight = Number(attrs.lineHeight);
+  if (Number.isFinite(lineHeight) && lineHeight > 0) {
+    parts.push(`line-height: ${lineHeight}`);
+  }
+  return parts.join("; ");
+}
+function parseParagraphStyleAttrs(style) {
+  const attrs = {};
+  for (const entry of style.split(";")) {
+    const index = entry.indexOf(":");
+    if (index < 0) continue;
+    const key = entry.slice(0, index).trim().toLowerCase();
+    const value = entry.slice(index + 1).trim();
+    if (!value) continue;
+    if (key === "text-align" && TEXT_ALIGN_VALUES.has(value)) {
+      attrs.textAlign = value;
+    } else if (key === "margin-left") {
+      const match = /^([\d.]+)em$/.exec(value);
+      const em = match ? Number.parseFloat(match[1]) : NaN;
+      const level = Number.isFinite(em) && em > 0 ? Math.round(em / INDENT_STEP_EM) : 0;
+      if (level > 0) attrs.indent = level;
+    } else if (key === "line-height") {
+      const parsed = Number.parseFloat(value);
+      if (Number.isFinite(parsed) && parsed > 0) attrs.lineHeight = parsed;
+    }
+  }
+  return attrs;
+}
+function hasKnownStyle(style) {
+  const lowered = style.toLowerCase();
+  return KNOWN_STYLE_KEYS.some((key) => lowered.includes(`${key}:`));
+}
+function paragraphRenderMarkdown(node, helpers) {
+  const children = helpers.renderChildren(node.content ?? []);
+  const style = paragraphStyleString(
+    node.attrs ?? {}
+  );
+  if (!style) return children;
+  return `<p style="${encodeAttr(style)}">${children}</p>`;
+}
+function headingRenderMarkdown(node, helpers) {
+  var _a;
+  const children = helpers.renderChildren(node.content ?? []);
+  const level = Math.min(
+    Math.max(Number((_a = node.attrs) == null ? void 0 : _a.level) || 1, 1),
+    6
+  );
+  const style = paragraphStyleString(
+    node.attrs ?? {}
+  );
+  if (!style) return `${"#".repeat(level)} ${children}`;
+  return `<h${level} style="${encodeAttr(style)}">${children}</h${level}>`;
+}
+const paragraphMarkdownTokenizer = {
+  name: "paragraph",
+  level: "block",
+  start(src) {
+    const match = /<(?:p|h[1-6])\s+style=/i.exec(src);
+    return match ? match.index : -1;
+  },
+  tokenize(src, _tokens, lexer) {
+    const match = /^<(p|h([1-6]))\s+style="([^"]*)"\s*>([\s\S]*?)<\/\1\s*>/i.exec(
+      src
+    );
+    if (!match) return void 0;
+    const [, tag, headingLevel, style, inner] = match;
+    if (!hasKnownStyle(style)) return void 0;
+    return {
+      type: "paragraph",
+      raw: match[0],
+      tag,
+      hLevel: headingLevel ? Number(headingLevel) : null,
+      style,
+      // 行内内容交给 marked 的 lexer 解析：bold / link 等照常还原（与 sup/sub 同一手法）
+      tokens: lexer.inlineTokens(inner ?? "")
+    };
+  }
+};
+const ROW_BLOCK_TYPES = /* @__PURE__ */ new Set(["image", "chart"]);
+function paragraphParseMarkdown(token, helpers) {
+  const attrs = parseParagraphStyleAttrs(String(token.style ?? ""));
+  const content = helpers.parseInline(token.tokens ?? []);
+  const blockOnly = content.length > 0 && Object.keys(attrs).length === 0 && content.every((child) => ROW_BLOCK_TYPES.has(String(child.type)));
+  if (blockOnly) return content;
+  if (token.hLevel) {
+    return helpers.createNode("heading", { level: token.hLevel, ...attrs }, content);
+  }
+  return helpers.createNode("paragraph", attrs, content);
+}
+function parseIndentValue(value, stepEm) {
+  if (!value) return null;
+  const match = /^([\d.]+)em$/.exec(value.trim());
+  if (!match) return null;
+  const em = Number.parseFloat(match[1]);
+  if (!Number.isFinite(em) || em <= 0) return null;
+  const level = Math.round(em / stepEm);
+  return level > 0 ? level : null;
+}
+function parseLineHeightValue(value) {
+  if (!value) return null;
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+function clampIndent(level, max) {
+  if (!Number.isFinite(level) || level <= 0) return 0;
+  return Math.min(Math.round(level), max);
+}
+const ParagraphStyles = Extension.create({
+  name: "paragraphStyles",
+  addOptions() {
+    return {
+      types: [],
+      indentStepEm: 2,
+      maxIndent: 8
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          indent: {
+            default: null,
+            parseHTML: (element) => parseIndentValue(element.style.marginLeft, this.options.indentStepEm),
+            renderHTML: (attributes) => {
+              const level = clampIndent(
+                Number(attributes.indent),
+                this.options.maxIndent
+              );
+              if (level === 0) return {};
+              return {
+                style: `margin-left: ${level * this.options.indentStepEm}em`
+              };
+            }
+          },
+          lineHeight: {
+            default: null,
+            parseHTML: (element) => parseLineHeightValue(element.style.lineHeight),
+            renderHTML: (attributes) => {
+              const value = Number(attributes.lineHeight);
+              if (!Number.isFinite(value) || value <= 0) return {};
+              return { style: `line-height: ${value}` };
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    const runOnTypes = (attrs) => (props) => this.options.types.map((type) => props.commands.updateAttributes(type, attrs)).some((response) => response);
+    const currentIndent = ({ editor }) => {
+      for (const type of this.options.types) {
+        const value = editor.getAttributes(type).indent;
+        if (value != null) return Number(value) || 0;
+      }
+      return 0;
+    };
+    return {
+      setIndent: (level) => (props) => {
+        const next = clampIndent(Number(level), this.options.maxIndent);
+        return runOnTypes({ indent: next || null })(props);
+      },
+      increaseIndent: () => (props) => runOnTypes({
+        indent: clampIndent(currentIndent(props) + 1, this.options.maxIndent) || null
+      })(props),
+      decreaseIndent: () => (props) => runOnTypes({
+        indent: clampIndent(currentIndent(props) - 1, this.options.maxIndent) || null
+      })(props),
+      setLineHeight: (value) => (props) => runOnTypes({
+        lineHeight: value == null ? null : parseLineHeightValue(String(value))
+      })(props)
+    };
+  }
+});
 const InlineCode = Code.extend({
   excludes: ""
 });
@@ -739,10 +1102,61 @@ const MarkdownSubscript = Subscript.extend({
 const pureCodeBlock = CodeBlockLowlight.extend({
   parseMarkdown: (token, helpers) => parseCodeTokenAsChartOrCodeBlock(token, helpers, "codeBlock")
 }).configure({ lowlight });
-const pureImage = Image.configure({ inline: false });
+const pureImage = Image.extend({
+  addAttributes() {
+    var _a;
+    return {
+      ...((_a = Image.config.addAttributes) == null ? void 0 : _a.call(this)) ?? {},
+      align: imageAlignAttribute,
+      caption: imageCaptionAttribute
+    };
+  },
+  parseHTML() {
+    return [
+      imageFigureParseRule(),
+      {
+        tag: this.options.allowBase64 ? "img[src]" : 'img[src]:not([src^="data:"])'
+      }
+    ];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    return imageNodeHtml({
+      attrs: node.attrs,
+      htmlAttributes: mergeAttributes(
+        this.options.HTMLAttributes,
+        HTMLAttributes
+      )
+    });
+  },
+  renderMarkdown: imageRenderMarkdown,
+  parseMarkdown: imageParseMarkdown,
+  markdownTokenizer: imageMarkdownTokenizer
+}).configure({ inline: false });
+const MarkdownParagraph = Paragraph.extend({
+  renderMarkdown: paragraphRenderMarkdown,
+  markdownTokenizer: paragraphMarkdownTokenizer,
+  parseMarkdown: paragraphParseMarkdown
+});
+const MarkdownHeading = Heading.extend({
+  renderMarkdown: headingRenderMarkdown
+});
 const baseExtensions = [
-  // 禁用 StarterKit 内置 codeBlock / code，统一改用 lowlight 代码块 + 可共存的 InlineCode
-  StarterKit.configure({ codeBlock: false, code: false }),
+  // 禁用 StarterKit 内置 codeBlock / code（改用 lowlight 代码块 + 可共存的 InlineCode）
+  // 与 paragraph / heading（改用带 markdown 样式往返的版本，见上）
+  StarterKit.configure({
+    codeBlock: false,
+    code: false,
+    paragraph: false,
+    heading: false
+  }),
+  MarkdownParagraph,
+  MarkdownHeading,
+  // 段落级样式：文字对齐用官方扩展（免费）；缩进 / 行高自研（官方无此扩展）。
+  // 三者都往节点 style 上写片段，tiptap 的 mergeAttributes 对 style 做拼接合并。
+  TextAlign.configure({ types: [MarkdownParagraph.name, MarkdownHeading.name] }),
+  ParagraphStyles.configure({
+    types: [MarkdownParagraph.name, MarkdownHeading.name]
+  }),
   InlineCode,
   MarkdownTextStyle,
   Color.configure({ types: [TextStyle.name] }),
@@ -840,7 +1254,9 @@ function extractToc(doc, lockedTitles = []) {
   return items;
 }
 export {
+  subscribeMathClick as A,
   CitationRef as C,
+  ParagraphStyles as P,
   pureCodeBlock as a,
   baseExtensions as b,
   pureImage as c,
@@ -854,10 +1270,18 @@ export {
   parseCodeTokenAsChartOrCodeBlock as k,
   lowlight as l,
   makeTocGetId as m,
-  renderMathInto as n,
-  subscribeMathClick as o,
+  normalizeImageAlign as n,
+  imageMarkdownTokenizer as o,
   prepareChartMarkdown as p,
+  imageParseMarkdown as q,
   renderMathElementHtml as r,
-  stabilizeMarkdown as s
+  stabilizeMarkdown as s,
+  imageRenderMarkdown as t,
+  imageNodeHtml as u,
+  imageFigureParseRule as v,
+  imageCaptionAttribute as w,
+  imageAlignAttribute as x,
+  normalizeImageCaption as y,
+  renderMathInto as z
 };
-//# sourceMappingURL=extractToc-BaR6LP1f.js.map
+//# sourceMappingURL=extractToc-CGrBMGvM.js.map