@xlsxflow/core 1.1.4 → 1.1.5

package/dist/index.mjs

@@ -56,21 +56,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();
@@ -79,10 +92,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;
@@ -3856,6 +3871,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;
@@ -4357,8 +4376,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() { }
     };