@xlsxflow/core 1.1.4 → 1.1.5

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.1.5
+
+Fixes found while testing every claim in the README on Node 20.12 and 25, Bun, Deno, Chrome and Cloudflare Workers.
+
+### Fixed
+
+- `SheetWriter`, `SheetEditor` and `OdsWriter` wait while nobody reads their output on Node and Bun too. Their `CompressionStream` takes thousands of chunks without pushing back, so a slow consumer let the writer pull the whole row source into memory.
+- On Bun, `.ods` files and other ZIP entries stored without compression read correctly. Bun's `Blob.slice().stream()` runs past the end of the slice, which 1.1.4's size check rejected.
+- `SheetWriter` refuses a merge that overlaps a table. Excel tables cannot hold merged cells, and Excel repaired such files by removing the table.
+
+### Docs
+
+- The README says to close a `createFileReader` reader (Node 25 stops the process when an open file is garbage-collected), lists Deno as tested, fixes the sheet-options example that merged cells inside a table, and corrects the comparison table: ExcelJS 4.4 has no pivot tables.
+
 ## 1.1.4
 
 Fixes from the third round of end-user tests (700 cases).

package/README.md

@@ -29,7 +29,7 @@ Rows are read and written one at a time instead of loading the whole workbook, s
 
 - **No dependencies**: TypeScript on Web APIs (`ReadableStream`, `CompressionStream`, `Blob`).
 - **Streaming**: rows are read and written one at a time, so memory stays flat as files grow (10M cells written with about 1 MB of extra heap; see [Benchmarks](#benchmarks)).
-- **Runs anywhere with Web APIs**: tested on Node 20.12+, Bun, browsers and Cloudflare Workers (without `nodejs_compat`). Deno provides the same APIs but is not tested yet.
+- **Runs anywhere with Web APIs**: tested on Node 20.12 and later, Bun, Deno, Chrome and Cloudflare Workers (without `nodejs_compat`).
 - **Read, write and edit**: stream rows out of a file, generate one on the fly, or change cells, rows, columns and sheets of an existing file while keeping everything else in it.
 - **Styles and formulas**: fonts, fills, borders, alignment, number formats, conditional formats, validations, tables, notes, hyperlinks, autofilters, images, protection and page setup. Formulas and styles read back too.
 - **Older and open formats**: the same reader opens Excel 97-2003 `.xls` files and OpenDocument `.ods` files, and `OdsWriter` writes `.ods`.
@@ -89,11 +89,20 @@ Parts held in memory (workbook, shared strings, styles) are capped at 1 GiB unco
 In Node.js, read straight from disk with `XlsxFlow.readFile`, or pass `await createFileReader(path)` to any function that takes a reader:
 
 ```typescript
-import { XlsxFlow } from '@xlsxflow/core';
+import { XlsxFlow, SheetReader, createFileReader } from '@xlsxflow/core';
 
 for await (const row of await XlsxFlow.readFile('./data.xlsx')) {
   console.log(row.cells);
 }
+
+// createFileReader keeps the file open until you close it, after you are done with
+// everything read through it (Node 25 stops the process when an open file is garbage-collected)
+const file = await createFileReader('./data.xlsx');
+try {
+  console.log((await new SheetReader().readWorkbook(file)).sheets);
+} finally {
+  await file.close();
+}
 ```
 
 ### Writing an Excel File
@@ -243,7 +252,7 @@ writer.addSheet('Report', rows, {
   protection: { password: 'secret', sort: true },  // Excel's legacy hash: deters edits, is not encryption
   pageSetup: { orientation: 'landscape', paperSize: 9, fitToWidth: 1, fitToHeight: 0, printArea: 'A1:C100', printTitleRows: '1', footer: '&CPage &P of &N' },
   tabColor: 'FF00B050',
-  mergeCells: ['A1:C1'],
+  mergeCells: ['E1:G1'],   // not inside a table: Excel tables cannot hold merged cells
   columnWidths: [30, 12],  // in characters; `columns[i].width` wins where both are set
   autoFitColumns: true,    // widths from the longest value (array rows only)
 });
@@ -253,11 +262,11 @@ writer.addSheet('Report', rows, {
 
 Formulas are stored for Excel to calculate when it opens the file. For array rows, the writer also stores a cached result for simple formulas (`SUM`, `AVERAGE`, `COUNT`, `MIN`, `MAX`, `IF`, `CONCATENATE`, `&`, comparisons and arithmetic, including over other formula cells), so other readers see a value. Errors are stored as error values (`#DIV/0!`). Rows from an AsyncIterable get no cached results, since the writer cannot look back at them.
 
-Strings are written inline, which keeps memory flat. `new SheetWriter({ sharedStrings: true })` stores each distinct string once instead. Files are smaller when values repeat, but the distinct strings stay in memory until the file is finished.
+Strings are written inline, which keeps memory flat. `new SheetWriter({ sharedStrings: true })` stores each distinct string once instead. Files are smaller when many different strings repeat (with only a handful of distinct values, inline strings compress as well or better), but the distinct strings stay in memory until the file is finished.
 
 ## Compared with SheetJS and ExcelJS
 
-Checked against each project's own documentation on 8 October 2026. "Pro" means a paid add-on.
+Checked against each project's own documentation, and ExcelJS 4.4.0's published code, on 9 October 2026. "Pro" means a paid add-on.
 
 | | XlsxFlow | SheetJS Community Edition | ExcelJS 4.4 |
 |---|---|---|---|
@@ -268,7 +277,7 @@ Checked against each project's own documentation on 8 October 2026. "Pro" means
 | `.ods` | Read and write | Read and write | No |
 | `.xlsb`, `.numbers` and other formats | No | Yes | No |
 | Charts | Add (Pro) | No (SheetJS Pro) | No |
-| Pivot tables | Add (Pro) | No (SheetJS Pro) | Partial, undocumented |
+| Pivot tables | Add (Pro) | No (SheetJS Pro) | No |
 | Password-protected files | Open and save (Pro) | Old `.xls` obfuscation only (SheetJS Pro opens AES files) | No |
 | Licence | MIT, Pro is paid | Apache 2.0 | MIT |
 

package/dist/index.cjs

@@ -58,21 +58,34 @@ class ZipStreamWriter {
         // Stream data, tracking sizes and CRC32
         let uncompressedSize = 0;
         let crc = 0xffffffff;
-        const crcStream = new TransformStream({
-            // CompressionStream takes every write at once, so the input is held back here instead,
-            // while nobody reads the output
-            transform: async (chunk, controller) => {
-                await this.roomInQueue();
-                uncompressedSize += chunk.length;
-                crc = crc32Update(crc, chunk);
-                controller.enqueue(chunk);
+        const compressor = new CompressionStream('deflate-raw');
+        const writer = compressor.writable.getWriter();
+        const reader = compressor.readable.getReader();
+        const input = inputStream.getReader();
+        // Node's and Bun's CompressionStream accept thousands of writes without backpressure, so one chunk
+        // is fed at a time: a write resolves once the chunk is compressed, which waits while nobody reads
+        // the output. Rows are then only pulled as fast as the ZIP is consumed.
+        const feed = (async () => {
+            try {
+                while (true) {
+                    const { done, value } = await input.read();
+                    if (done)
+                        break;
+                    await this.roomInQueue();
+                    uncompressedSize += value.length;
+                    crc = crc32Update(crc, value);
+                    await writer.write(value);
+                }
+                await writer.close();
             }
-        });
+            catch (err) {
+                // Stop the source too (a row generator's finally runs, a database cursor closes)
+                await input.cancel(err).catch(() => { });
+                await writer.abort(err).catch(() => { });
+                throw err;
+            }
+        })();
         let compressedSize = 0;
-        const reader = inputStream
-            .pipeThrough(crcStream)
-            .pipeThrough(new CompressionStream('deflate-raw'))
-            .getReader();
         try {
             while (true) {
                 const { done, value } = await reader.read();
@@ -81,10 +94,12 @@ class ZipStreamWriter {
                 compressedSize += value.length;
                 await this.pushChunk(value);
             }
+            await feed;
         }
         catch (err) {
-            // Stop the source too (a row generator's finally runs, a database cursor closes)
             await reader.cancel(err).catch(() => { });
+            await input.cancel(err).catch(() => { });
+            await feed.catch(() => { });
             throw err;
         }
         crc = (crc ^ 0xffffffff) >>> 0;
@@ -3858,6 +3873,10 @@ class SheetWriter {
                 const box = parseRange$1(table.ref, 'table range');
                 if (boxes.some(b => overlaps(b, box)))
                     throw new Error(`Table "${table.name}" overlaps another table on sheet "${sheet.name}".`);
+                // Excel tables cannot hold merged cells: it repairs the file by removing the table
+                const merge = sheet.options.mergeCells?.find(ref => overlaps(parseRange$1(ref, 'merge range'), box));
+                if (merge)
+                    throw new Error(`Merge "${merge}" overlaps table "${table.name}" on sheet "${sheet.name}"; Excel tables cannot contain merged cells.`);
                 boxes.push(box);
                 const first = colIndex(m[1]);
                 const width = colIndex(m[3]) - first + 1;
@@ -4359,8 +4378,18 @@ function createBlobReader(blob) {
             return new Uint8Array(await slice.arrayBuffer());
         },
         stream(offset, length) {
-            const slice = blob.slice(offset, offset + length);
-            return slice.stream();
+            // Bun's Blob.slice(start, end).stream() runs on to the end of the original blob, so stop at length
+            let left = length;
+            return blob.slice(offset, offset + length).stream().pipeThrough(new TransformStream({
+                start(controller) { if (left <= 0)
+                    controller.terminate(); },
+                transform(chunk, controller) {
+                    controller.enqueue(chunk.length > left ? chunk.subarray(0, left) : chunk);
+                    left -= chunk.length;
+                    if (left <= 0)
+                        controller.terminate();
+                }
+            }));
         },
         async close() { }
     };