@bendyline/squisq-formats 2.8.8 → 2.8.10

package/README.md

@@ -337,19 +337,21 @@ Also exported: `createRegistry` / `defaultRegistry` / `defaultFormats`, `BUILTIN
 
 ## Subpath Exports
 
-| Subpath                               | Contents                                                                        |
-| ------------------------------------- | ------------------------------------------------------------------------------- |
-| `@bendyline/squisq-formats/docx`      | DOCX import/export (+ `docxToContainer`)                                        |
-| `@bendyline/squisq-formats/pdf`       | PDF import/export (+ `pdfToContainer`, `configurePdfWorker`)                    |
-| `@bendyline/squisq-formats/html`      | Player HTML export, static plain-HTML export + bundles, HTML import             |
-| `@bendyline/squisq-formats/epub`      | EPUB 3 e-book export (with optional Media Overlays)                             |
-| `@bendyline/squisq-formats/pptx`      | PPTX export + import (text/lists/tables + slide images)                         |
-| `@bendyline/squisq-formats/xlsx`      | XLSX import + tables-only export                                                |
-| `@bendyline/squisq-formats/csv`       | CSV import/export (RFC 4180)                                                    |
-| `@bendyline/squisq-formats/ooxml`     | Shared OOXML infrastructure (package reader/writer, XML utilities, namespaces)  |
-| `@bendyline/squisq-formats/diagrams`  | `rasterizeDiagrams` / `findDiagrams`: diagrams as pictures for document exports |
-| `@bendyline/squisq-formats/container` | `ContentContainer` ↔ ZIP serialization                                          |
-| `@bendyline/squisq-formats/registry`  | Format registry + programmatic `convert()` (also re-exported from the root)     |
+| Subpath                                  | Contents                                                                        |
+| ---------------------------------------- | ------------------------------------------------------------------------------- |
+| `@bendyline/squisq-formats/docx`         | DOCX import/export (+ `docxToContainer`)                                        |
+| `@bendyline/squisq-formats/pdf`          | PDF import/export (+ `pdfToContainer`, `configurePdfWorker`)                    |
+| `@bendyline/squisq-formats/html`         | Player HTML export, static plain-HTML export + bundles, HTML import             |
+| `@bendyline/squisq-formats/html-prepare` | `prepareMarkdownDocForPlainHtml`: data tables and pictures for plain-HTML pages |
+| `@bendyline/squisq-formats/html-icons`   | `plainHtmlIcons`: inline icons as SVG outlines for plain-HTML pages             |
+| `@bendyline/squisq-formats/epub`         | EPUB 3 e-book export (with optional Media Overlays)                             |
+| `@bendyline/squisq-formats/pptx`         | PPTX export + import (text/lists/tables + slide images)                         |
+| `@bendyline/squisq-formats/xlsx`         | XLSX import + tables-only export                                                |
+| `@bendyline/squisq-formats/csv`          | CSV import/export (RFC 4180)                                                    |
+| `@bendyline/squisq-formats/ooxml`        | Shared OOXML infrastructure (package reader/writer, XML utilities, namespaces)  |
+| `@bendyline/squisq-formats/diagrams`     | `rasterizeDiagrams` / `findDiagrams`: diagrams as pictures for document exports |
+| `@bendyline/squisq-formats/container`    | `ContentContainer` ↔ ZIP serialization                                          |
+| `@bendyline/squisq-formats/registry`     | Format registry + programmatic `convert()` (also re-exported from the root)     |
 
 The package root re-exports the common converters; `./container`, the plain-HTML/bundle functions, `docxToContainer`, `pdfToContainer`, `PdfPageSize`, and the image utilities are subpath-only.
 

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-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