@bendyline/squisq-formats 2.5.1 → 2.6.1

package/dist/chunk-DXYWKZ52.js

@@ -0,0 +1,57 @@
+// src/data/sidecar.ts
+import { dataSidecarPrefix } from "@bendyline/squisq/doc";
+import { stringifyMarkdown } from "@bendyline/squisq/markdown";
+function sanitizeSourceFileName(name, fallback) {
+  const base = (name ?? "").split(/[\\/]/).pop()?.trim() ?? "";
+  return base || fallback;
+}
+function docSlugForFileName(fileName) {
+  const stem = fileName.replace(/\.[^.]+$/, "");
+  const slug = stem.normalize("NFKD").replace(/\p{Mark}+/gu, "").toLocaleLowerCase("en-US").replace(/[^\p{Letter}\p{Number}]+/gu, "-").replace(/^-+|-+$/g, "");
+  return slug || "document";
+}
+function planDataSidecar(sourceName, fallbackName) {
+  const fileName = sanitizeSourceFileName(sourceName, fallbackName);
+  const slug = docSlugForFileName(fileName);
+  return {
+    slug,
+    markdownFilename: `${slug}.md`,
+    fileName,
+    sidecarPath: `${dataSidecarPrefix(slug)}${fileName}`
+  };
+}
+function sidecarReferenceDoc(plan) {
+  const title = plan.fileName.replace(/\.[^.]+$/, "");
+  return {
+    type: "document",
+    children: [
+      {
+        type: "heading",
+        depth: 1,
+        children: [{ type: "text", value: title }],
+        templateAnnotation: { template: "dataTable", params: { src: plan.sidecarPath } }
+      },
+      {
+        type: "paragraph",
+        children: [
+          {
+            type: "link",
+            url: plan.sidecarPath,
+            children: [{ type: "text", value: plan.fileName }]
+          }
+        ]
+      }
+    ]
+  };
+}
+function sidecarReferenceMarkdown(plan) {
+  return stringifyMarkdown(sidecarReferenceDoc(plan));
+}
+
+export {
+  sanitizeSourceFileName,
+  docSlugForFileName,
+  planDataSidecar,
+  sidecarReferenceDoc,
+  sidecarReferenceMarkdown
+};

package/dist/chunk-FLR2ARKC.js

