@bendyline/squisq-formats 2.8.8 → 2.8.9

package/dist/chunk-4LIFEQKX.js

@@ -0,0 +1,358 @@
+// src/diagrams/index.ts
+import {
+  extractPlainText,
+  isSvgIslandLang,
+  parseSvgIsland,
+  stringifyMarkdown
+} from "@bendyline/squisq/markdown";
+import {
+  TABLE_FED_TEMPLATES,
+  buildChartData,
+  detectAsciiDiagram,
+  detectAsciiTimeline,
+  detectTree,
+  isContainerTemplate,
+  isEligibleAsciiFenceLang,
+  isEligibleAsciiTimelineFenceLang,
+  isEligibleTreeFenceLang,
+  isExplicitDiagramLang,
+  isExplicitTimelineLang,
+  isExplicitTreeLang,
+  resolveTemplateName
+} from "@bendyline/squisq/doc";
+var DEFAULT_KINDS = [
+  "mermaid",
+  "diagram",
+  "timeline",
+  "tree",
+  "container",
+  "chart"
+];
+var EXPORT_DIAGRAM_KINDS = [...DEFAULT_KINDS, "svg"];
+var KIND_NAMES = {
+  mermaid: "Diagram",
+  diagram: "Diagram",
+  timeline: "Timeline",
+  tree: "Tree",
+  container: "Diagram",
+  svg: "Illustration",
+  chart: "Chart"
+};
+function fenceDiagramKind(node) {
+  const lang = node.lang ?? null;
+  if ((lang ?? "").trim().toLowerCase() === "mermaid") return "mermaid";
+  if (isSvgIslandLang(lang)) return parseSvgIsland(node.value).ok ? "svg" : null;
+  if (isEligibleAsciiFenceLang(lang)) {
+    const detection = detectAsciiDiagram(node.value, { explicit: isExplicitDiagramLang(lang) });
+    if (detection.isDiagram) return "diagram";
+  }
+  if (isEligibleTreeFenceLang(lang)) {
+    if (detectTree(node.value, { explicit: isExplicitTreeLang(lang) }).isTree) return "tree";
+  }
+  if (isEligibleAsciiTimelineFenceLang(lang)) {
+    const detection = detectAsciiTimeline(node.value, { explicit: isExplicitTimelineLang(lang) });
+    if (detection.isTimeline) return "timeline";
+  }
+  return null;
+}
+function containerTemplateOf(node) {
+  if (node.type !== "heading") return null;
+  const requested = node.templateAnnotation?.template;
+  if (!requested || !isContainerTemplate(requested)) return null;
+  return resolveTemplateName(requested);
+}
+function mermaidAlt(source) {
+  const title = /^\s*accTitle\s*:\s*(.+?)\s*$/mu.exec(source)?.[1] ?? "";
+  const description = /^\s*accDescr\s*:\s*(.+?)\s*$/mu.exec(source)?.[1] ?? "";
+  return [title, description].filter(Boolean).join(". ");
+}
+function fenceAlt(kind, source) {
+  if (kind === "mermaid") return mermaidAlt(source);
+  if (kind === "svg") {
+    const result = parseSvgIsland(source);
+    return result.ok && result.island.title || "";
+  }
+  return "";
+}
+function fenceMarkdown(node) {
+  return stringifyMarkdown({ type: "document", children: [node] }).trim();
+}
+function tableText(table) {
+  const [header, ...body] = table.children.map(
+    (row) => row.children.map((cell) => extractPlainText(cell).trim())
+  );
+  return { headers: header ?? [], rows: body };
+}
+function listParam(value) {
+  const entries = value?.split(",").map((entry) => entry.trim()).filter(Boolean);
+  return entries && entries.length > 0 ? entries : void 0;
+}
+var NON_CHART_PARAMS = /* @__PURE__ */ new Set([
+  "showTable",
+  "src",
+  "sheet",
+  "anchor",
+  "headerRow",
+  "titleAnchor",
+  "previewRows",
+  "sort",
+  "filter"
+]);
+function isTruthyParam(value) {
+  return value !== void 0 && value !== "false" && value !== "0";
+}
+function findChart(children, index) {
+  const heading = children[index];
+  const requested = heading.templateAnnotation?.template;
+  const template = requested ? resolveTemplateName(requested) : "";
+  if (!TABLE_FED_TEMPLATES.has(template) || template === "dataTable") return null;
+  let tableIndex = -1;
+  for (let at = index + 1; at < children.length; at++) {
+    const node = children[at];
+    if (node.type === "heading") break;
+    if (node.type === "table") {
+      tableIndex = at;
+      break;
+    }
+  }
+  if (tableIndex < 0) return null;
+  const table = children[tableIndex];
+  const params = heading.templateAnnotation?.params ?? {};
+  const data = buildChartData(tableText(table), {
+    labelColumn: params.labelColumn,
+    valueColumns: listParam(params.valueColumns)
+  });
+  if (!data) return null;
+  const { showTable } = params;
+  const chartParams = Object.fromEntries(
+    Object.entries(params).filter(([key]) => !NON_CHART_PARAMS.has(key))
+  );
+  const chartHeading = {
+    ...heading,
+    templateAnnotation: { template, params: chartParams }
+  };
+  const title = extractPlainText(heading).trim();
+  const plotted = data.series.map((series) => series.name).join(", ");
+  const what = `${template.replace(/Chart$/, "")} chart of ${plotted}${data.labelHeader ? ` by ${data.labelHeader}` : ""}`;
+  return {
+    chart: { headingIndex: index, tableIndex, keepTable: isTruthyParam(showTable) },
+    diagram: {
+      kind: "chart",
+      markdown: stringifyMarkdown({ type: "document", children: [chartHeading, table] }).trim(),
+      source: "",
+      template,
+      alt: title ? `${title}: ${what}` : what.charAt(0).toUpperCase() + what.slice(1)
+    }
+  };
+}
+function findInDocument(doc) {
+  const found = [];
+  const children = doc.children;
+  const walk = (nodes) => {
+    for (const node of nodes) {
+      if (node.type === "code") {
+        const fence = node;
+        const kind = fenceDiagramKind(fence);
+        if (kind) {
+          found.push({
+            fence,
+            diagram: {
+              kind,
+              markdown: fenceMarkdown(fence),
+              source: fence.value,
+              template: "",
+              alt: fenceAlt(kind, fence.value) || KIND_NAMES[kind]
+            }
+          });
+        }
+        continue;
+      }
+      const nested = node.children;
+      if (Array.isArray(nested) && node.type !== "heading" && node.type !== "paragraph") {
+        walk(nested);
+      }
+    }
+  };
+  for (let index = 0; index < children.length; index++) {
+    const node = children[index];
+    const template = containerTemplateOf(node);
+    if (!template) {
+      const chart = node.type === "heading" ? findChart(children, index) : null;
+      if (chart) found.push(chart);
+      walk([node]);
+      continue;
+    }
+    const depth = node.depth;
+    let end = index + 1;
+    while (end < children.length) {
+      const next = children[end];
+      if (next.type === "heading" && next.depth <= depth) break;
+      end++;
+    }
+    const heading = extractPlainText(node).trim();
+    found.push({
+      containerIndex: index,
+      containerEnd: end,
+      diagram: {
+        kind: "container",
+        markdown: stringifyMarkdown({
+          type: "document",
+          children: children.slice(index, end)
+        }).trim(),
+        source: "",
+        template,
+        alt: heading || KIND_NAMES.container
+      }
+    });
+    index = end - 1;
+  }
+  return found;
+}
+function imageUrls(nodes, into) {
+  for (const node of nodes) {
+    if (node.type === "image") into.add(node.url);
+    const nested = node.children;
+    if (Array.isArray(nested)) imageUrls(nested, into);
+  }
+  return into;
+}
+function findDiagrams(doc) {
+  return findInDocument(doc).map((entry) => entry.diagram);
+}
+function withoutTemplate(heading) {
+  const { templateAnnotation: _template, ...plain } = heading;
+  return plain;
+}
+function imageParagraph(url, alt) {
+  const image = { type: "image", url, alt, title: null };
+  return { type: "paragraph", children: [image] };
+}
+function replaceFences(nodes, replacements) {
+  let changed = false;
+  const next = nodes.map((node) => {
+    const replacement = replacements.get(node);
+    if (replacement) {
+      changed = true;
+      return replacement;
+    }
+    const nested = node.children;
+    if (Array.isArray(nested)) {
+      const replaced = replaceFences(nested, replacements);
+      if (replaced !== nested) {
+        changed = true;
+        return { ...node, children: replaced };
+      }
+    }
+    return node;
+  });
+  return changed ? next : nodes;
+}
+function cachingDiagramRasterizer(render, limit = 64) {
+  const drawn = /* @__PURE__ */ new Map();
+  return (diagram) => {
+    const key = `${diagram.kind}\0${diagram.markdown}\0${diagram.source}`;
+    let picture = drawn.get(key);
+    if (picture) {
+      drawn.delete(key);
+    } else {
+      picture = render(diagram);
+      picture.catch(() => drawn.delete(key));
+    }
+    drawn.set(key, picture);
+    if (drawn.size > limit) drawn.delete(drawn.keys().next().value);
+    return picture;
+  };
+}
+async function rasterizeDiagrams(doc, render, options = {}) {
+  const kinds = new Set(options.kinds ?? DEFAULT_KINDS);
+  const prefix = options.urlPrefix ?? "diagram";
+  const taken = imageUrls(doc.children, /* @__PURE__ */ new Set());
+  let counter = 0;
+  const nextUrl = () => {
+    let url;
+    do
+      url = `${prefix}-${String(++counter)}.png`;
+    while (taken.has(url));
+    taken.add(url);
+    return url;
+  };
+  const images = /* @__PURE__ */ new Map();
+  const mermaid = /* @__PURE__ */ new Map();
+  const svg = /* @__PURE__ */ new Map();
+  const fenceReplacements = /* @__PURE__ */ new Map();
+  const blockReplacements = [];
+  for (const entry of findInDocument(doc)) {
+    options.signal?.throwIfAborted();
+    if (!kinds.has(entry.diagram.kind)) continue;
+    let picture = null;
+    try {
+      picture = await render(entry.diagram);
+    } catch (error) {
+      options.onWarning?.(
+        `A ${KIND_NAMES[entry.diagram.kind].toLowerCase()} could not be drawn and was kept as text: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (!picture || picture.width <= 0 || picture.height <= 0) continue;
+    const data = picture.data instanceof Uint8Array ? picture.data : new Uint8Array(picture.data);
+    const url = nextUrl();
+    images.set(url, {
+      data,
+      contentType: "image/png",
+      width: picture.width,
+      height: picture.height
+    });
+    if (entry.diagram.kind === "mermaid") mermaid.set(entry.diagram.source.trim(), picture);
+    if (entry.diagram.kind === "svg") svg.set(entry.diagram.source.trim(), picture);
+    const paragraph = imageParagraph(url, entry.diagram.alt);
+    if (entry.fence) {
+      fenceReplacements.set(entry.fence, paragraph);
+    } else if (entry.containerIndex !== void 0 && entry.containerEnd !== void 0) {
+      blockReplacements.push({
+        start: entry.containerIndex,
+        end: entry.containerEnd,
+        nodes: [withoutTemplate(doc.children[entry.containerIndex]), paragraph]
+      });
+    } else if (entry.chart) {
+      const { headingIndex, tableIndex, keepTable } = entry.chart;
+      const table = doc.children[tableIndex];
+      blockReplacements.push(
+        {
+          start: headingIndex,
+          end: headingIndex + 1,
+          nodes: [withoutTemplate(doc.children[headingIndex])]
+        },
+        {
+          start: tableIndex,
+          end: tableIndex + 1,
+          nodes: keepTable ? [paragraph, table] : [paragraph]
+        }
+      );
+    }
+  }
+  let children = doc.children;
+  if (blockReplacements.length > 0) {
+    const rebuilt = [];
+    let cursor = 0;
+    for (const replacement of blockReplacements) {
+      rebuilt.push(...children.slice(cursor, replacement.start), ...replacement.nodes);
+      cursor = replacement.end;
+    }
+    rebuilt.push(...children.slice(cursor));
+    children = rebuilt;
+  }
+  if (fenceReplacements.size > 0) children = replaceFences(children, fenceReplacements);
+  return {
+    markdownDoc: children === doc.children ? doc : { ...doc, children },
+    images,
+    mermaid,
+    svg
+  };
+}
+
+export {
+  EXPORT_DIAGRAM_KINDS,
+  fenceDiagramKind,
+  findDiagrams,
+  cachingDiagramRasterizer,
+  rasterizeDiagrams
+};

package/dist/{chunk-UXEANVBI.js → chunk-5HUHSLGA.js}

@@ -8,9 +8,6 @@ import {
   parseCsv
 } from "./chunk-Q77KNJIN.js";
 
-// src/data/materialize.ts
-import { isDataFilePath } from "@bendyline/squisq/doc";
-
 // src/data/readers.ts
 import { applyTableViewState, parseTableViewState } from "@bendyline/squisq/table";
 function applyViewParams(headers, body, opts) {
@@ -152,89 +149,9 @@ function defaultDataReaders() {
   return [csvDataReader, xlsxDataReader, parquetDataReader];
 }
 
-// src/data/materialize.ts
-function tableRow(cells) {
-  return {
-    type: "tableRow",
-    children: cells.map((value) => ({
-      type: "tableCell",
-      children: value ? [{ type: "text", value }] : []
-    }))
-  };
-}
-function extensionOf(path) {
-  const base = path.split("/").pop() ?? path;
-  const dot = base.lastIndexOf(".");
-  return dot > 0 ? base.slice(dot + 1).toLowerCase() : "";
-}
-async function materializeDataReferences(markdownDoc, container, onWarning) {
-  const readers = defaultDataReaders();
-  const children = [];
-  let changed = false;
-  for (const node of markdownDoc.children) {
-    children.push(node);
-    if (node.type !== "heading") continue;
-    const params = node.templateAnnotation?.params;
-    const src = params?.src;
-    if (!src || !isDataFilePath(src)) continue;
-    const label = params?.sheet && params?.anchor ? `${params.sheet}!${params.anchor}` : src;
-    if (!container) {
-      onWarning?.(
-        `Data reference "${src}" could not be embedded: the export has no source container to read it from.`
-      );
-      continue;
-    }
-    const ext = extensionOf(src);
-    const reader = readers.find((r) => r.extensions.includes(ext));
-    if (!reader) {
-      onWarning?.(`Data reference "${src}" could not be embedded: no reader for ".${ext}".`);
-      continue;
-    }
-    let bytes = null;
-    try {
-      bytes = await container.readFile(src);
-    } catch {
-      bytes = null;
-    }
-    if (!bytes) {
-      onWarning?.(`Data reference "${src}" could not be embedded: file not found in container.`);
-      continue;
-    }
-    try {
-      const table = await reader.read(bytes, {
-        maxRows: Number.POSITIVE_INFINITY,
-        ...params?.sheet ? { sheet: params.sheet } : {},
-        ...params?.anchor ? { anchor: params.anchor } : {},
-        ...params?.headerRow !== void 0 ? { headerRow: params.headerRow !== "false" } : {},
-        // Exports honor the author's curated view: the sort/filter params
-        // shape the embedded full table exactly as they shape previews.
-        ...params?.sort ? { sort: params.sort } : {},
-        ...params?.filter ? { filter: params.filter } : {}
-      });
-      const mdTable = {
-        type: "table",
-        children: [tableRow(table.headers), ...table.rows.map(tableRow)]
-      };
-      children.push(mdTable);
-      changed = true;
-      if (ext === "xlsx") {
-        onWarning?.(
-          `Region ${label} exported as values; formulas in the sidecar workbook were not carried over.`
-        );
-      }
-    } catch (err) {
-      onWarning?.(
-        `Data reference "${src}" could not be embedded: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-  }
-  return changed ? { ...markdownDoc, children } : markdownDoc;
-}
-
 export {
   csvDataReader,
   xlsxDataReader,
   parquetDataReader,
-  defaultDataReaders,
-  materializeDataReferences
+  defaultDataReaders
 };

package/dist/{chunk-6ALSRHD7.js → chunk-6HUQFEP3.js}

@@ -1,7 +1,7 @@
 import {
   convert,
   defaultRegistry
-} from "./chunk-GDUZJ75A.js";
+} from "./chunk-WVDAFJFS.js";
 import {
   ConversionError
 } from "./chunk-KXOZMWBS.js";
@@ -188,7 +188,9 @@ async function renderOutsideInDocument(source, options = {}) {
       { format: "html" }
     );
   }
