@openjsxl/core 0.2.1 → 0.3.0

package/README.md

@@ -5,8 +5,9 @@
 [![license: MIT](https://img.shields.io/npm/l/@openjsxl/core?color=blue)](./LICENSE)
 
 The zero-dependency OOXML engine behind [`openjsxl`](https://www.npmjs.com/package/openjsxl):
-the `zip → xml → ooxml → reader` layers that turn an `.xlsx` into typed cells, built only on
-platform Web APIs (`DecompressionStream`, `TextDecoder`, …). No runtime dependencies.
+the `zip → xml → ooxml → reader` layers that turn an `.xlsx` into typed cells — and the mirror
+`writer` layer that turns plain data back into `.xlsx` bytes. Built only on platform Web APIs
+(`DecompressionStream`, `CompressionStream`, `TextDecoder`, …). No runtime dependencies.
 
 **Most users should install [`openjsxl`](https://www.npmjs.com/package/openjsxl) instead** — it
 re-exports everything here and is the stable public surface. Install `@openjsxl/core` directly
@@ -39,9 +40,30 @@ Malformed input throws a typed `XlsxError` with a discriminating `.code`
 (`'not-a-zip' | 'not-xlsx' | 'missing-part' | 'corrupt-zip' | 'part-too-large' | …`), never a
 bare `TypeError` from a corrupt file.
 
+## Writing
+
+```ts
+import { writeXlsx, workbookToInput } from '@openjsxl/core'
+
+// Author from plain data — cell types inferred from the JS values.
+const bytes = await writeXlsx({
+	sheets: [{ name: 'Report', rows: [['Item', 'Added'], ['Apples', new Date('2024-01-15')]] }],
+})
+
+// Or read → modify → write.
+const input = await workbookToInput(await openXlsx(bytes))
+input.sheets[0].rows.push(['Pears', new Date('2024-02-01')])
+const updated = await writeXlsx(input)
+```
+
+Output is deterministic; unrepresentable input (no sheets, bad/duplicate sheet name, non-finite
+number, invalid `Date`, XML-illegal characters) throws `XlsxError` with `code: 'invalid-input'`.
+The round trip is lossless for values, types, and sheet names/order.
+
 ## Exports
 
 - **Reader:** `openXlsx`, `streamSheetRows`, `Workbook`, `Worksheet`, `ReadOptions`
+- **Writer:** `writeXlsx`, `workbookToInput`, `WorkbookInput`, `SheetInput`, `CellValue`, `WriteOptions`
 - **Errors:** `XlsxError`, `XlsxErrorCode`
 - **Types:** `Row`, `Cell`, `CellType`, `Comment`, `Hyperlink`, `SheetInfo`, `CellRef`
 - **A1 & dates:** `columnToIndex`, `indexToColumn`, `parseRef`, `formatRef`, `serialToDate`

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-type XlsxErrorCode = 'not-a-zip' | 'not-xlsx' | 'missing-part' | 'corrupt-zip' | 'unsupported' | 'no-such-sheet' | 'part-too-large';
+type XlsxErrorCode = 'not-a-zip' | 'not-xlsx' | 'missing-part' | 'corrupt-zip' | 'unsupported' | 'no-such-sheet' | 'part-too-large' | 'invalid-input';
 declare class XlsxError extends Error {
     /** Machine-readable discriminant; branch on this rather than the message. */
     readonly code: XlsxErrorCode;
@@ -19,6 +19,7 @@ declare function parseRef(ref: string): CellRef;
 declare function formatRef(ref: CellRef): string;
 
 declare function serialToDate(serial: number, date1904?: boolean): Date;
+declare function dateToSerial(date: Date, date1904?: boolean): number;
 
 type CellType = 'empty' | 'string' | 'number' | 'boolean' | 'date' | 'error';
 interface CellBase {
@@ -178,4 +179,41 @@ declare function openXlsx(source: Uint8Array | ArrayBuffer, options?: ReadOption
  */
 declare function streamSheetRows(source: Uint8Array | ArrayBuffer, sheetName?: string, options?: ReadOptions): AsyncGenerator<Row>;
 
-export { type Cell, type CellRef, type CellType, type Comment, type Hyperlink, type ReadOptions, type Row, type SheetInfo, Workbook, Worksheet, XlsxError, type XlsxErrorCode, columnToIndex, formatRef, indexToColumn, openXlsx, parseRef, serialToDate, streamSheetRows };
+/**
+ * A value a cell can hold when writing. The OOXML cell type is inferred from it:
+ * `string` → inline string, `number` → numeric, `boolean` → `b`, `Date` → date-styled serial.
+ * `null` / `undefined` (including array holes) → an empty cell, omitted from the output.
+ */
+type CellValue = string | number | boolean | Date | null | undefined;
+interface SheetInput {
+    /** Tab name. 1–31 chars, unique (case-insensitively), free of `\ / ? * [ ] :`. */
+    readonly name: string;
+    /** Rows top-to-bottom; each a left-to-right array of cell values. `rows[0][0]` is A1. */
+    readonly rows: readonly (readonly CellValue[])[];
+}
+interface WorkbookInput {
+    /** At least one sheet, in tab order. */
+    readonly sheets: readonly SheetInput[];
+}
+interface WriteOptions {
+    /** Use the 1904 date epoch (legacy Mac) instead of the default 1900 system. */
+    readonly date1904?: boolean;
+}
+
+/**
+ * Convert an open {@link Workbook} into {@link WorkbookInput} for {@link writeXlsx}. Each populated
+ * cell is placed at its own A1 reference, preserving sheet names and tab order. Rows/columns are
+ * left sparse (array holes) — the writer treats a hole as an empty cell — so a workbook with a few
+ * far-apart cells does not materialize a dense grid.
+ */
+declare function workbookToInput(workbook: Workbook): Promise<WorkbookInput>;
+
+/**
+ * Serialize a workbook to `.xlsx` bytes. Async because compression runs on the platform's
+ * CompressionStream. Throws {@link XlsxError} with code `invalid-input` for anything that can't be
+ * represented — no sheets, a bad sheet name, or a cell value that isn't a string, finite number,
+ * boolean, Date, or null.
+ */
+declare function writeXlsx(workbook: WorkbookInput, options?: WriteOptions): Promise<Uint8Array>;
+
+export { type Cell, type CellRef, type CellType, type CellValue, type Comment, type Hyperlink, type ReadOptions, type Row, type SheetInfo, type SheetInput, Workbook, type WorkbookInput, Worksheet, type WriteOptions, XlsxError, type XlsxErrorCode, columnToIndex, dateToSerial, formatRef, indexToColumn, openXlsx, parseRef, serialToDate, streamSheetRows, workbookToInput, writeXlsx };

package/dist/index.js

@@ -62,6 +62,10 @@ function serialToDate(serial, date1904 = false) {
   const epoch = date1904 ? EPOCH_1904_UTC : EPOCH_1900_UTC;
   return new Date(epoch + Math.round(serial * MS_PER_DAY));
 }
+function dateToSerial(date, date1904 = false) {
+  const epoch = date1904 ? EPOCH_1904_UTC : EPOCH_1900_UTC;
+  return (date.getTime() - epoch) / MS_PER_DAY;
+}
 
 // src/ooxml/cell.ts
 function decodeCell(raw, ctx) {
@@ -84,7 +88,8 @@ function decodeCell(raw, ctx) {
       const num = Number(value);
       if (!Number.isFinite(num)) return { ref, type: "empty", value: null };
       if (ctx.styles?.isDateStyle(raw.style)) {
-        return { ref, type: "date", value: serialToDate(num, ctx.date1904 ?? false) };
+        const date = serialToDate(num, ctx.date1904 ?? false);
+        if (!Number.isNaN(date.getTime())) return { ref, type: "date", value: date };
       }
       return { ref, type: "number", value: num };
     }
@@ -1257,4 +1262,434 @@ async function* streamSheetRows(source, sheetName, options) {
   yield* streamRows(zip.readStream(path), context);
 }
 
-export { Workbook, Worksheet, XlsxError, columnToIndex, formatRef, indexToColumn, openXlsx, parseRef, serialToDate, streamSheetRows };
+// src/writer/crc32.ts
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = (c & 1) !== 0 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (let i = 0; i < bytes.length; i++) {
+    crc = (CRC_TABLE[(crc ^ bytes[i]) & 255] ^ crc >>> 8) >>> 0;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+
+// src/writer/deflate.ts
+async function deflateRaw(data) {
+  const blob = new Blob([data]);
+  const reader = blob.stream().pipeThrough(new CompressionStream("deflate-raw")).getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    total += value.byteLength;
+    chunks.push(value);
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
+
+// src/writer/from-workbook.ts
+function cellToValue(cell) {
+  return cell.value;
+}
+async function workbookToInput(workbook) {
+  const sheets = [];
+  for (const info of workbook.sheets) {
+    const worksheet = workbook.sheet(info.name);
+    const rows = [];
+    for await (const row of worksheet.rows()) {
+      for (const cell of row.cells) {
+        const { col, row: rowNum } = parseRef(cell.ref);
+        let rowArr = rows[rowNum - 1];
+        if (rowArr === void 0) {
+          rowArr = [];
+          rows[rowNum - 1] = rowArr;
+        }
+        rowArr[col - 1] = cellToValue(cell);
+      }
+    }
+    sheets.push({ name: info.name, rows });
+  }
+  return { sheets };
+}
+
+// src/writer/xml.ts
+function escapeText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttr(s) {
+  return escapeText(s).replace(/"/g, "&quot;");
+}
+function isXmlSafe(s) {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 32) {
+      if (c !== 9 && c !== 10 && c !== 13) return false;
+    } else if (c === 65534 || c === 65535) {
+      return false;
+    } else if (c >= 55296 && c <= 56319) {
+      const next = s.charCodeAt(i + 1);
+      if (!(next >= 56320 && next <= 57343)) return false;
+      i++;
+    } else if (c >= 56320 && c <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function needsPreserve(s) {
+  return s !== s.trim();
+}
+function preserveAttr(s) {
+  return needsPreserve(s) ? ' xml:space="preserve"' : "";
+}
+
+// src/writer/sheet.ts
+var XML_DECL = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+var NS_MAIN = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+var DATE_STYLE_INDEX = 1;
+function numberToXml(n) {
+  return String(n);
+}
+function renderCell(col, row, value, date1904) {
+  if (value === null || value === void 0) return void 0;
+  const ref = formatRef({ col, row });
+  if (typeof value === "string") {
+    if (!isXmlSafe(value)) {
+      throw new XlsxError(
+        "invalid-input",
+        `cell ${ref}: string contains a character not allowed in XML (a control character or lone surrogate)`
+      );
+    }
+    return {
+      xml: `<c r="${ref}" t="inlineStr"><is><t${preserveAttr(value)}>${escapeText(value)}</t></is></c>`,
+      isDate: false
+    };
+  }
+  if (typeof value === "boolean") {
+    return { xml: `<c r="${ref}" t="b"><v>${value ? 1 : 0}</v></c>`, isDate: false };
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new XlsxError("invalid-input", `cell ${ref}: ${value} is not a finite number`);
+    }
+    return { xml: `<c r="${ref}"><v>${numberToXml(value)}</v></c>`, isDate: false };
+  }
+  if (value instanceof Date) {
+    const serial = dateToSerial(value, date1904);
+    if (!Number.isFinite(serial)) {
+      throw new XlsxError("invalid-input", `cell ${ref}: invalid Date`);
+    }
+    return {
+      xml: `<c r="${ref}" s="${DATE_STYLE_INDEX}"><v>${numberToXml(serial)}</v></c>`,
+      isDate: true
+    };
+  }
+  throw new XlsxError("invalid-input", `cell ${ref}: unsupported cell value type`);
+}
+function worksheetXml(rows, date1904) {
+  let usesDate = false;
+  let minRow = 0;
+  let maxRow = 0;
+  let minCol = 0;
+  let maxCol = 0;
+  const rowXmls = [];
+  for (let r = 0; r < rows.length; r++) {
+    const cells = rows[r];
+    if (cells === void 0) continue;
+    if (!Array.isArray(cells)) {
+      throw new XlsxError(
+        "invalid-input",
+        `sheet row ${r + 1}: a row must be an array of cell values`
+      );
+    }
+    if (cells.length === 0) continue;
+    const rowNum = r + 1;
+    const cellXmls = [];
+    for (let c = 0; c < cells.length; c++) {
+      const colNum = c + 1;
+      const rendered = renderCell(colNum, rowNum, cells[c], date1904);
+      if (rendered === void 0) continue;
+      if (rendered.isDate) usesDate = true;
+      if (minRow === 0 || rowNum < minRow) minRow = rowNum;
+      if (rowNum > maxRow) maxRow = rowNum;
+      if (minCol === 0 || colNum < minCol) minCol = colNum;
+      if (colNum > maxCol) maxCol = colNum;
+      cellXmls.push(rendered.xml);
+    }
+    if (cellXmls.length > 0) rowXmls.push(`<row r="${rowNum}">${cellXmls.join("")}</row>`);
+  }
+  const dimension = minRow === 0 ? "A1" : minRow === maxRow && minCol === maxCol ? formatRef({ col: minCol, row: minRow }) : `${formatRef({ col: minCol, row: minRow })}:${formatRef({ col: maxCol, row: maxRow })}`;
+  const xml = `${XML_DECL}
+<worksheet xmlns="${NS_MAIN}"><dimension ref="${dimension}"/><sheetData>${rowXmls.join(
+    ""
+  )}</sheetData></worksheet>`;
+  return { xml, usesDate };
+}
+
+// src/writer/zip.ts
+var encoder = new TextEncoder();
+var SIG_LOCAL2 = 67324752;
+var SIG_CENTRAL2 = 33639248;
+var SIG_EOCD2 = 101010256;
+var METHOD_STORE = 0;
+var METHOD_DEFLATE = 8;
+var VERSION = 20;
+var U32_CEILING = 4294967295;
+var MAX_ENTRIES = 65535;
+var DOS_TIME = 0;
+var DOS_DATE = 33;
+var u16 = (n) => Uint8Array.from([n & 255, n >>> 8 & 255]);
+var u32 = (n) => Uint8Array.from([n & 255, n >>> 8 & 255, n >>> 16 & 255, n >>> 24 & 255]);
+function concat(parts) {
+  let total = 0;
+  for (const part of parts) total += part.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+async function writeZip(entries) {
+  if (entries.length >= MAX_ENTRIES) {
+    throw new XlsxError(
+      "unsupported",
+      `too many zip entries (${entries.length}); would require ZIP64, which is not supported`
+    );
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const local = [];
+  const central = [];
+  let offset = 0;
+  for (const entry of entries) {
+    if (entry.name.endsWith("/")) {
+      throw new Error(`invalid zip entry name (directory placeholder): ${entry.name}`);
+    }
+    if (seen.has(entry.name)) throw new Error(`duplicate zip entry name: ${entry.name}`);
+    seen.add(entry.name);
+    const name = encoder.encode(entry.name);
+    if (name.length > 65535) {
+      throw new XlsxError(
+        "unsupported",
+        `zip entry name too long (${name.length} bytes); exceeds the classic-ZIP name-length field`
+      );
+    }
+    const data = entry.data;
+    const crc = crc32(data);
+    const uncompressedSize = data.length;
+    const deflated = await deflateRaw(data);
+    const useDeflate = deflated.length < data.length;
+    const method = useDeflate ? METHOD_DEFLATE : METHOD_STORE;
+    const payload = useDeflate ? deflated : data;
+    const compressedSize = payload.length;
+    if (uncompressedSize >= U32_CEILING || compressedSize >= U32_CEILING || offset >= U32_CEILING) {
+      throw new XlsxError(
+        "unsupported",
+        `zip entry ${entry.name} too large for a classic (ZIP64-free) archive`
+      );
+    }
+    const header = concat([
+      u32(SIG_LOCAL2),
+      u16(VERSION),
+      // version needed to extract
+      u16(0),
+      // general-purpose flags: none (sizes/CRC are in the header, no data descriptor)
+      u16(method),
+      u16(DOS_TIME),
+      u16(DOS_DATE),
+      u32(crc),
+      u32(compressedSize),
+      u32(uncompressedSize),
+      u16(name.length),
+      u16(0),
+      // extra field length
+      name
+    ]);
+    local.push(header, payload);
+    central.push(
+      concat([
+        u32(SIG_CENTRAL2),
+        u16(VERSION),
+        // version made by
+        u16(VERSION),
+        // version needed to extract
+        u16(0),
+        // flags
+        u16(method),
+        u16(DOS_TIME),
+        u16(DOS_DATE),
+        u32(crc),
+        u32(compressedSize),
+        u32(uncompressedSize),
+        u16(name.length),
+        u16(0),
+        // extra field length
+        u16(0),
+        // file comment length
+        u16(0),
+        // disk number start
+        u16(0),
+        // internal file attributes
+        u32(0),
+        // external file attributes
+        u32(offset),
+        // relative offset of the local header
+        name
+      ])
+    );
+    offset += header.length + payload.length;
+  }
+  const directory = concat(central);
+  if (offset >= U32_CEILING || directory.length >= U32_CEILING) {
+    throw new XlsxError(
+      "unsupported",
+      "zip archive too large for a classic (ZIP64-free) archive"
+    );
+  }
+  const eocd = concat([
+    u32(SIG_EOCD2),
+    u16(0),
+    // number of this disk
+    u16(0),
+    // disk where the central directory starts
+    u16(entries.length),
+    // central-directory entries on this disk
+    u16(entries.length),
+    // total central-directory entries
+    u32(directory.length),
+    // size of the central directory
+    u32(offset),
+    // offset of the central directory from the start of the archive
+    u16(0)
+    // comment length
+  ]);
+  return concat([...local, directory, eocd]);
+}
+
+// src/writer/workbook.ts
+var encoder2 = new TextEncoder();
+var XML_DECL2 = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
+var NS_MAIN2 = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+var NS_REL = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var NS_PKG_REL = "http://schemas.openxmlformats.org/package/2006/relationships";
+var NS_CT = "http://schemas.openxmlformats.org/package/2006/content-types";
+var CT_BASE = "application/vnd.openxmlformats-officedocument.spreadsheetml";
+var CT_RELS = "application/vnd.openxmlformats-package.relationships+xml";
+var MAX_SHEET_NAME = 31;
+var FORBIDDEN_SHEET_NAME = /[\\/?*[\]:]/;
+var STYLES_XML = `${XML_DECL2}
+<styleSheet xmlns="${NS_MAIN2}"><fonts count="1"><font><sz val="11"/><name val="Calibri"/></font></fonts><fills count="2"><fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill></fills><borders count="1"><border/></borders><cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs><cellXfs count="2"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/><xf numFmtId="14" fontId="0" fillId="0" borderId="0" xfId="0" applyNumberFormat="1"/></cellXfs><cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles></styleSheet>`;
+function validate(workbook) {
+  const sheets = workbook?.sheets;
+  if (!Array.isArray(sheets) || sheets.length === 0) {
+    throw new XlsxError("invalid-input", "a workbook needs at least one sheet");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const sheet of sheets) {
+    const name = sheet?.name;
+    if (typeof name !== "string" || name.length === 0) {
+      throw new XlsxError("invalid-input", "a sheet name must be a non-empty string");
+    }
+    if (name.length > MAX_SHEET_NAME) {
+      throw new XlsxError(
+        "invalid-input",
+        `sheet name "${name}" exceeds ${MAX_SHEET_NAME} characters`
+      );
+    }
+    if (FORBIDDEN_SHEET_NAME.test(name)) {
+      throw new XlsxError(
+        "invalid-input",
+        `sheet name "${name}" contains a forbidden character (\\ / ? * [ ] :)`
+      );
+    }
+    if (!isXmlSafe(name)) {
+      throw new XlsxError(
+        "invalid-input",
+        `sheet name "${name}" contains a character not allowed in XML`
+      );
+    }
+    const key = name.toLowerCase();
+    if (seen.has(key)) {
+      throw new XlsxError(
+        "invalid-input",
+        `duplicate sheet name "${name}" (case-insensitive)`
+      );
+    }
+    seen.add(key);
+    if (!Array.isArray(sheet.rows)) {
+      throw new XlsxError("invalid-input", `sheet "${name}": rows must be an array`);
+    }
+  }
+}
+async function writeXlsx(workbook, options) {
+  validate(workbook);
+  const date1904 = options?.date1904 === true;
+  const sheets = workbook.sheets;
+  const worksheets = sheets.map((sheet) => worksheetXml(sheet.rows, date1904));
+  const anyDate = worksheets.some((w) => w.usesDate);
+  const parts = [];
+  const add = (name, xml) => {
+    parts.push({ name, data: encoder2.encode(xml) });
+  };
+  const overrides = [
+    `<Override PartName="/xl/workbook.xml" ContentType="${CT_BASE}.sheet.main+xml"/>`,
+    ...sheets.map(
+      (_, i) => `<Override PartName="/xl/worksheets/sheet${i + 1}.xml" ContentType="${CT_BASE}.worksheet+xml"/>`
+    ),
+    ...anyDate ? [`<Override PartName="/xl/styles.xml" ContentType="${CT_BASE}.styles+xml"/>`] : []
+  ].join("");
+  add(
+    "[Content_Types].xml",
+    `${XML_DECL2}
+<Types xmlns="${NS_CT}"><Default Extension="rels" ContentType="${CT_RELS}"/><Default Extension="xml" ContentType="application/xml"/>${overrides}</Types>`
+  );
+  add(
+    "_rels/.rels",
+    `${XML_DECL2}
+<Relationships xmlns="${NS_PKG_REL}"><Relationship Id="rId1" Type="${NS_REL}/officeDocument" Target="xl/workbook.xml"/></Relationships>`
+  );
+  const workbookPr = date1904 ? '<workbookPr date1904="1"/>' : "";
+  const sheetsXml = sheets.map(
+    (sheet, i) => `<sheet name="${escapeAttr(sheet.name)}" sheetId="${i + 1}" r:id="rId${i + 1}"/>`
+  ).join("");
+  add(
+    "xl/workbook.xml",
+    `${XML_DECL2}
+<workbook xmlns="${NS_MAIN2}" xmlns:r="${NS_REL}">${workbookPr}<sheets>${sheetsXml}</sheets></workbook>`
+  );
+  const relItems = [
+    ...sheets.map(
+      (_, i) => `<Relationship Id="rId${i + 1}" Type="${NS_REL}/worksheet" Target="worksheets/sheet${i + 1}.xml"/>`
+    ),
+    ...anyDate ? [
+      `<Relationship Id="rId${sheets.length + 1}" Type="${NS_REL}/styles" Target="styles.xml"/>`
+    ] : []
+  ].join("");
+  add(
+    "xl/_rels/workbook.xml.rels",
+    `${XML_DECL2}
+<Relationships xmlns="${NS_PKG_REL}">${relItems}</Relationships>`
+  );
+  if (anyDate) add("xl/styles.xml", STYLES_XML);
+  worksheets.forEach((w, i) => {
+    add(`xl/worksheets/sheet${i + 1}.xml`, w.xml);
+  });
+  return writeZip(parts);
+}
+
+export { Workbook, Worksheet, XlsxError, columnToIndex, dateToSerial, formatRef, indexToColumn, openXlsx, parseRef, serialToDate, streamSheetRows, workbookToInput, writeXlsx };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openjsxl/core",
-  "version": "0.2.1",
-  "description": "Core OOXML engine for openjsxl — zero-dependency .xlsx primitives (zip, xml, cell typing).",
+  "version": "0.3.0",
+  "description": "Core OOXML engine for openjsxl — zero-dependency .xlsx primitives (zip, xml, cell typing, read + write).",
   "type": "module",
   "license": "MIT",
   "author": "joaquimserafim (https://github.com/joaquimserafim)",