@@ -0,0 +1,240 @@
+import {
+  columnLetter2 as columnLetter,
+  parseCellRef,
+  xlsxToTables
+} from "./chunk-OBADJV7C.js";
+import {
+  SIDECAR_CSV_LIMITS,
+  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) {
+  if (!opts.sort && !opts.filter) return { body };
+  const { view, issues } = parseTableViewState(opts.sort, opts.filter, headers);
+  const applied = applyTableViewState(headers, body, view);
+  const filtered = applied.rows.length !== applied.unfilteredRowCount;
+  return {
+    body: applied.rows,
+    ...filtered ? { unfilteredTotalRows: applied.unfilteredRowCount } : {},
+    ...issues.length > 0 ? { viewIssues: issues } : {}
+  };
+}
+function csvToTable(rows, opts) {
+  const width = rows.reduce((max, row) => Math.max(max, row.length), 0);
+  const pad = (row) => row.length === width ? row : [...row, ...Array(width - row.length).fill("")];
+  const headerRow = opts.headerRow !== false;
+  const headers = headerRow && rows.length > 0 ? pad(rows[0]) : Array.from({ length: width }, (_, i) => columnLetter(i));
+  const rawBody = (headerRow ? rows.slice(1) : rows).map(pad);
+  const { body, unfilteredTotalRows, viewIssues } = applyViewParams(headers, rawBody, opts);
+  return {
+    headers,
+    rows: body.slice(0, opts.maxRows),
+    totalRows: body.length,
+    totalCols: width,
+    ...unfilteredTotalRows !== void 0 ? { unfilteredTotalRows } : {},
+    ...viewIssues ? { viewIssues } : {}
+  };
+}
+var csvDataReader = {
+  extensions: ["csv", "tsv"],
+  async read(data, opts) {
+    const text = new TextDecoder().decode(data);
+    const firstLine = text.slice(0, text.indexOf("\n") + 1 || text.length);
+    const delimiter = firstLine.includes("	") && !firstLine.includes(",") ? "	" : ",";
+    return csvToTable(parseCsv(text, delimiter, SIDECAR_CSV_LIMITS), opts);
+  }
+};
+function tableRect(table) {
+  const ref = parseCellRef(table.anchor);
+  if (!ref) return null;
+  const height = table.rows.length + (table.hasHeader ? 1 : 0);
+  return {
+    top: ref.row,
+    left: ref.col,
+    bottom: ref.row + Math.max(height - 1, 0),
+    right: ref.col + Math.max(table.columns.length - 1, 0)
+  };
+}
+function pickTable(tables, anchor) {
+  if (tables.length === 0) return null;
+  if (anchor) {
+    const exact = tables.find((t) => t.anchor.toUpperCase() === anchor.toUpperCase());
+    if (exact) return exact;
+    const target = parseCellRef(anchor);
+    if (target) {
+      const containing = tables.find((t) => {
+        const rect = tableRect(t);
+        return !!rect && target.row >= rect.top && target.row <= rect.bottom && target.col >= rect.left && target.col <= rect.right;
+      });
+      if (containing) return containing;
+    }
+  }
+  return tables.reduce(
+    (best, t) => t.rows.length * t.columns.length > best.rows.length * best.columns.length ? t : best
+  );
+}
+function stringifyCell(value) {
+  if (value === null) return "";
+  if (typeof value === "string") return value;
+  return String(value);
+}
+var xlsxDataReader = {
+  extensions: ["xlsx"],
+  async read(data, opts) {
+    const tables = await xlsxToTables(data, {
+      ...opts.sheet !== void 0 ? { sheet: opts.sheet } : {}
+    });
+    if (opts.sheet !== void 0 && tables.length === 0) {
+      throw new Error(`worksheet "${opts.sheet}" not found or holds no tabular data`);
+    }
+    const table = pickTable(tables, opts.anchor);
+    if (!table) {
+      throw new Error("no tabular data found in workbook");
+    }
+    const ref = parseCellRef(table.anchor);
+    const demoteHeader = opts.headerRow === false && table.hasHeader;
+    const headers = demoteHeader ? table.columns.map((_, i) => columnLetter((ref?.col ?? 0) + i)) : table.columns.map((c) => c.name);
+    const rawBody = demoteHeader ? [table.columns.map((c) => c.name), ...table.rows.map((row) => row.map(stringifyCell))] : table.rows.map((row) => row.map(stringifyCell));
+    const { body, unfilteredTotalRows, viewIssues } = applyViewParams(headers, rawBody, opts);
+    return {
+      headers,
+      rows: body.slice(0, opts.maxRows),
+      totalRows: body.length,
+      totalCols: table.columns.length,
+      ...unfilteredTotalRows !== void 0 ? { unfilteredTotalRows } : {},
+      ...viewIssues ? { viewIssues } : {}
+    };
+  }
+};
+var parquetDataReader = {
+  extensions: ["parquet"],
+  async read(data, opts) {
+    let hyparquet;
+    try {
+      hyparquet = await import("hyparquet");
+    } catch {
+      throw new Error('parquet support is not installed (missing optional dependency "hyparquet")');
+    }
+    const buffer = data instanceof ArrayBuffer ? data : new Uint8Array(data).slice().buffer;
+    const metadata = hyparquet.parquetMetadata(buffer);
+    const totalRows = Number(metadata.num_rows);
+    const columnNames = hyparquet.parquetSchema(metadata).children.map((c) => c.element.name);
+    const hasView = Boolean(opts.sort || opts.filter);
+    const rows = [];
+    await hyparquet.parquetRead({
+      file: buffer,
+      metadata,
+      rowStart: 0,
+      rowEnd: hasView ? totalRows : Math.min(opts.maxRows, totalRows),
+      onComplete(read) {
+        for (const row of read) {
+          rows.push(row.map((cell) => cell === null || cell === void 0 ? "" : String(cell)));
+        }
+      }
+    });
+    const { body, unfilteredTotalRows, viewIssues } = applyViewParams(columnNames, rows, opts);
+    return {
+      headers: columnNames,
+      rows: body.slice(0, opts.maxRows),
+      totalRows: hasView ? body.length : totalRows,
+      totalCols: columnNames.length,
+      ...unfilteredTotalRows !== void 0 ? { unfilteredTotalRows } : {},
+      ...viewIssues ? { viewIssues } : {}
+    };
+  }
+};
+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
+};

package/dist/{chunk-5JQ5NDRC.js → chunk-JPU5GPGG.js}

@@ -85,6 +85,9 @@ function assertDocWithinConversionLimits(doc, limits, signal) {
   }
 }
 
