@shbernal/ts-xlsx 2.0.0 → 3.0.0

package/dist/io/xlsx/workbook-xml.js

@@ -1,10 +1,12 @@
 import { mangleFormula, quoteSheetName } from '../../core/formula.js';
 import { WORKBOOK_PROTECTION_CREDENTIAL_ATTRS } from '../../core/workbook-protection.js';
-import { escapeAttr, escapeText, XML_DECLARATION } from '../../xml/xml.js';
-import { extensionOf, relativePartPath, THEME_PART_PATH } from '../opc/part-paths.js';
+import { isVisibility } from '../../core/worksheet.js';
+import { checkedToken, escapeAttr, escapeText, numAttr, textAttr, XML_DECLARATION, } from '../../xml/xml.js';
+import { extensionOf, THEME_PART_PATH } from '../opc/part-paths.js';
 import { relationship, relationshipsPart } from '../opc/rels.js';
 import { imageContentType } from './images.js';
 import { SLICER_CACHES_EXT_URI } from './namespaces.js';
+import { APP_PROPS_PART, commentsPart, CORE_PROPS_PART, drawingPart, PERSONS_PART, pivotCacheDefinitionPart, pivotCacheRecordsPart, pivotTablePart, SHARED_STRINGS_PART, STYLES_PART, tablePart, targetFromWorkbook, threadedCommentsPart, WORKBOOK_PART, worksheetPart, } from './part-names.js';
 import { NS, REL } from './relationships.js';
 import { x14Ext } from './x14-ext.js';
 const CT = {
@@ -71,45 +73,47 @@ function contentTypeOverrides(sheetCount, tables, drawingNumbers, commentNumbers
         .filter((part) => part.path !== THEME_PART_PATH)
         .filter((part) => extensionDefaults.get(extensionOf(part.path).toLowerCase())?.contentType !==
         part.contentType)
-        .map((part) => override(`/${part.path}`, part.contentType));
+        .map((part) => override(part.path, part.contentType));
     return [
-        override('/xl/workbook.xml', isMacroEnabled(preservedWorkbookRefs) ? CT.macroEnabledWorkbook : CT.workbook),
-        ...Array.from({ length: sheetCount }, (_, i) => override(`/xl/worksheets/sheet${i + 1}.xml`, CT.worksheet)),
-        ...tables.map(({ number }) => override(`/xl/tables/table${number}.xml`, CT.table)),
-        ...drawingNumbers.map((number) => override(`/xl/drawings/drawing${number}.xml`, CT.drawing)),
-        ...commentNumbers.map((number) => override(`/xl/comments${number}.xml`, CT.comments)),
-        ...threadedCommentNumbers.map((number) => override(`/xl/threadedComments/threadedComment${number}.xml`, CT.threadedComments)),
-        ...pivots.map(({ number }) => override(`/xl/pivotTables/pivotTable${number}.xml`, CT.pivotTable)),
-        ...pivots.map(({ number }) => override(`/xl/pivotCache/pivotCacheDefinition${number}.xml`, CT.pivotCacheDefinition)),
-        ...pivots.map(({ number }) => override(`/xl/pivotCache/pivotCacheRecords${number}.xml`, CT.pivotCacheRecords)),
-        override(`/${THEME_PART_PATH}`, CT.theme),
-        override('/xl/styles.xml', CT.styles),
-        ...(hasSharedStrings ? [override('/xl/sharedStrings.xml', CT.sharedStrings)] : []),
-        ...(hasPersons ? [override('/xl/persons/person.xml', CT.person)] : []),
-        override('/docProps/core.xml', CT.core),
-        override('/docProps/app.xml', CT.app),
+        override(WORKBOOK_PART, isMacroEnabled(preservedWorkbookRefs) ? CT.macroEnabledWorkbook : CT.workbook),
+        ...Array.from({ length: sheetCount }, (_, i) => override(worksheetPart(i + 1), CT.worksheet)),
+        ...tables.map(({ number }) => override(tablePart(number), CT.table)),
+        ...drawingNumbers.map((number) => override(drawingPart(number), CT.drawing)),
+        ...commentNumbers.map((number) => override(commentsPart(number), CT.comments)),
+        ...threadedCommentNumbers.map((number) => override(threadedCommentsPart(number), CT.threadedComments)),
+        ...pivots.map(({ number }) => override(pivotTablePart(number), CT.pivotTable)),
+        ...pivots.map(({ number }) => override(pivotCacheDefinitionPart(number), CT.pivotCacheDefinition)),
+        ...pivots.map(({ number }) => override(pivotCacheRecordsPart(number), CT.pivotCacheRecords)),
+        override(THEME_PART_PATH, CT.theme),
+        override(STYLES_PART, CT.styles),
+        ...(hasSharedStrings ? [override(SHARED_STRINGS_PART, CT.sharedStrings)] : []),
+        ...(hasPersons ? [override(PERSONS_PART, CT.person)] : []),
+        override(CORE_PROPS_PART, CT.core),
+        override(APP_PROPS_PART, CT.app),
         ...preservedOverrides,
     ].join('');
 }
-function override(partName, contentType) {
-    return `<Override PartName="${partName}" ContentType="${contentType}"/>`;
+function override(partPath, contentType) {
+    return `<Override PartName="/${partPath}" ContentType="${contentType}"/>`;
 }
 function defaultType(extension, contentType) {
     return `<Default Extension="${extension}" ContentType="${contentType}"/>`;
 }
 export function rootRelsXml(rootRefs) {
     return relationshipsPart([
-        relationship('rId1', REL.officeDocument, 'xl/workbook.xml'),
-        relationship('rId2', REL.coreProps, 'docProps/core.xml'),
-        relationship('rId3', REL.extProps, 'docProps/app.xml'),
-        ...rootRefs.map((ref, i) => relationship(`rId${4 + i}`, ref.relType, escapeAttr(ref.entryPath))),
+        relationship('rId1', REL.officeDocument, WORKBOOK_PART),
+        relationship('rId2', REL.coreProps, CORE_PROPS_PART),
+        relationship('rId3', REL.extProps, APP_PROPS_PART),
+        ...rootRefs.map((ref, i) => relationship(`rId${4 + i}`, ref.relType, ref.entryPath)),
     ]);
 }
 export function workbookXml(workbook, preservedRels, pivots) {
     const sheets = workbook.worksheets;
     const entries = sheets
         .map((sheet, i) => {
-        const state = sheet.state === 'visible' ? '' : ` state="${sheet.state}"`;
+        const state = sheet.state === 'visible'
+            ? ''
+            : ` state="${checkedToken(sheet.state, isVisibility, 'sheet visibility')}"`;
         return `<sheet name="${escapeAttr(sheet.name)}" sheetId="${sheet.id}"${state} r:id="rId${i + 1}"/>`;
     })
         .join('');
@@ -128,11 +132,14 @@ export function workbookXml(workbook, preservedRels, pivots) {
 function bookViewsXml(workbook) {
     const view = workbook.view;
     const activeTab = workbook.activeTabIndex;
-    const attrs = (view.visibility !== undefined && view.visibility !== 'visible'
-        ? ` visibility="${view.visibility}"`
-        : '') +
+    const attrs = (view.visibility === undefined || view.visibility === 'visible'
+        ? ''
+        : ` visibility="${checkedToken(view.visibility, isVisibility, 'window visibility')}"`) +
         (view.minimized ? ' minimized="1"' : '') +
-        ` xWindow="${view.x}" yWindow="${view.y}" windowWidth="${view.width}" windowHeight="${view.height}"` +
+        numAttr('xWindow', view.x) +
+        numAttr('yWindow', view.y) +
+        numAttr('windowWidth', view.width) +
+        numAttr('windowHeight', view.height) +
         (activeTab === 0 ? '' : ` activeTab="${activeTab}"`);
     return `<bookViews><workbookView${attrs}/></bookViews>`;
 }
@@ -192,7 +199,7 @@ function definedNamesXml(workbook) {
         const scopeAttr = name.scope === undefined
             ? ''
             : ` localSheetId="${sheets.findIndex((sheet) => sheet.name === name.scope)}"`;
-        const commentAttr = name.comment === undefined ? '' : ` comment="${escapeAttr(name.comment)}"`;
+        const commentAttr = textAttr('comment', name.comment);
         const hiddenAttr = name.hidden ? ' hidden="1"' : '';
         return (`<definedName name="${escapeAttr(name.name)}"${scopeAttr}${commentAttr}${hiddenAttr}>` +
             `${escapeText(mangleFormula(name.refersTo))}</definedName>`);
@@ -215,19 +222,19 @@ function filterDatabaseRefersTo(sheetName, range) {
 export const FIXED_WORKBOOK_REL_COUNT = 2;
 export function workbookRelsXml(sheetCount, hasSharedStrings, personsRelId, preservedRels, pivots) {
     return relationshipsPart([
-        ...Array.from({ length: sheetCount }, (_, i) => relationship(`rId${i + 1}`, REL.worksheet, `worksheets/sheet${i + 1}.xml`)),
+        ...Array.from({ length: sheetCount }, (_, i) => relationship(`rId${i + 1}`, REL.worksheet, targetFromWorkbook(worksheetPart(i + 1)))),
         relationship(`rId${sheetCount + 1}`, REL.styles, 'styles.xml'),
-        relationship(`rId${sheetCount + FIXED_WORKBOOK_REL_COUNT}`, REL.theme, relativePartPath('xl/workbook.xml', THEME_PART_PATH)),
+        relationship(`rId${sheetCount + FIXED_WORKBOOK_REL_COUNT}`, REL.theme, targetFromWorkbook(THEME_PART_PATH)),
         ...(hasSharedStrings
             ? [
-                relationship(`rId${sheetCount + FIXED_WORKBOOK_REL_COUNT + 1}`, REL.sharedStrings, 'sharedStrings.xml'),
+                relationship(`rId${sheetCount + FIXED_WORKBOOK_REL_COUNT + 1}`, REL.sharedStrings, targetFromWorkbook(SHARED_STRINGS_PART)),
             ]
             : []),
         ...(personsRelId === null
             ? []
-            : [relationship(personsRelId, REL.person, 'persons/person.xml')]),
-        ...preservedRels.map((ref) => relationship(ref.relId, ref.relType, escapeAttr(relativePartPath('xl/workbook.xml', ref.entryPath)))),
-        ...pivots.map((pivot) => relationship(pivot.workbookRelId, REL.pivotCacheDefinition, `pivotCache/pivotCacheDefinition${pivot.number}.xml`)),
+            : [relationship(personsRelId, REL.person, targetFromWorkbook(PERSONS_PART))]),
+        ...preservedRels.map((ref) => relationship(ref.relId, ref.relType, escapeAttr(targetFromWorkbook(ref.entryPath)))),
+        ...pivots.map((pivot) => relationship(pivot.workbookRelId, REL.pivotCacheDefinition, targetFromWorkbook(pivotCacheDefinitionPart(pivot.number)))),
     ]);
 }
 export function corePropsXml(properties) {

package/dist/io/xlsx/worksheet-xml.d.ts

@@ -1,4 +1,4 @@
-import type { Cell } from '../../core/cell.ts';
+import { type Cell } from '../../core/cell.ts';
 import type { ColumnProperties, RowProperties, Worksheet } from '../../core/worksheet.ts';
 import { type HyperlinkPlan } from './hyperlinks.ts';
 import type { BackgroundPlan, CommentPlan, DrawingPlan, PivotPlan, PreservedReferencePlan, PrinterSettingsPlan, TablePlan, ThreadedCommentPlan } from './package-plan.ts';

package/dist/io/xlsx/worksheet-xml.js

@@ -1,16 +1,18 @@
 import { decodeRange, encodeAddress } from '../../core/address.js';
+import { cellHasOwnStyle } from '../../core/cell.js';
 import { DEFAULT_DATE_NUMFMT, dateToSerial } from '../../core/date.js';
 import { mangleFormula } from '../../core/formula.js';
 import { NAMED_STYLE_ID } from '../../core/internal.js';
+import { CELL_STYLE_FACETS, pickStyleFacets } from '../../core/style.js';
 import { detectValueType, isDataTableFormulaValue, isErrorValue, isFormulaValue, isHyperlinkValue, isRichTextValue, isSharedFormulaValue, } from '../../core/value.js';
 import { AuthoringError, InternalError } from '../../errors.js';
-import { escapeAttr, escapeSpreadsheetText, escapeText, numberText, textElement, XML_DECLARATION, } from '../../xml/xml.js';
-import { relativePartPath } from '../opc/part-paths.js';
+import { assertWritableNumber, escapeAttr, escapeSpreadsheetText, escapeText, numberText, textAttr, textElement, XML_DECLARATION, } from '../../xml/xml.js';
 import { relationship, relationshipsPart } from '../opc/rels.js';
 import { conditionalFormattingsExtXml, conditionalFormattingsXml } from './conditional-formatting.js';
 import { dataValidationsExtXml, dataValidationsXml } from './data-validation.js';
 import { hyperlinksXml } from './hyperlinks.js';
 import { SLICER_LIST_EXT_URI } from './namespaces.js';
+import { commentsPart, drawingPart, mediaPart, pivotTablePart, printerSettingsPart, tablePart, targetFromWorksheet, threadedCommentsPart, vmlDrawingPart, } from './part-names.js';
 import { NS, REL } from './relationships.js';
 import { richTextRunsXml } from './rich-text.js';
 import { planSharedFormulas } from './shared-formulas.js';
@@ -114,7 +116,7 @@ export function buildColumnDefaults(sheet) {
 }
 export function renderRow(entry, ctx) {
     const { number, cells, properties } = entry;
-    const rendered = cells.filter((cell) => cell.value !== null || hasOwnStyle(cell));
+    const rendered = cells.filter((cell) => cell.value !== null || cellHasOwnStyle(cell));
     const attrs = rowAttrs(properties, ctx.styles, ctx.collapsedSummaries.has(number));
     if (rendered.length === 0 && attrs === '')
         return { xml: '', minCol: Infinity, maxCol: -Infinity };
@@ -136,16 +138,20 @@ export function renderRow(entry, ctx) {
     return { xml: `<row r="${number}"${attrs}>${cellsXml}</row>`, minCol, maxCol };
 }
 function composeCellStyle(cell, rowFill, colDef) {
-    return {
-        fill: cell.fill ?? rowFill ?? colDef?.fill,
-        numFmt: cell.numFmt ?? colDef?.numFmt ?? dateDefaultNumFmt(cell.value),
-        font: cell.font ?? colDef?.font,
-        border: cell.border ?? colDef?.border,
-        alignment: cell.alignment ?? colDef?.alignment,
-        protection: cell.protection ?? colDef?.protection,
-        quotePrefix: cell.quotePrefix,
-        xfId: cell[NAMED_STYLE_ID],
-    };
+    const style = {};
+    for (const facet of CELL_STYLE_FACETS)
+        inheritFacet(style, facet, cell, colDef);
+    style.fill = cell.fill ?? rowFill ?? colDef?.fill;
+    style.numFmt = cell.numFmt ?? colDef?.numFmt ?? dateDefaultNumFmt(cell.value);
+    if (cell.quotePrefix !== undefined)
+        style.quotePrefix = cell.quotePrefix;
+    const xfId = cell[NAMED_STYLE_ID];
+    if (xfId !== undefined)
+        style.xfId = xfId;
+    return style;
+}
+function inheritFacet(target, key, cell, colDef) {
+    target[key] = cell[key] ?? colDef?.[key];
 }
 function worksheetExtLstXml(sheet, slicerRelIds) {
     const exts = [
@@ -199,36 +205,38 @@ function tablePartsXml(tables) {
 }
 export function worksheetRelsXml(tables, drawing, comments, threadedComments, printerSettings, background, hyperlinks, preservedReferences, pivots) {
     const rels = [
-        ...tables.map(({ relId, number }) => relationship(relId, REL.table, `../tables/table${number}.xml`)),
-        ...pivots.map((pivot) => relationship(pivot.sheetRelId, REL.pivotTable, `../pivotTables/pivotTable${pivot.number}.xml`)),
+        ...tables.map(({ relId, number }) => relationship(relId, REL.table, targetFromWorksheet(tablePart(number)))),
+        ...pivots.map((pivot) => relationship(pivot.sheetRelId, REL.pivotTable, targetFromWorksheet(pivotTablePart(pivot.number)))),
         ...(drawing === null
             ? []
-            : [relationship(drawing.relId, REL.drawing, `../drawings/drawing${drawing.number}.xml`)]),
+            : [
+                relationship(drawing.relId, REL.drawing, targetFromWorksheet(drawingPart(drawing.number))),
+            ]),
         ...(comments === null
             ? []
             : [
-                relationship(comments.vmlRelId, REL.vmlDrawing, `../drawings/vmlDrawing${comments.number}.vml`),
-                relationship(comments.commentsRelId, REL.comments, `../comments${comments.number}.xml`),
+                relationship(comments.vmlRelId, REL.vmlDrawing, targetFromWorksheet(vmlDrawingPart(comments.number))),
+                relationship(comments.commentsRelId, REL.comments, targetFromWorksheet(commentsPart(comments.number))),
             ]),
         ...(threadedComments === null
             ? []
             : [
-                relationship(threadedComments.relId, REL.threadedComment, `../threadedComments/threadedComment${threadedComments.number}.xml`),
+                relationship(threadedComments.relId, REL.threadedComment, targetFromWorksheet(threadedCommentsPart(threadedComments.number))),
             ]),
         ...(printerSettings === null
             ? []
             : [
-                relationship(printerSettings.relId, REL.printerSettings, `../printerSettings/printerSettings${printerSettings.number}.bin`),
+                relationship(printerSettings.relId, REL.printerSettings, targetFromWorksheet(printerSettingsPart(printerSettings.number))),
             ]),
         ...(background === null
             ? []
             : [
-                relationship(background.relId, REL.image, `../media/image${background.mediaNumber}.${background.extension}`),
+                relationship(background.relId, REL.image, targetFromWorksheet(mediaPart(background.mediaNumber, background.extension))),
             ]),
-        ...preservedReferences.map((reference) => relationship(reference.relId, reference.relType, escapeAttr(relativePartPath('xl/worksheets/sheet1.xml', reference.entryPath)))),
+        ...preservedReferences.map((reference) => relationship(reference.relId, reference.relType, escapeAttr(targetFromWorksheet(reference.entryPath)))),
         ...hyperlinks
             .filter((link) => link.relId !== undefined && link.target !== undefined)
-            .map((link) => relationship(link.relId, REL.hyperlink, escapeAttr(link.target), {
+            .map((link) => relationship(link.relId, REL.hyperlink, link.target, {
             external: true,
         })),
     ];
@@ -243,12 +251,16 @@ function sheetFormatPr(properties, outlineLevel) {
     }
     if (properties.defaultRowHeight !== undefined)
         attrs += ' customHeight="1"';
-    if (outlineLevel.col > 0)
-        attrs += ` outlineLevelCol="${outlineLevel.col}"`;
-    if (outlineLevel.row > 0)
-        attrs += ` outlineLevelRow="${outlineLevel.row}"`;
+    attrs += outlineAttr('outlineLevelCol', outlineLevel.col);
+    attrs += outlineAttr('outlineLevelRow', outlineLevel.row);
     return `<sheetFormatPr${attrs}/>`;
 }
+function outlineAttr(name, level) {
+    if (level === undefined)
+        return '';
+    const text = numberText(level);
+    return level > 0 ? ` ${name}="${text}"` : '';
+}
 function maxColumnOutlineLevel(sheet) {
     let max = 0;
     for (const column of sheet.columns())
@@ -285,22 +297,16 @@ function colBody(properties, styles) {
         attrs += ' hidden="1"';
         meaningful = true;
     }
-    if (properties.outlineLevel !== undefined && properties.outlineLevel > 0) {
-        attrs += ` outlineLevel="${properties.outlineLevel}"`;
+    const outline = outlineAttr('outlineLevel', properties.outlineLevel);
+    if (outline !== '') {
+        attrs += outline;
         meaningful = true;
     }
     if (properties.collapsed) {
         attrs += ' collapsed="1"';
         meaningful = true;
     }
-    const style = styles.styleId({
-        fill: properties.fill,
-        numFmt: properties.numFmt,
-        font: properties.font,
-        border: properties.border,
-        alignment: properties.alignment,
-        protection: properties.protection,
-    });
+    const style = styles.styleId(pickStyleFacets(properties));
     if (style !== 0) {
         attrs += ` style="${style}"`;
         meaningful = true;
@@ -315,9 +321,7 @@ function rowAttrs(properties, styles, collapsedSummary) {
         attrs += ` ht="${numberText(properties.height)}" customHeight="1"`;
     if (properties.hidden)
         attrs += ' hidden="1"';
-    if (properties.outlineLevel !== undefined && properties.outlineLevel > 0) {
-        attrs += ` outlineLevel="${properties.outlineLevel}"`;
-    }
+    attrs += outlineAttr('outlineLevel', properties.outlineLevel);
     if (properties.collapsed || collapsedSummary)
         attrs += ' collapsed="1"';
     const style = styles.styleId({ fill: properties.fill });
@@ -331,6 +335,7 @@ function scanRowOutline(sheet) {
     let maxLevel = 0;
     for (const { number, properties } of sheet.rows()) {
         const rowLevel = properties?.outlineLevel ?? 0;
+        assertWritableNumber(rowLevel);
         level.set(number, rowLevel);
         hidden.set(number, properties?.hidden ?? false);
         if (rowLevel > maxLevel)
@@ -407,16 +412,6 @@ function cellXml(cell, style, shared, sharedStrings) {
         return `<c r="${ref}"${s}/>`;
     throw new InternalError(`writing a ${detectValueType(value)} cell value has no arm: every CellValue kind is handled above`);
 }
-function hasOwnStyle(cell) {
-    return (cell.fill !== undefined ||
-        cell.numFmt !== undefined ||
-        cell.font !== undefined ||
-        cell.border !== undefined ||
-        cell.alignment !== undefined ||
-        cell.protection !== undefined ||
-        cell.quotePrefix === true ||
-        cell[NAMED_STYLE_ID] !== undefined);
-}
 function cellFormulaXml(ref, s, value, shared) {
     if (shared !== undefined) {
         if (shared.ref !== undefined && isFormulaValue(value)) {
@@ -430,8 +425,8 @@ function cellFormulaXml(ref, s, value, shared) {
         const attrs = `ref="${escapeAttr(value.ref)}"` +
             ` dt2D="${value.dataTable2D ? 1 : 0}"` +
             ` dtr="${value.dataTableRow ? 1 : 0}"` +
-            (value.r1 !== undefined ? ` r1="${escapeAttr(value.r1)}"` : '') +
-            (value.r2 !== undefined ? ` r2="${escapeAttr(value.r2)}"` : '');
+            textAttr('r1', value.r1) +
+            textAttr('r2', value.r2);
         return formulaBodyXml(ref, s, `<f t="dataTable" ${attrs}/>`, value.result);
     }
     if (isFormulaValue(value)) {

package/dist/io/xlsx/write-stream.d.ts

@@ -88,7 +88,14 @@ export declare class WorksheetStreamWriter {
      */
     flushRow(number: number, cells: readonly Cell[]): void;
     flushedSheet(): FlushedSheet | undefined;
-    /** Address a cell by its A1 reference to read or style it before the sheet is committed. */
+    /**
+     * Address a cell by its A1 reference to read or style it before the sheet is committed. The row it
+     * names must still be live: a row whose {@link StreamedRow.commit} has run is finished.
+     *
+     * @throws {AuthoringError} if the reference names an already-committed row. That row's `<row>` is
+     *   rendered and its cells are released, so the cell this would materialise could only be written
+     *   as a second row carrying the same number.
+     */
     getCell(reference: string): Cell;
     /**
      * Attach a data validation to a range before the sheet is committed. Delegates to the model, so the
@@ -165,6 +172,12 @@ export declare class WorkbookStreamWriter {
      * Assemble the workbook into its package, stream the bytes through {@link stream}, and resolve with
      * the same bytes. Every sheet is frozen first, so a row added after this rejects legibly. Idempotent
      * only in that a second call throws rather than re-emitting.
+     *
+     * If assembling or zipping the package fails, the returned promise rejects *and* every stream this
+     * writer was given or handed out is destroyed with that error. A caller piping {@link stream}, or
+     * awaiting its own sink, therefore sees an `error` rather than waiting on a stream that will never
+     * end; and it is an `error` rather than a clean `end` because the bytes written so far are a
+     * truncated package that must not be read as a whole one.
      */
     commit(): Promise<Uint8Array>;
 }

package/dist/io/xlsx/write-stream.js

@@ -1,7 +1,8 @@
 import { createWriteStream } from 'node:fs';
 import { PassThrough } from 'node:stream';
 import { Zip, ZipDeflate } from 'fflate';
-import { encodeAddress } from '../../core/address.js';
+import { concat } from '../../bytes.js';
+import { encodeAddress, tryDecodeCellRef } from '../../core/address.js';
 import { INTERNAL } from '../../core/internal.js';
 import { isSharedFormulaValue } from '../../core/value.js';
 import { Workbook } from '../../core/workbook.js';
@@ -36,6 +37,7 @@ export class WorksheetStreamWriter {
     #lastRow = 0;
     #columnDefaults;
     #flushedRows = [];
+    #flushedNumbers = new Set();
     #extent = new Extent();
     #maxRowOutlineLevel = 0;
     constructor(sheet, eager, styles) {
@@ -97,6 +99,7 @@ export class WorksheetStreamWriter {
             this.#flushedRows.push({ number, xml });
             this.#extent.add(number, minCol, maxCol);
         }
+        this.#flushedNumbers.add(number);
         this.#sheet[INTERNAL].evictRow(number);
     }
     flushedSheet() {
@@ -110,6 +113,12 @@ export class WorksheetStreamWriter {
     }
     getCell(reference) {
         this.#assertOpen();
+        const target = tryDecodeCellRef(reference);
+        if (target !== undefined && this.#flushedNumbers.has(target.row)) {
+            throw new AuthoringError(`cell ${reference} of streamed sheet "${this.#sheet.name}" is in row ${target.row}, which is ` +
+                'already committed: its bytes are written and its cells released, so this value could only ' +
+                'be emitted as a second row with that number. Style a row before committing it.');
+        }
         return this.#sheet.getCell(reference);
     }
     addDataValidation(sqref, rule, options = {}) {
@@ -178,23 +187,17 @@ export class WorkbookStreamWriter {
         return this.#stream;
     }
     addImage(options) {
-        if (this.#committed) {
-            throw new AuthoringError('the workbook is already committed: no more images can be registered');
-        }
+        this.#assertOpen('no more images can be registered');
         return this.#workbook.addImage(options);
     }
     addWorksheet(name, options = {}) {
-        if (this.#committed) {
-            throw new AuthoringError('the workbook is already committed: no more worksheets can be added');
-        }
+        this.#assertOpen('no more worksheets can be added');
         const sheet = new WorksheetStreamWriter(this.#workbook.addWorksheet(name, options), this.#eager, this.#styles);
         this.#sheets.push(sheet);
         return sheet;
     }
     async commit() {
-        if (this.#committed) {
-            throw new AuthoringError('the workbook is already committed');
-        }
+        this.#assertOpen('its package is already assembled and cannot be re-emitted');
         this.#committed = true;
         for (const sheet of this.#sheets)
             sheet.commit();
@@ -206,22 +209,36 @@ export class WorkbookStreamWriter {
             if (sheetFlushed)
                 flushed.set(sheet.model, sheetFlushed);
         }
-        const parts = buildPackageParts(this.#workbook, {
-            ...this.#writeOptions,
-            styles: this.#styles,
-            flushed,
-        });
         const owned = this.#stream;
         const sink = this.#sink;
         const sinkSettled = sink ? settleOnFinish(sink) : undefined;
-        const bytes = await streamZipPackage(parts, (chunk) => {
-            owned?.write(chunk);
-            sink?.write(chunk);
-        });
-        owned?.end();
-        sink?.end();
-        await sinkSettled;
-        return bytes;
+        try {
+            const parts = buildPackageParts(this.#workbook, {
+                ...this.#writeOptions,
+                styles: this.#styles,
+                flushed,
+            });
+            const bytes = await streamZipPackage(parts, (chunk) => {
+                owned?.write(chunk);
+                sink?.write(chunk);
+            });
+            owned?.end();
+            sink?.end();
+            await sinkSettled;
+            return bytes;
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            sinkSettled?.catch(() => { });
+            owned?.destroy(failure);
+            sink?.destroy(failure);
+            throw error;
+        }
+    }
+    #assertOpen(what) {
+        if (this.#committed) {
+            throw new AuthoringError(`the workbook is already committed: ${what}`);
+        }
     }
 }
 function settleOnFinish(sink) {
@@ -252,13 +269,3 @@ function streamZipPackage(parts, onChunk) {
         zip.end();
     });
 }
-function concat(chunks) {
-    const total = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return out;
-}

package/dist/io/xlsx/write.d.ts

@@ -81,6 +81,11 @@ export declare function createStyleRegistry(workbook: Workbook): StyleRegistry;
  * streaming writer can drive the identical parts through a streamed zip container rather than
  * `zipSync`. Neither writer duplicates a byte of serialisation.
  *
+ * Three steps, and their order is load-bearing. The package is planned in full before anything is
+ * serialised, so a drawing's embed and a pivot's cache can target a part number that already exists.
+ * The sheets are serialised before the parts are emitted, because interning a style is a side effect
+ * of that pass and `xl/styles.xml` is one of the parts emitted in the third step.
+ *
  * @throws {AuthoringError} if the workbook has no worksheets, or holds a value the writer cannot represent.
  */
 export declare function buildPackageParts(workbook: Workbook, options?: InternalWriteOptions): Record<string, Uint8Array>;