-  const formatOptions = { ...options.formatOptions ?? {} };
+  const formatOptions = {
+    ...options.formatOptions ?? {}
+  };
   if (layout.format === "html" && options.html) {
     formatOptions.html = {
       ...formatOptions.html ?? {},
@@ -196,10 +198,19 @@ async function renderOutsideInDocument(source, options = {}) {
       basePath: options.html.basePath ?? layout.companionName
     };
   }
-  return convert(
+  const warnings = [];
+  const markdown = await prepareOutsideInMarkdown(
+    source.markdown,
+    layout.format,
+    source.container,
+    options,
+    formatOptions,
+    warnings
+  );
+  const result = await convert(
     {
       kind: "markdown",
-      markdown: source.markdown,
+      markdown,
       container: source.container,
       baseName: layout.stem
     },
@@ -210,6 +221,52 @@ async function renderOutsideInDocument(source, options = {}) {
       formatOptions
     }
   );
+  return warnings.length > 0 ? { ...result, warnings: [...warnings, ...result.warnings] } : result;
+}
+async function prepareOutsideInMarkdown(markdown, format, container, options, formatOptions, warnings) {
+  const render = options.renderDiagram;
+  if (!render || format !== "docx" && format !== "pdf" && format !== "pptx") return markdown;
+  const onWarning = (message) => {
+    warnings.push(message);
+  };
+  let doc = typeof markdown === "string" ? parseMarkdown(markdown) : markdown;
+  const { rasterizeDiagrams, EXPORT_DIAGRAM_KINDS } = await import("./diagrams/index.js");
+  const signal = options.signal;
+  if (format === "pptx") {
+    const { mermaid, svg } = await rasterizeDiagrams(doc, render, {
+      kinds: ["mermaid", "svg"],
+      signal,
+      onWarning
+    });
+    formatOptions.pptx = {
+      ...formatOptions.pptx,
+      diagramImages: new Map([...mermaid, ...svg, ...formatOptions.pptx?.diagramImages ?? []])
+    };
+    return doc;
+  }
+  const { materializeDataReferences, DATA_PREVIEW_ROWS } = await import("./materialize-ICXNO4S4.js");
+  doc = await materializeDataReferences(doc, container, onWarning, {
+    maxRows: DATA_PREVIEW_ROWS
+  });
+  const pictured = await rasterizeDiagrams(doc, render, {
+    kinds: format === "pdf" ? EXPORT_DIAGRAM_KINDS : void 0,
+    signal,
+    onWarning
+  });
+  if (format === "docx") {
+    const { svg } = await rasterizeDiagrams(doc, render, { kinds: ["svg"], signal, onWarning });
+    formatOptions.docx = {
+      ...formatOptions.docx,
+      images: new Map([...formatOptions.docx?.images ?? [], ...pictured.images]),
+      svgIslandFallbacks: new Map([...svg, ...formatOptions.docx?.svgIslandFallbacks ?? []])
+    };
+  } else {
+    formatOptions.pdf = {
+      ...formatOptions.pdf,
+      images: new Map([...formatOptions.pdf?.images ?? [], ...pictured.images])
+    };
+  }
+  return pictured.markdownDoc;
 }
 
 export {

package/dist/{chunk-BXWNU4T5.js → chunk-DTJQK7U7.js}

@@ -1,3 +1,45 @@
+// src/shared/blockTags.ts
+import {
+  detectPromotableBodyAnnotation,
+  hasTemplate,
+  isMediaAnnotationName,
+  parseStandaloneAnnotation
+} from "@bendyline/squisq/doc";
+function withoutBlockTags(doc, options = {}) {
+  const children = withoutPromotedTags(doc.children);
+  const kept = children.filter((node) => !isRemovedTag(node, options));
+  return kept.length === doc.children.length && children === doc.children ? doc : { ...doc, children: kept };
+}
+function isRemovedTag(node, options) {
+  const tag = parseStandaloneAnnotation(node)?.template;
+  if (!tag) return false;
+  if (isMediaAnnotationName(tag)) return !options.keepMedia;
+  return hasTemplate(tag);
+}
+function withoutPromotedTags(children) {
+  const out = [];
+  let changed = false;
+  let index = 0;
+  while (index < children.length) {
+    const node = children[index++];
+    out.push(node);
+    if (node.type !== "heading" || node.templateAnnotation?.template) continue;
+    let end = index;
+    while (end < children.length && children[end].type !== "heading") end++;
+    const body = children.slice(index, end);
+    const found = detectPromotableBodyAnnotation(body);
+    const tag = found?.data.template;
+    if (found && tag && !isMediaAnnotationName(tag) && hasTemplate(tag)) {
+      out.push(...found.strippedContents);
+      changed = true;
+    } else {
+      out.push(...body);
+    }
+    index = end;
+  }
+  return changed ? out : children;
+}
+
 // src/shared/footnotes.ts
 var FootnoteIndex = class {
   constructor(doc) {
@@ -102,6 +144,7 @@ function renumberFootnotes(doc) {
 }
 
 export {
+  withoutBlockTags,
   FootnoteIndex,
   footnoteIds,
   renumberFootnotes

package/dist/{chunk-QU4EVC62.js → chunk-GFHUJ7L4.js}

@@ -60,7 +60,7 @@ import {
   fontAwesomeFace,
   fontAwesomeFaces,
   fontAwesomeGlyph
-} from "./chunk-LBXBRFBZ.js";
+} from "./chunk-DDMPZZJF.js";
 import {
   extToMime,
   readImageDimensions

package/dist/{chunk-TMOXUUTG.js → chunk-NQNIFIDP.js}

@@ -2,8 +2,9 @@ import {
   upngEncoder
 } from "./chunk-34KECNZO.js";
 import {
-  FootnoteIndex
-} from "./chunk-BXWNU4T5.js";
+  FootnoteIndex,
+  withoutBlockTags
+} from "./chunk-DTJQK7U7.js";
 import {
   buildContainer
 } from "./chunk-IIQYS2YH.js";
@@ -11,7 +12,7 @@ import {
   collectInlineIconFamilies,
   fontAwesomeFaces,
   fontAwesomeGlyph
-} from "./chunk-LBXBRFBZ.js";
+} from "./chunk-DDMPZZJF.js";
 import {
   authoredImageSize,
   fitWithin,
@@ -499,8 +500,9 @@ var IMPORT_TABLE_MIN_ROWS = 2;
 var IMPORT_URL_PATTERN = /https?:\/\/[^\s)>\]]+/g;
 
 // src/pdf/export.ts
-async function markdownDocToPdf(doc, options = {}) {
+async function markdownDocToPdf(source, options = {}) {
   options.signal?.throwIfAborted();
+  const doc = withoutBlockTags(source);
   const pdfDoc = await PDFDocument.create();
   if (options.title) pdfDoc.setTitle(options.title);
   if (options.author) pdfDoc.setAuthor(options.author);