+// src/registry/defaultFormats.ts
+import { isDataFilePath } from "@bendyline/squisq/doc";
+
 // src/shared/fidelity.ts
 var CONTENT_NODE_TYPES = {
   heading: true,
@@ -221,24 +224,44 @@ async function markdownOf(input) {
   const { docToMarkdown } = await import("@bendyline/squisq/doc");
   return docToMarkdown(input.doc);
 }
-async function collectContainerImages(container, signal) {
-  const images = /* @__PURE__ */ new Map();
+var IMAGE_ASSET_RE = /\.(jpg|jpeg|png|gif|webp|svg|bmp|avif)$/i;
+var DATA_ASSET_RE = /\.(csv|tsv|xlsx|parquet)$/i;
+async function collectContainerAssets(container, pattern, signal, flattenBasenames = true) {
+  const assets = /* @__PURE__ */ new Map();
   const files = await container.listFiles();
   for (let index = 0; index < files.length; index++) {
     if ((index & 63) === 0) signal?.throwIfAborted();
     const file = files[index];
-    if (!/\.(jpg|jpeg|png|gif|webp|svg|bmp|avif)$/i.test(file.path)) continue;
+    if (!pattern.test(file.path)) continue;
     const data = await container.readFile(file.path);
     if (!data) continue;
-    images.set(file.path, data);
+    assets.set(file.path, data);
+    if (!flattenBasenames) continue;
     const slash = file.path.lastIndexOf("/");
-    if (slash !== -1) images.set(file.path.slice(slash + 1), data);
+    if (slash !== -1) assets.set(file.path.slice(slash + 1), data);
   }
-  return images;
+  return assets;
+}
+async function collectContainerImages(container, signal) {
+  return collectContainerAssets(container, IMAGE_ASSET_RE, signal);
+}
+function dataReferenceWarnings(doc, formatLabel) {
+  const srcs = /* @__PURE__ */ new Set();
+  const visit = (blocks) => {
+    for (const block of blocks) {
+      const src = block.templateOverrides?.src;
+      if (src && isDataFilePath(src)) srcs.add(src);
+      if (block.children) visit(block.children);
+    }
+  };
+  visit(doc.blocks);
+  return [...srcs].map(
+    (src) => `${formatLabel} cannot embed the data sidecar "${src}"; the export carries its bounded preview and the link will not resolve outside the source container.`
+  );
 }
 async function collectContainerDocxImages(container, signal) {
   const images = await collectContainerImages(container, signal);
-  const { extToMime } = await import("./images-ESPQKVTW.js");
+  const { extToMime } = await import("./images-JLBFCDD4.js");
   return new Map(
     [...images].map(([path, data]) => [
       path,
@@ -418,17 +441,29 @@ function defaultFormats() {
     label: "Excel (XLSX)",
     mimeType: MIME.xlsx,
     extensions: [".xlsx"],
+    async importContainer(data, options) {
+      const { xlsxToContainer } = await import("./xlsx/index.js");
+      return xlsxToContainer(data, optionsFor(options, "xlsx"));
+    },
     async importDoc(data, options) {
       const { xlsxToMarkdownDoc } = await import("./xlsx/index.js");
       return xlsxToMarkdownDoc(data, optionsFor(options, "xlsx"));
     },
     async exportDoc(input, options) {
       const { markdownDocToXlsx } = await import("./xlsx/index.js");
-      const markdownDoc = await markdownOf(input);
+      const { materializeDataReferences } = await import("./materialize-A34OZGEU.js");
+      const warnings = [];
+      const markdownDoc = await materializeDataReferences(
+        await markdownOf(input),
+        input.container,
+        (message) => warnings.push(message)
+      );
       const omitted = markdownDoc.children.filter(
         (n) => n.type !== "table" && n.type !== "heading"
       ).length;
-      const warnings = omitted > 0 ? [`XLSX export is tables-only; ${omitted} non-table block(s) were omitted.`] : [];
+      if (omitted > 0) {
+        warnings.push(`XLSX export is tables-only; ${omitted} non-table block(s) were omitted.`);
+      }
       const blob = await markdownDocToXlsx(markdownDoc, {
         ...optionsFor(options, "xlsx"),
         ...options.title !== void 0 ? { title: options.title } : {},
@@ -445,6 +480,10 @@ function defaultFormats() {
     label: "CSV",
     mimeType: MIME.csv,
     extensions: [".csv"],
+    async importContainer(data, options) {
+      const { csvToContainer } = await import("./csv/index.js");
+      return csvToContainer(data, optionsFor(options, "csv"));
+    },
     async importDoc(data, options) {
       const { csvToMarkdownDoc } = await import("./csv/index.js");
       return csvToMarkdownDoc(data, optionsFor(options, "csv"));
@@ -503,7 +542,11 @@ function defaultFormats() {
         themeId: resolveThemeId(input, options),
         themeRegistry: options.themeRegistry ?? raw.themeRegistry
       });
-      return ok(new TextEncoder().encode(htmlText), MIME.html);
+      return ok(
+        new TextEncoder().encode(htmlText),
+        MIME.html,
+        dataReferenceWarnings(input.doc, "Single-file HTML")
+      );
     }
   };
   const htmlzip = {
@@ -517,7 +560,13 @@ function defaultFormats() {
       const { docToHtmlZip } = await import("./html/index.js");
       const raw = optionsFor(options, "htmlzip");
       const containerImages = await collectContainerImages(input.container, options.signal);
-      const images = new Map([...containerImages, ...raw.images ?? /* @__PURE__ */ new Map()]);
+      const containerData = await collectContainerAssets(
+        input.container,
+        DATA_ASSET_RE,
+        options.signal,
+        false
+      );
+      const images = new Map([...containerImages, ...containerData, ...raw.images ?? /* @__PURE__ */ new Map()]);
       const blob = await docToHtmlZip(input.doc, {
         ...raw,
         playerScript,
@@ -549,7 +598,10 @@ function defaultFormats() {
         themeRegistry: options.themeRegistry ?? raw.themeRegistry,
         images
       });
-      return ok(await toBytes(buf), MIME.epub, markdownFidelityWarnings(markdownDoc, "epub"));
+      return ok(await toBytes(buf), MIME.epub, [
+        ...markdownFidelityWarnings(markdownDoc, "epub"),
+        ...dataReferenceWarnings(input.doc, "EPUB")
+      ]);
     }
   };
   const dbk = {