@noy-db/as-xlsx 0.2.0-pre.3 → 0.2.0-pre.31

package/dist/index.js

@@ -2,7 +2,19 @@
 import { writeZip } from "@noy-db/as-zip";
 var XML_HEADER = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
 var ENCODER = new TextEncoder();
-async function writeXlsx(sheets) {
+function formula(f, cachedValue) {
+  return cachedValue === void 0 ? { __xlsxFormula: f } : { __xlsxFormula: f, v: cachedValue };
+}
+function isFormulaCell(v) {
+  return typeof v === "object" && v !== null && typeof v.__xlsxFormula === "string";
+}
+function styled(value, numberFormat) {
+  return { __xlsxStyle: numberFormat, v: value };
+}
+function isStyledCell(v) {
+  return typeof v === "object" && v !== null && typeof v.__xlsxStyle === "string";
+}
+async function writeXlsx(sheets, options = {}) {
   if (sheets.length === 0) {
     throw new Error("writeXlsx: at least one sheet is required");
   }
@@ -27,6 +39,16 @@ async function writeXlsx(sheets) {
     stringIndex.set(s, idx);
     return idx;
   };
+  const numFmtCodes = [];
+  const styleIndexByCode = /* @__PURE__ */ new Map();
+  const internStyle = (code) => {
+    const existing = styleIndexByCode.get(code);
+    if (existing !== void 0) return existing;
+    const idx = numFmtCodes.length + 1;
+    numFmtCodes.push(code);
+    styleIndexByCode.set(code, idx);
+    return idx;
+  };
   const sheetXmls = safeSheets.map((sheet) => {
     const lines = [
       XML_HEADER,
@@ -56,12 +78,42 @@ async function writeXlsx(sheets) {
     }
     for (const row of sheet.rows) {
       rowNum++;
-      const cells = row.map((value, i) => cellXml(value, i + 1, rowNum, internString)).join("");
+      const cells = row.map((value, i) => cellXml(value, i + 1, rowNum, internString, internStyle)).join("");
       lines.push(`<row r="${rowNum}">${cells}</row>`);
     }
-    lines.push("</sheetData>", "</worksheet>");
+    lines.push("</sheetData>");
+    if (sheet.validations && sheet.validations.length > 0) {
+      lines.push(`<dataValidations count="${sheet.validations.length}">`);
+      for (const dv of sheet.validations) {
+        const f1 = dv.formula1 ?? `"${(dv.values ?? []).join(",")}"`;
+        lines.push(
+          `<dataValidation type="list" allowBlank="1" showInputMessage="1" showErrorMessage="1" sqref="${escapeXmlAttr(dv.sqref)}"><formula1>${escapeXmlText(f1)}</formula1></dataValidation>`
+        );
+      }
+      lines.push("</dataValidations>");
+    }
+    lines.push("</worksheet>");
     return lines.join("");
   });
+  const hasStyles = numFmtCodes.length > 0;
+  const stylesXml = hasStyles ? [
+    XML_HEADER,
+    '<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">',
+    `<numFmts count="${numFmtCodes.length}">`,
+    ...numFmtCodes.map((code, i) => `<numFmt numFmtId="${164 + i}" formatCode="${escapeXmlAttr(code)}"/>`),
+    "</numFmts>",
+    '<fonts count="1"><font><sz val="11"/><name val="Calibri"/></font></fonts>',
+    '<fills count="1"><fill><patternFill patternType="none"/></fill></fills>',
+    '<borders count="1"><border/></borders>',
+    '<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>',
+    `<cellXfs count="${numFmtCodes.length + 1}">`,
+    '<xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>',
+    ...numFmtCodes.map(
+      (_, i) => `<xf numFmtId="${164 + i}" fontId="0" fillId="0" borderId="0" xfId="0" applyNumberFormat="1"/>`
+    ),
+    "</cellXfs>",
+    "</styleSheet>"
+  ].join("") : "";
   const sheetEntries = safeSheets.map((s, i) => ({
     index: i + 1,
     id: `rId${i + 1}`,
@@ -78,6 +130,7 @@ async function writeXlsx(sheets) {
       (s) => `<Override PartName="/${s.path}" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`
     ),
     '<Override PartName="/xl/sharedStrings.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"/>',
+    ...hasStyles ? ['<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>'] : [],
     "</Types>"
   ].join("");
   const rootRels = XML_HEADER + '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/></Relationships>';
@@ -89,6 +142,13 @@ async function writeXlsx(sheets) {
       (s) => `<sheet name="${escapeXmlAttr(s.name)}" sheetId="${s.index}" r:id="${s.id}"/>`
     ),
     "</sheets>",
+    ...options.definedNames && options.definedNames.length > 0 ? [
+      "<definedNames>",
+      ...options.definedNames.map(
+        (d) => `<definedName name="${escapeXmlAttr(d.name)}">${escapeXmlText(d.ref)}</definedName>`
+      ),
+      "</definedNames>"
+    ] : [],
     "</workbook>"
   ].join("");
   const workbookRels = [
@@ -98,6 +158,7 @@ async function writeXlsx(sheets) {
       (s) => `<Relationship Id="${s.id}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet${s.index}.xml"/>`
     ),
     `<Relationship Id="rIdSharedStrings" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>`,
+    ...hasStyles ? [`<Relationship Id="rIdStyles" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>`] : [],
     "</Relationships>"
   ].join("");
   const sharedStringsXml = [
@@ -112,12 +173,28 @@ async function writeXlsx(sheets) {
     { path: "xl/workbook.xml", bytes: ENCODER.encode(workbookXml) },
     { path: "xl/_rels/workbook.xml.rels", bytes: ENCODER.encode(workbookRels) },
     { path: "xl/sharedStrings.xml", bytes: ENCODER.encode(sharedStringsXml) },
+    ...hasStyles ? [{ path: "xl/styles.xml", bytes: ENCODER.encode(stylesXml) }] : [],
     ...sheetEntries.map((s, i) => ({ path: s.path, bytes: ENCODER.encode(sheetXmls[i] ?? "") }))
   ];
   return await writeZip(entries);
 }
-function cellXml(value, colIdx, rowNum, intern) {
+function cellXml(value, colIdx, rowNum, intern, internStyle) {
   const ref = `${colLetter(colIdx)}${rowNum}`;
+  if (isStyledCell(value)) {
+    const s2 = internStyle(value.__xlsxStyle);
+    const v = value.v;
+    if (v === null || v === void 0 || v === "") return `<c r="${ref}" s="${s2}"/>`;
+    if (typeof v === "number" && Number.isFinite(v)) return `<c r="${ref}" s="${s2}"><v>${v}</v></c>`;
+    if (typeof v === "boolean") return `<c r="${ref}" s="${s2}" t="b"><v>${v ? 1 : 0}</v></c>`;
+    return `<c r="${ref}" s="${s2}" t="s"><v>${intern(typeof v === "string" ? v : String(v))}</v></c>`;
+  }
+  if (isFormulaCell(value)) {
+    const f = escapeXmlText(value.__xlsxFormula);
+    if (value.v === void 0) return `<c r="${ref}"><f>${f}</f></c>`;
+    if (typeof value.v === "number" && Number.isFinite(value.v)) return `<c r="${ref}"><f>${f}</f><v>${value.v}</v></c>`;
+    if (typeof value.v === "boolean") return `<c r="${ref}" t="b"><f>${f}</f><v>${value.v ? 1 : 0}</v></c>`;
+    return `<c r="${ref}" t="str"><f>${f}</f><v>${escapeXmlText(String(value.v))}</v></c>`;
+  }
   if (value === null || value === void 0 || value === "") return `<c r="${ref}"/>`;
   if (typeof value === "number" && Number.isFinite(value)) {
     return `<c r="${ref}"><v>${value}</v></c>`;
@@ -342,6 +419,92 @@ function stringAttr(raw) {
   return "";
 }
 
+// src/infer.ts
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2})?/;
+function inferType(vals) {
+  if (vals.length === 0) return "string";
+  if (vals.every((v) => typeof v === "boolean")) return "boolean";
+  if (vals.every((v) => typeof v === "number")) return "number";
+  if (vals.every((v) => typeof v === "string" && ISO_DATE.test(v))) return "date";
+  return "string";
+}
+async function inferSchema(bytes, options = {}) {
+  const skip = new Set(options.skipSheets ?? []);
+  const decoded = await readXlsx(bytes);
+  const sheets = [];
+  for (const sh of decoded.sheets) {
+    if (sh.name.startsWith("_") || skip.has(sh.name)) continue;
+    const headerRow = sh.rows[0] ?? {};
+    const colToField = /* @__PURE__ */ new Map();
+    const fields = [];
+    for (const [letter, val] of Object.entries(headerRow)) {
+      const name = typeof val === "string" ? val.trim() : typeof val === "number" || typeof val === "boolean" ? String(val) : "";
+      if (!name) continue;
+      colToField.set(letter, name);
+      fields.push(name);
+    }
+    const records = sh.rows.slice(1).map((row) => {
+      const rec = {};
+      for (const [letter, val] of Object.entries(row)) {
+        const f = colToField.get(letter);
+        if (f !== void 0) rec[f] = val;
+      }
+      return rec;
+    });
+    sheets.push({ name: sh.name, fields, records });
+  }
+  const valuesOf = (s, f) => s.records.map((r) => r[f]).filter((v) => v != null && v !== "");
+  const idFieldOf = (s) => {
+    if (s.fields.includes("id")) return "id";
+    for (const f of s.fields) {
+      const vals = valuesOf(s, f);
+      if (vals.length > 0 && new Set(vals.map((v) => String(v))).size === vals.length) return f;
+    }
+    return s.fields[0] ?? "id";
+  };
+  const meta = sheets.map((s) => ({ s, idField: idFieldOf(s) }));
+  const idValuesByName = /* @__PURE__ */ new Map();
+  for (const { s, idField } of meta) {
+    idValuesByName.set(s.name, new Set(valuesOf(s, idField).map((v) => String(v))));
+  }
+  const collections = {};
+  for (const { s, idField } of meta) {
+    const fields = {};
+    for (const f of s.fields) {
+      const vals = valuesOf(s, f);
+      const type = inferType(vals);
+      let references;
+      if (f !== idField && type === "string" && vals.length > 0) {
+        const distinct = new Set(vals.map((v) => String(v)));
+        for (const { s: other } of meta) {
+          if (other.name === s.name) continue;
+          const ids = idValuesByName.get(other.name);
+          if (ids && ids.size > 0 && [...distinct].every((v) => ids.has(v))) {
+            references = other.name;
+            break;
+          }
+        }
+      }
+      fields[f] = references ? { type, references } : { type };
+    }
+    collections[s.name] = { idField, fields };
+  }
+  return { collections };
+}
+function zodSourceFor(schema) {
+  const zType = (t) => t === "number" ? "z.number()" : t === "boolean" ? "z.boolean()" : t === "date" ? "z.string().datetime()" : "z.string()";
+  const blocks = [`import { z } from 'zod'`];
+  for (const [name, c] of Object.entries(schema.collections)) {
+    const lines = Object.entries(c.fields).map(
+      ([f, d]) => `  ${f}: ${zType(d.type)},${d.references ? ` // \u2192 ${d.references}` : ""}`
+    );
+    blocks.push(`export const ${name}Schema = z.object({
+${lines.join("\n")}
+})`);
+  }
+  return blocks.join("\n\n");
+}
+
 // src/index.ts
 import { diffVault } from "@noy-db/hub";
 async function toBytesFromCollection(vault, collectionName) {
@@ -354,6 +517,10 @@ async function toBytes(vault, options) {
   if (options.sheets.length === 0) {
     throw new Error("as-xlsx: at least one sheet is required");
   }
+  if (options.smart) {
+    const { sheets, definedNames } = await buildSmartSheets(vault, options);
+    return writeXlsx(sheets, { definedNames });
+  }
   const materialisedSheets = [];
   for (const sheetOpt of options.sheets) {
     const collection = vault.collection(sheetOpt.collection);
@@ -397,6 +564,339 @@ async function write(vault, path, options) {
   const { writeFile } = await import("fs/promises");
   await writeFile(path, bytes);
 }
+async function toBytesMultiVault(entries, options = {}) {
+  const sep = options.sheetSeparator ?? "_";
+  for (const entry of entries) {
+    entry.vault.assertCanExport("plaintext", "xlsx");
+  }
+  const loaded = [];
+  const denormIndex = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const prefix = entry.label ?? entry.vault.name;
+    for (const s of entry.sheets) {
+      const all = await entry.vault.collection(s.collection).list();
+      const records = [];
+      for (const item of all) {
+        const r = item;
+        const allow = entry.closure?.get(s.collection);
+        if (allow && !allow.has(String(r.id))) continue;
+        if (s.filter && !s.filter(r)) continue;
+        records.push(r);
+      }
+      loaded.push({ entry, prefix, sheetOpt: s, records });
+      const indexKey = `${prefix}/${s.collection}`;
+      const collectionIndex = denormIndex.get(indexKey) ?? /* @__PURE__ */ new Map();
+      denormIndex.set(indexKey, collectionIndex);
+      for (const r of records) {
+        const idVal = r.id;
+        if (idVal != null) collectionIndex.set(safeStringify(idVal), r);
+      }
+    }
+  }
+  for (const ls of loaded) {
+    for (const d of ls.sheetOpt.denormalize ?? []) {
+      if (d.from.keyField === "id") continue;
+      const indexKey = `${d.from.label}/${d.from.collection}`;
+      const idx = denormIndex.get(indexKey);
+      if (!idx) continue;
+      const srcLoaded = loaded.find(
+        (l) => l.prefix === d.from.label && l.sheetOpt.collection === d.from.collection
+      );
+      if (!srcLoaded) continue;
+      for (const r of srcLoaded.records) {
+        const kv = r[d.from.keyField];
+        if (kv != null) idx.set(safeStringify(kv), r);
+      }
+    }
+  }
+  const allSheets = [];
+  const manifestRows = [];
+  for (const { prefix, sheetOpt: s, records } of loaded) {
+    const baseColumns = s.columns ?? inferColumns(records);
+    const denormDefs = s.denormalize ?? [];
+    if (denormDefs.length === 0) {
+      const sheetName2 = `${prefix}${sep}${s.name}`;
+      allSheets.push(buildFlatSheet(sheetName2, baseColumns, records));
+      manifestRows.push([prefix, s.collection, records.length]);
+      continue;
+    }
+    const allColumns = [...baseColumns, ...denormDefs.map((d) => d.column)];
+    const sheetName = `${prefix}${sep}${s.name}`;
+    const rows = records.map((r) => {
+      const baseCells = baseColumns.map((c) => r[c] ?? null);
+      const denormCells = denormDefs.map((d) => {
+        const idxKey = `${d.from.label}/${d.from.collection}`;
+        const idx = denormIndex.get(idxKey);
+        if (!idx) return "";
+        const fkVal = r[d.localField];
+        if (fkVal == null) return "";
+        const supporting = idx.get(safeStringify(fkVal));
+        if (!supporting) return "";
+        return supporting[d.from.pick] ?? "";
+      });
+      return [...baseCells, ...denormCells];
+    });
+    allSheets.push({ name: sheetName, header: allColumns, rows });
+    manifestRows.push([prefix, s.collection, records.length]);
+  }
+  allSheets.unshift({
+    name: "_manifest",
+    header: ["Vault", "Collection", "Records"],
+    rows: manifestRows
+  });
+  return writeXlsx(allSheets);
+}
+function buildFlatSheet(name, columns, records) {
+  return {
+    name,
+    header: [...columns],
+    rows: records.map((r) => columns.map((c) => r[c] ?? null))
+  };
+}
+function safeStringify(v) {
+  if (typeof v === "string") return v;
+  if (typeof v === "number" || typeof v === "boolean" || typeof v === "bigint") return String(v);
+  if (v == null) return "";
+  try {
+    return JSON.stringify(v) ?? "";
+  } catch {
+    return "";
+  }
+}
+function asCached(v) {
+  if (typeof v === "number" || typeof v === "boolean" || typeof v === "string") return v;
+  return safeStringify(v);
+}
+async function buildSmartSheets(vault, options) {
+  const snapshot = await vault.dumpSchema();
+  const sheetNameByCollection = /* @__PURE__ */ new Map();
+  for (const s of options.sheets) sheetNameByCollection.set(s.collection, s.name);
+  const mats = [];
+  const localeSet = /* @__PURE__ */ new Set();
+  for (const sheetOpt of options.sheets) {
+    const collection = vault.collection(sheetOpt.collection);
+    const list = await collection.list();
+    const records = [];
+    for (const item of list) {
+      const r = item;
+      if (sheetOpt.filter && !sheetOpt.filter(r)) continue;
+      records.push(r);
+    }
+    const base = sheetOpt.columns ?? inferColumns(records);
+    const cols = ["id", ...base.filter((c) => c !== "id")];
+    const labelCol = cols.find((c) => c !== "id");
+    const labelMap = /* @__PURE__ */ new Map();
+    if (labelCol) {
+      for (const r of records) if (r.id != null) labelMap.set(safeStringify(r.id), r[labelCol]);
+    }
+    const i18nFields = (sheetOpt.i18nFields ?? []).filter((f) => cols.includes(f));
+    for (const f of i18nFields) {
+      for (const r of records) {
+        const v = r[f];
+        if (v && typeof v === "object") for (const loc of Object.keys(v)) localeSet.add(loc);
+      }
+    }
+    mats.push({ opt: sheetOpt, records, cols, labelMap, i18nFields });
+  }
+  const matByCollection = new Map(mats.map((m) => [m.opt.collection, m]));
+  const dictEntries = /* @__PURE__ */ new Map();
+  for (const m of mats) {
+    for (const [field, dictName] of Object.entries(m.opt.dictFields ?? {})) {
+      if (!m.cols.includes(field) || dictEntries.has(dictName)) continue;
+      dictEntries.set(dictName, await vault.dictionary(dictName).list());
+    }
+  }
+  for (const entries of dictEntries.values()) {
+    for (const e of entries) for (const loc of Object.keys(e.labels)) localeSet.add(loc);
+  }
+  const locales = [...localeSet].sort();
+  const hasLang = locales.length > 0;
+  const defaultLocale = locales.includes("en") ? "en" : locales[0] ?? "en";
+  const ifChain = (refOf) => {
+    if (locales.length === 0) return '""';
+    let expr = refOf(locales[0]);
+    for (let k = locales.length - 1; k >= 0; k--) {
+      expr = `IF(LANG="${locales[k]}",${refOf(locales[k])},${expr})`;
+    }
+    return expr;
+  };
+  const sheetMeta = /* @__PURE__ */ new Map();
+  const dataSheets = mats.map((m) => {
+    const refs = snapshot.collections[m.opt.collection]?.refs ?? {};
+    const fields = snapshot.collections[m.opt.collection]?.fields ?? {};
+    const i18nSet = new Set(m.i18nFields);
+    const refFields = Object.keys(refs).filter((f) => m.cols.includes(f) && matByCollection.has(refs[f].target));
+    const baseCols = m.cols.filter((c) => !i18nSet.has(c));
+    const i18nFlat = m.i18nFields.flatMap((f) => [f, ...locales.map((l) => `${f}__${l}`)]);
+    const dictPairs = Object.entries(m.opt.dictFields ?? {}).filter(([f]) => m.cols.includes(f));
+    const header = [
+      ...baseCols,
+      ...i18nFlat,
+      ...dictPairs.map(([f]) => `${f}__label`),
+      ...refFields.map((f) => `${f}__label`)
+    ];
+    const colIndex = /* @__PURE__ */ new Map();
+    header.forEach((h, i) => colIndex.set(h, i + 1));
+    sheetMeta.set(m.opt.collection, { name: m.opt.name, colIndex });
+    const lastRow = Math.max(m.records.length + 1, 2);
+    const validations = [];
+    for (const field of baseCols) {
+      const colL = colLetter(colIndex.get(field));
+      const sqref = `${colL}2:${colL}${lastRow}`;
+      const explicit = m.opt.dropdowns?.[field];
+      if (explicit && explicit.length > 0) {
+        validations.push({ sqref, values: explicit });
+        continue;
+      }
+      const rf = refs[field];
+      if (rf && matByCollection.has(rf.target)) {
+        const targetSheet = sheetNameByCollection.get(rf.target);
+        const targetRows = Math.max(matByCollection.get(rf.target).records.length + 1, 2);
+        validations.push({ sqref, formula1: `'${targetSheet}'!$A$2:$A$${targetRows}` });
+        continue;
+      }
+      const enumVals = fields[field]?.constraints?.["values"];
+      if (Array.isArray(enumVals) && enumVals.length > 0) validations.push({ sqref, values: enumVals.map((v) => safeStringify(v)) });
+    }
+    const rows = m.records.map((r, i) => {
+      const rowNum = i + 2;
+      const baseCells = baseCols.map((c) => {
+        const raw = c === "id" ? r.id ?? null : r[c] ?? null;
+        const fmt = m.opt.numberFormats?.[c];
+        if (fmt === void 0) return raw;
+        const num = typeof raw === "string" && raw.trim() !== "" && Number.isFinite(Number(raw)) ? Number(raw) : raw;
+        return styled(num, fmt);
+      });
+      const i18nCells = m.i18nFields.flatMap((f) => {
+        const rawMap = r[f] && typeof r[f] === "object" ? r[f] : {};
+        const display = formula(
+          ifChain((l) => `${colLetter(colIndex.get(`${f}__${l}`))}${rowNum}`),
+          asCached(rawMap[defaultLocale] ?? "")
+        );
+        return [display, ...locales.map((l) => rawMap[l] ?? null)];
+      });
+      const dictCells = dictPairs.map(([f, dn]) => {
+        const codeRef = `${colLetter(colIndex.get(f))}${rowNum}`;
+        const lk = `_Lookups_${dn}`;
+        const f1 = `IFERROR(VLOOKUP(${codeRef},'${lk}'!$A:$ZZ,MATCH(LANG,'${lk}'!$1:$1,0),FALSE),${codeRef})`;
+        const code = r[f];
+        const entry = code == null ? void 0 : dictEntries.get(dn)?.find((e) => e.key === safeStringify(code));
+        return formula(f1, asCached(entry?.labels[defaultLocale] ?? (code ?? "")));
+      });
+      const refCells = refFields.map((f) => {
+        const target = refs[f].target;
+        const targetSheet = sheetNameByCollection.get(target);
+        const targetMat = matByCollection.get(target);
+        const codeRef = `${colLetter(colIndex.get(f))}${rowNum}`;
+        const f1 = `IFERROR(VLOOKUP(${codeRef},'${targetSheet}'!$A:$ZZ,2,FALSE),"")`;
+        const code = r[f];
+        const cached = code == null ? "" : asCached(targetMat.labelMap.get(safeStringify(code)));
+        return formula(f1, cached);
+      });
+      return [...baseCells, ...i18nCells, ...dictCells, ...refCells];
+    });
+    return {
+      name: m.opt.name,
+      header,
+      rows,
+      ...validations.length > 0 ? { validations } : {},
+      ...m.opt.widths !== void 0 ? { widths: m.opt.widths } : {}
+    };
+  });
+  const manifest = {
+    name: "_manifest",
+    header: ["Collection", "Records", "Refs"],
+    rows: mats.map((m) => {
+      const refs = snapshot.collections[m.opt.collection]?.refs ?? {};
+      return [m.opt.name, m.records.length, Object.entries(refs).map(([f, r]) => `${f}\u2192${r.target}`).join(", ")];
+    })
+  };
+  const dialect = options.dialect ?? "excel";
+  const summarySheets = [];
+  for (const spec of options.summaries ?? []) {
+    const src = sheetMeta.get(spec.from);
+    const srcMat = matByCollection.get(spec.from);
+    const gCol = src?.colIndex.get(spec.groupBy);
+    if (!src || !srcMat || gCol === void 0) continue;
+    const gLetter = colLetter(gCol);
+    if (dialect === "sheets") {
+      const selects = [];
+      const labels = [];
+      for (const a of spec.aggregates) {
+        if (a.op === "count") {
+          selects.push(`COUNT(${gLetter})`);
+          labels.push(`COUNT(${gLetter}) '${a.label}'`);
+          continue;
+        }
+        const vIdx = a.field ? src.colIndex.get(a.field) : void 0;
+        if (vIdx === void 0) continue;
+        const vL = colLetter(vIdx);
+        const fn = a.op === "sum" ? "SUM" : "AVG";
+        selects.push(`${fn}(${vL})`);
+        labels.push(`${fn}(${vL}) '${a.label}'`);
+      }
+      const q = `QUERY('${src.name}'!A:ZZ, "SELECT ${gLetter}, ${selects.join(", ")} GROUP BY ${gLetter} LABEL ${labels.join(", ")}", 1)`;
+      summarySheets.push({ name: spec.name, rows: [[formula(q)]] });
+      continue;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const groups = [];
+    for (const r of srcMat.records) {
+      const k = safeStringify(r[spec.groupBy]);
+      if (!seen.has(k)) {
+        seen.add(k);
+        groups.push(r[spec.groupBy]);
+      }
+    }
+    const header = [spec.groupBy, ...spec.aggregates.map((a) => a.label)];
+    const rows = groups.map((g, i) => {
+      const rowNum = i + 2;
+      const groupRecs = srcMat.records.filter((r) => safeStringify(r[spec.groupBy]) === safeStringify(g));
+      const cells = [g];
+      for (const a of spec.aggregates) {
+        if (a.op === "count") {
+          cells.push(formula(`COUNTIFS('${src.name}'!$${gLetter}:$${gLetter},$A${rowNum})`, groupRecs.length));
+          continue;
+        }
+        const vIdx = a.field ? src.colIndex.get(a.field) : void 0;
+        if (vIdx === void 0) {
+          cells.push(null);
+          continue;
+        }
+        const vLetter = colLetter(vIdx);
+        const nums = groupRecs.map((r) => Number(r[a.field])).filter((n) => Number.isFinite(n));
+        const sum = nums.reduce((s, n) => s + n, 0);
+        const cached = a.op === "sum" ? sum : nums.length ? sum / nums.length : 0;
+        const fn = a.op === "sum" ? "SUMIFS" : "AVERAGEIFS";
+        cells.push(
+          formula(`${fn}('${src.name}'!$${vLetter}:$${vLetter},'${src.name}'!$${gLetter}:$${gLetter},$A${rowNum})`, cached)
+        );
+      }
+      return cells;
+    });
+    summarySheets.push({ name: spec.name, header, rows });
+  }
+  const lookupSheets = [...dictEntries.entries()].map(([dn, entries]) => ({
+    name: `_Lookups_${dn}`,
+    header: ["Code", ...locales],
+    rows: entries.map((e) => [e.key, ...locales.map((l) => e.labels[l] ?? "")])
+  }));
+  const settingsSheets = [];
+  const definedNames = [];
+  if (hasLang) {
+    settingsSheets.push({
+      name: "_settings",
+      header: ["Setting", "Value"],
+      rows: [["Language", defaultLocale]],
+      validations: [{ sqref: "B2:B2", values: locales }]
+    });
+    definedNames.push({ name: "LANG", ref: `'_settings'!$B$2` });
+  }
+  return {
+    sheets: [...settingsSheets, ...lookupSheets, manifest, ...summarySheets, ...dataSheets],
+    definedNames
+  };
+}
 function inferColumns(records) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
@@ -468,6 +968,13 @@ async function fromBytes(vault, bytes, options) {
     } catch {
     }
   }
+  const i18nBases = /* @__PURE__ */ new Set();
+  if (options.smart) {
+    for (const field of colToField.values()) {
+      const m = /^(.+)__(.+)$/.exec(field);
+      if (m && m[2] !== "label") i18nBases.add(m[1]);
+    }
+  }
   const records = [];
   for (let i = headerRowIdx + 1; i < allRows.length; i++) {
     const row = allRows[i];
@@ -476,6 +983,22 @@ async function fromBytes(vault, bytes, options) {
     for (const [col, value] of Object.entries(row)) {
       const field = colToField.get(col);
       if (field === void 0) continue;
+      if (options.smart) {
+        if (field.endsWith("__label")) continue;
+        const lm = /^(.+)__(.+)$/.exec(field);
+        if (lm && lm[2] !== "label" && i18nBases.has(lm[1])) {
+          const base = lm[1];
+          const coerced2 = coerceXlsxCell(value, types[base]);
+          if (coerced2 !== void 0 && coerced2 !== "") {
+            const map = record[base] ?? {};
+            map[lm[2]] = coerced2;
+            record[base] = map;
+            hasAny = true;
+          }
+          continue;
+        }
+        if (i18nBases.has(field)) continue;
+      }
       const coerced = coerceXlsxCell(value, types[field]);
       if (coerced !== void 0) {
         const invMap = invertMaps.get(field);
@@ -582,11 +1105,16 @@ export {
   XlsxDictAmbiguityError,
   colLetter,
   download,
+  formula,
   fromBytes,
+  inferSchema,
   readXlsx,
+  styled,
   toBytes,
   toBytesFromCollection,
+  toBytesMultiVault,
   write,
-  writeXlsx
+  writeXlsx,
+  zodSourceFor
 };
 //# sourceMappingURL=index.js.map