@noy-db/as-xlsx 0.2.0-pre.2 → 0.2.0-pre.21

package/dist/index.cjs

@@ -33,8 +33,10 @@ __export(index_exports, {
   XlsxDictAmbiguityError: () => XlsxDictAmbiguityError,
   colLetter: () => colLetter,
   download: () => download,
+  formula: () => formula,
   fromBytes: () => fromBytes,
   readXlsx: () => readXlsx,
+  styled: () => styled,
   toBytes: () => toBytes,
   toBytesFromCollection: () => toBytesFromCollection,
   write: () => write,
@@ -46,7 +48,19 @@ module.exports = __toCommonJS(index_exports);
 var import_as_zip = require("@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");
   }
@@ -71,6 +85,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,
@@ -100,12 +124,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}`,
@@ -122,6 +176,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>';
@@ -133,6 +188,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 = [
@@ -142,6 +204,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 = [
@@ -156,12 +219,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 (0, import_as_zip.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>`;
@@ -398,6 +477,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);
@@ -441,6 +524,229 @@ async function write(vault, path, options) {
   const { writeFile } = await import("fs/promises");
   await writeFile(path, bytes);
 }
+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 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);
+    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 = [];
@@ -627,8 +933,10 @@ function excelSerialToMs(serial) {
   XlsxDictAmbiguityError,
   colLetter,
   download,
+  formula,
   fromBytes,
   readXlsx,
+  styled,
   toBytes,
   toBytesFromCollection,
   write,