@shbernal/ts-xlsx 2.1.0 → 3.0.0

package/dist/io/xlsx/read.js

@@ -4,51 +4,44 @@ import { INTERNAL } from '../../core/internal.js';
 import { WORKBOOK_PROTECTION_CREDENTIAL_ATTRS, } from '../../core/workbook-protection.js';
 import { Workbook } from '../../core/workbook.js';
 import { isVisibility } from '../../core/worksheet.js';
-import { boolStrict, capturedText, enumToken, localName, numInteger, openElements, parseXml, } from '../../xml/xml-read.js';
+import { capturedText, openElements, parseXml, parseXmlPasses } from '../../xml/xml-read.js';
+import { boolStrict, enumToken, localName, numInteger } from '../../xml/xml-scan.js';
 import { UnsupportedFormatError } from '../opc/errors.js';
-import { extensionOf } from '../opc/part-paths.js';
-import { capturePartClosure, contentTypeResolver, packageAccessors, parseRelationshipRecords, parseRelationships, readPartRelationships, relationshipTargetByType, resolveRelativePart, resolveWorkbookPart, } from '../opc/read-opc.js';
-import { DEFAULT_MAX_UNCOMPRESSED } from '../opc/read-options.js';
-import { inflateSpreadsheetPackage } from '../opc/sniff-format.js';
+import { extensionOf, resolveRelativePart } from '../opc/part-paths.js';
+import { capturePartClosure, contentTypeResolver, openSpreadsheetPackage, parseRelationshipRecords, readPartRelationships, } from '../opc/read-opc.js';
 import { readXlsbPackage, XLSB_WORKBOOK_PART } from '../xlsb/read.js';
 import { applyNotes, parseComments } from './comments.js';
-import { parseConditionalFormattings, parseDxfs } from './conditional-formatting.js';
-import { applyDataValidations, parseDataValidations, parseExtendedDataValidations, } from './data-validation.js';
-import { applyHyperlinks, parseSheetHyperlinks } from './hyperlinks.js';
+import { conditionalFormattingPass } from './conditional-formatting.js';
+import { applyDataValidations, dataValidationPass, extendedDataValidationPass, } from './data-validation.js';
+import { applyHyperlinks, sheetHyperlinkPass } from './hyperlinks.js';
 import { drawingHasUnmodeledContent, parseDrawing } from './images.js';
 import { parsePivotTable } from './read-pivot.js';
 import { parseSharedStrings } from './read-shared-strings.js';
-import { parseIndexedColors, parseMruColors, parseStyleTable, parseTableStyles, } from './read-styles.js';
-import { parseWorksheet } from './read-worksheet.js';
+import { parseStyleTable } from './read-styles.js';
+import { worksheetPass } from './read-worksheet.js';
 import { parseTable } from './tables.js';
 import { parseThemeColorScheme, parseThemeFontScheme } from './theme-xml.js';
 import { buildCommentThreads, parsePersons, parseThreadedComments } from './threaded-comments.js';
-export { parseRelationships, resolveWorkbookPart } from '../opc/read-opc.js';
-export { DEFAULT_MAX_UNCOMPRESSED } from '../opc/read-options.js';
 export { parseStyleTable } from './read-styles.js';
 export function readXlsx(data, options = {}) {
-    const cap = options.maxUncompressedBytes ?? DEFAULT_MAX_UNCOMPRESSED;
-    const files = inflateSpreadsheetPackage(data, cap);
-    const pkg = packageAccessors(files);
+    const { files, pkg, workbookXml } = openSpreadsheetPackage(data, options.maxUncompressedBytes);
     const { partText } = pkg;
-    const workbookXml = partText('xl/workbook.xml');
     if (workbookXml === undefined) {
         if (files[XLSB_WORKBOOK_PART] !== undefined)
             return readXlsbPackage(files);
         throw new UnsupportedFormatError('unknown');
     }
     const contentTypeOf = contentTypeResolver(partText('[Content_Types].xml') ?? '');
-    const workbookRelsXml = partText('xl/_rels/workbook.xml.rels') ?? '';
-    const rels = parseRelationships(workbookRelsXml);
+    const workbookRels = readPartRelationships('xl/workbook.xml', partText);
     const sharedStrings = parseSharedStrings(partText('xl/sharedStrings.xml') ?? '');
     const stylesXml = partText('xl/styles.xml') ?? '';
-    const { cellXfs: xfStyles, namedStyles, defaultFont } = parseStyleTable(stylesXml);
+    const { cellXfs: xfStyles, namedStyles, defaultFont, preserved } = parseStyleTable(stylesXml);
     const workbook = new Workbook();
-    workbook[INTERNAL].restoreDifferentialStyles(parseDxfs(stylesXml));
-    workbook[INTERNAL].restoreIndexedColors(parseIndexedColors(stylesXml));
-    workbook[INTERNAL].restoreMruColors(parseMruColors(stylesXml));
-    workbook[INTERNAL].restoreTableStyles(parseTableStyles(stylesXml));
-    readWorkbookTheme(workbookRelsXml, pkg, contentTypeOf, workbook);
+    workbook[INTERNAL].restoreDifferentialStyles([...preserved.dxfs]);
+    workbook[INTERNAL].restoreIndexedColors([...preserved.indexedColors]);
+    workbook[INTERNAL].restoreMruColors([...preserved.mruColors]);
+    workbook[INTERNAL].restoreTableStyles(preserved.tableStyles);
+    readWorkbookTheme(workbookRels, pkg, contentTypeOf, workbook);
     if (namedStyles.length > 1)
         workbook[INTERNAL].restoreNamedStyles(namedStyles);
     workbook[INTERNAL].restoreDefaultFont(defaultFont);
@@ -60,53 +53,72 @@ export function readXlsx(data, options = {}) {
         applyAppProperties(workbook, app);
     workbook.protection = parseWorkbookProtection(workbookXml);
     applyWorkbookView(workbook.view, workbookXml);
-    readWorkbookPersons(workbookRelsXml, pkg, workbook);
-    const imageIdByMediaPath = new Map();
+    readWorkbookPersons(workbookRels, pkg, workbook);
+    const context = {
+        pkg,
+        workbook,
+        contentTypeOf,
+        sharedStrings,
+        xfStyles,
+        imageIdByMediaPath: new Map(),
+    };
     const sheetOrder = [];
     for (const { name, relId, state } of parseWorkbookSheets(workbookXml)) {
-        const target = rels.get(relId);
+        const target = workbookRels.byId(relId)?.target;
         const sheet = workbook.addWorksheet(name, state === undefined ? undefined : { state });
         sheetOrder.push(name);
-        const path = target === undefined ? undefined : resolveWorkbookPart(target);
-        const sheetXml = path === undefined ? undefined : partText(path);
-        if (sheetXml !== undefined)
-            parseWorksheet(sheetXml, sheet, sharedStrings, xfStyles);
-        if (path !== undefined) {
-            const sheetRels = readPartRelationships(path, partText);
-            if (sheetXml !== undefined) {
-                applyHyperlinks(sheet, parseSheetHyperlinks(sheetXml), (id) => sheetRels.byId(id)?.target);
-                applyDataValidations(sheet, [
-                    ...parseDataValidations(sheetXml),
-                    ...parseExtendedDataValidations(sheetXml),
-                ]);
-                for (const cf of parseConditionalFormattings(sheetXml))
-                    sheet.addConditionalFormatting(cf);
-            }
-            const threads = readSheetCommentThreads(sheetRels, pkg, workbook);
-            if (threads.length > 0)
-                sheet[INTERNAL].restoreCommentThreads(threads);
-            const comments = readSheetComments(sheetRels, pkg);
-            if (comments !== undefined)
-                applyNotes(sheet, comments);
-            readSheetImages(sheetRels, pkg, workbook, sheet, imageIdByMediaPath);
-            readSheetBackground(sheetRels, pkg, workbook, sheet, imageIdByMediaPath);
-            if (sheetXml !== undefined) {
-                readSheetPreservedReferences(sheetRels, sheetXml, pkg, contentTypeOf, sheet);
-            }
-            readSheetTables(sheetRels, pkg, sheet);
-            readSheetPivotTables(sheetRels, pkg, sheet);
-            const printerSettings = readSheetPrinterSettings(sheetRels, pkg);
-            if (printerSettings !== undefined)
-                sheet.pageSetup.printerSettings = printerSettings;
-        }
+        readSheet(sheet, target === undefined ? undefined : workbookRels.pathOf(target), context);
     }
-    readWorkbookPreservedReferences(workbookXml, pkg, contentTypeOf, workbook);
+    readWorkbookPreservedReferences(workbookXml, workbookRels, pkg, contentTypeOf, workbook);
     readRootPreservedReferences(pkg, contentTypeOf, workbook);
     for (const name of parseWorkbookDefinedNames(workbookXml, sheetOrder)) {
         workbook.defineName(name);
     }
     return workbook;
 }
+function readSheet(sheet, path, context) {
+    const { pkg, workbook, contentTypeOf, sharedStrings, xfStyles, imageIdByMediaPath } = context;
+    const { partText } = pkg;
+    const sheetXml = path === undefined ? undefined : partText(path);
+    const hyperlinks = sheetHyperlinkPass();
+    const validations = dataValidationPass();
+    const extendedValidations = extendedDataValidationPass();
+    const formattings = conditionalFormattingPass();
+    if (sheetXml !== undefined) {
+        parseXmlPasses(sheetXml, [
+            worksheetPass(sheet, sharedStrings, xfStyles),
+            hyperlinks,
+            validations,
+            extendedValidations,
+            formattings,
+        ]);
+    }
+    if (path === undefined)
+        return;
+    const sheetRels = readPartRelationships(path, partText);
+    if (sheetXml !== undefined) {
+        applyHyperlinks(sheet, hyperlinks.result(), (id) => sheetRels.byId(id)?.target);
+        applyDataValidations(sheet, [...validations.result(), ...extendedValidations.result()]);
+        for (const cf of formattings.result())
+            sheet.addConditionalFormatting(cf);
+    }
+    const threads = readSheetCommentThreads(sheetRels, pkg, workbook);
+    if (threads.length > 0)
+        sheet[INTERNAL].restoreCommentThreads(threads);
+    const comments = readSheetComments(sheetRels, pkg);
+    if (comments !== undefined)
+        applyNotes(sheet, comments);
+    readSheetImages(sheetRels, pkg, workbook, sheet, imageIdByMediaPath);
+    readSheetBackground(sheetRels, pkg, workbook, sheet, imageIdByMediaPath);
+    if (sheetXml !== undefined) {
+        readSheetPreservedReferences(sheetRels, sheetXml, pkg, contentTypeOf, sheet);
+    }
+    readSheetTables(sheetRels, pkg, sheet);
+    readSheetPivotTables(sheetRels, pkg, sheet);
+    const printerSettings = readSheetPrinterSettings(sheetRels, pkg);
+    if (printerSettings !== undefined)
+        sheet.pageSetup.printerSettings = printerSettings;
+}
 function readSheetComments(sheetRels, pkg) {
     const commentsPath = sheetRels.targetPath('comments');
     if (commentsPath === undefined)
@@ -116,17 +128,16 @@ function readSheetComments(sheetRels, pkg) {
         return undefined;
     return parseComments(commentsXml);
 }
-function readWorkbookPersons(workbookRelsXml, pkg, workbook) {
-    const target = relationshipTargetByType(workbookRelsXml, 'person');
-    const xml = target === undefined ? undefined : pkg.partText(resolveWorkbookPart(target));
+function readWorkbookPersons(workbookRels, pkg, workbook) {
+    const path = workbookRels.targetPath('person');
+    const xml = path === undefined ? undefined : pkg.partText(path);
     if (xml !== undefined)
         workbook[INTERNAL].restorePersons(parsePersons(xml));
 }
-function readWorkbookTheme(workbookRelsXml, pkg, contentTypeOf, workbook) {
-    const target = relationshipTargetByType(workbookRelsXml, 'theme');
-    if (target === undefined)
+function readWorkbookTheme(workbookRels, pkg, contentTypeOf, workbook) {
+    const entryPath = workbookRels.targetPath('theme');
+    if (entryPath === undefined)
         return;
-    const entryPath = resolveWorkbookPart(target);
     const parts = capturePartClosure(entryPath, pkg.partText, pkg.partBytes, contentTypeOf);
     if (parts === undefined)
         return;
@@ -217,17 +228,14 @@ function readSheetPreservedReferences(sheetRels, sheetXml, pkg, contentTypeOf, s
 function isPreservedSheetRelType(type) {
     return type.endsWith('/pivotTable') || type.endsWith('/slicer');
 }
-function readWorkbookPreservedReferences(workbookXml, pkg, contentTypeOf, workbook) {
+function readWorkbookPreservedReferences(workbookXml, workbookRels, pkg, contentTypeOf, workbook) {
     const { partText, partBytes } = pkg;
-    const relsXml = partText('xl/_rels/workbook.xml.rels');
-    if (relsXml === undefined)
-        return;
     const cacheIdByRelId = parsePivotCacheRegistrations(workbookXml);
     const externalIndexByRelId = parseExternalReferenceRegistrations(workbookXml);
-    for (const record of parseRelationshipRecords(relsXml)) {
+    for (const record of workbookRels.records) {
         if (record.external || !isPreservedWorkbookRelType(record.type))
             continue;
-        const entryPath = resolveWorkbookPart(record.target);
+        const entryPath = workbookRels.pathOf(record.target);
         const parts = capturePartClosure(entryPath, partText, partBytes, contentTypeOf);
         if (parts === undefined)
             continue;

package/dist/io/xlsx/rich-runs.d.ts

@@ -1,5 +1,5 @@
 import type { RichTextRun } from '../../core/value.ts';
-import { type XmlAttributes } from '../../xml/xml-read.ts';
+import { type XmlAttributes } from '../../xml/xml-scan.ts';
 /**
  * What {@link RunAccumulator.close} did with an element: `'container'` means the `<si>`/`<is>` itself
  * closed and the caller should commit whatever it makes of the gathered runs, the one step the two

package/dist/io/xlsx/rich-runs.js

@@ -1,4 +1,5 @@
-import { decodeSpreadsheetText, TextCapture } from '../../xml/xml-read.js';
+import { TextCapture } from '../../xml/xml-read.js';
+import { decodeSpreadsheetText } from '../../xml/xml-scan.js';
 import { applyFontChild } from './read-styles.js';
 export class RunAccumulator {
     #container;

package/dist/io/xlsx/sheet-properties.js

@@ -1,5 +1,5 @@
 import { encodeAddress } from '../../core/address.js';
-import { isPageOrder, isPageOrientation, } from '../../core/page-setup.js';
+import { HEADER_FOOTER_ELEMENTS, MARGIN_SIDES, PAGE_SETUP_FACETS, PRINT_OPTION_FLAGS, } from '../../core/page-setup.js';
 import { SHEET_PROTECTION_FLAGS } from '../../core/protection.js';
 import { boolAttr, checkedToken, escapeAttr, escapeSpreadsheetText, numAttr, numberText, } from '../../xml/xml.js';
 import { colorAttrs } from './color-xml.js';
@@ -80,16 +80,8 @@ function filterCriteriaXml(criteria) {
         .join('');
     return `<customFilters${andAttr}>${predicates}</customFilters>`;
 }
-const HF_CHILDREN = [
-    { tag: 'oddHeader', key: 'oddHeader' },
-    { tag: 'oddFooter', key: 'oddFooter' },
-    { tag: 'evenHeader', key: 'evenHeader' },
-    { tag: 'evenFooter', key: 'evenFooter' },
-    { tag: 'firstHeader', key: 'firstHeader' },
-    { tag: 'firstFooter', key: 'firstFooter' },
-];
 export function headerFooterXml(hf) {
-    const children = HF_CHILDREN.filter(({ key }) => hf[key] !== undefined);
+    const children = HEADER_FOOTER_ELEMENTS.filter((key) => hf[key] !== undefined);
     if (children.length === 0)
         return '';
     const differentOddEven = hf.evenHeader !== undefined || hf.evenFooter !== undefined;
@@ -100,7 +92,7 @@ export function headerFooterXml(hf) {
     if (differentFirst)
         attrs += ' differentFirst="1"';
     const body = children
-        .map(({ tag, key }) => `<${tag}>${escapeSpreadsheetText(hf[key])}</${tag}>`)
+        .map((key) => `<${key}>${escapeSpreadsheetText(hf[key] ?? '')}</${key}>`)
         .join('');
     return `<headerFooter${attrs}>${body}</headerFooter>`;
 }
@@ -112,13 +104,8 @@ const DEFAULT_MARGINS = {
     header: 0.3,
     footer: 0.3,
 };
-const MARGIN_SIDES = ['left', 'right', 'top', 'bottom', 'header', 'footer'];
 export function printOptionsXml(printOptions) {
-    const attrs = boolAttr('horizontalCentered', printOptions.horizontalCentered) +
-        boolAttr('verticalCentered', printOptions.verticalCentered) +
-        boolAttr('headings', printOptions.headings) +
-        boolAttr('gridLines', printOptions.gridLines) +
-        boolAttr('gridLinesSet', printOptions.gridLinesSet);
+    const attrs = PRINT_OPTION_FLAGS.map((flag) => boolAttr(flag, printOptions[flag])).join('');
     return attrs === '' ? '' : `<printOptions${attrs}/>`;
 }
 export function pageMarginsXml(margins) {
@@ -128,17 +115,23 @@ export function pageMarginsXml(margins) {
     return `<pageMargins ${attrs}/>`;
 }
 export function pageSetupXml(pageSetup, printerSettingsRelId) {
-    const attrs = numAttr('paperSize', pageSetup.paperSize) +
-        numAttr('scale', pageSetup.scale) +
-        numAttr('fitToWidth', pageSetup.fitToWidth) +
-        numAttr('fitToHeight', pageSetup.fitToHeight) +
-        (pageSetup.pageOrder === undefined
-            ? ''
-            : ` pageOrder="${checkedToken(pageSetup.pageOrder, isPageOrder, 'page order')}"`) +
-        (pageSetup.orientation === undefined
-            ? ''
-            : ` orientation="${checkedToken(pageSetup.orientation, isPageOrientation, 'page orientation')}"`) +
-        (printerSettingsRelId !== null ? ` r:id="${printerSettingsRelId}"` : '');
+    let attrs = '';
+    for (const facet of PAGE_SETUP_FACETS) {
+        switch (facet.kind) {
+            case 'count':
+                attrs += numAttr(facet.key, pageSetup[facet.key]);
+                break;
+            case 'token': {
+                const value = pageSetup[facet.key];
+                if (value !== undefined) {
+                    attrs += ` ${facet.key}="${checkedToken(value, facet.isValid, facet.label)}"`;
+                }
+                break;
+            }
+        }
+    }
+    if (printerSettingsRelId !== null)
+        attrs += ` r:id="${printerSettingsRelId}"`;
     return attrs === '' ? '' : `<pageSetup${attrs}/>`;
 }
 export function pageBreaksXml(breaks, element) {

package/dist/io/xlsx/styles.js

@@ -1,6 +1,6 @@
-import { isBorderStyle, isFillPatternType, isFontScheme, isFontVerticalAlignment, isHorizontalAlignment, isNamedUnderlineStyle, isVerticalAlignment, } from '../../core/style.js';
+import { ALIGNMENT_FACETS, isBorderStyle, isFillPatternType, isFontScheme, isFontVerticalAlignment, isNamedUnderlineStyle, } from '../../core/style.js';
 import { TABLE_STYLE_ELEMENT_TYPES } from '../../core/table-style.js';
-import { decodeEntities } from '../../xml/xml-read.js';
+import { decodeEntities } from '../../xml/xml-scan.js';
 import { assertRepresentable, checkedToken, escapeAttr, numberText, XML_DECLARATION, } from '../../xml/xml.js';
 import { colorAttrs } from './color-xml.js';
 import { MARKUP_COMPATIBILITY_NS, SPREADSHEETML_NS } from './namespaces.js';
@@ -281,24 +281,27 @@ function cellStyleTag(entry) {
 }
 function alignmentAttrs(alignment) {
     const parts = [];
-    if (alignment.horizontal !== undefined && alignment.horizontal !== 'general') {
-        parts.push(`horizontal="${checkedToken(alignment.horizontal, isHorizontalAlignment, 'horizontal alignment')}"`);
-    }
-    if (alignment.vertical !== undefined) {
-        parts.push(`vertical="${checkedToken(alignment.vertical, isVerticalAlignment, 'vertical alignment')}"`);
-    }
-    if (alignment.textRotation !== undefined && alignment.textRotation !== 0) {
-        parts.push(`textRotation="${numberText(alignment.textRotation)}"`);
-    }
-    if (alignment.wrapText)
-        parts.push('wrapText="1"');
-    if (alignment.indent !== undefined && alignment.indent !== 0) {
-        parts.push(`indent="${numberText(alignment.indent)}"`);
-    }
-    if (alignment.shrinkToFit)
-        parts.push('shrinkToFit="1"');
-    if (alignment.readingOrder !== undefined && alignment.readingOrder !== 0) {
-        parts.push(`readingOrder="${numberText(alignment.readingOrder)}"`);
+    for (const facet of ALIGNMENT_FACETS) {
+        switch (facet.kind) {
+            case 'token': {
+                const value = alignment[facet.key];
+                if (value === undefined || value === facet.omit)
+                    break;
+                parts.push(`${facet.key}="${checkedToken(value, facet.isValid, facet.label)}"`);
+                break;
+            }
+            case 'number': {
+                const value = alignment[facet.key];
+                if (value === undefined || value === 0)
+                    break;
+                parts.push(`${facet.key}="${numberText(value)}"`);
+                break;
+            }
+            case 'flag':
+                if (alignment[facet.key])
+                    parts.push(`${facet.key}="1"`);
+                break;
+        }
     }
     return parts.join(' ');
 }

package/dist/io/xlsx/tables.js

@@ -1,6 +1,7 @@
 import { encodeAddress, tryDecodeRange } from '../../core/address.js';
 import { isTotalsRowFunction, } from '../../core/table.js';
-import { boolPresent, localName, numInteger, parseXml, TextCapture } from '../../xml/xml-read.js';
+import { parseXml, TextCapture } from '../../xml/xml-read.js';
+import { boolPresent, localName, numInteger } from '../../xml/xml-scan.js';
 import { boolAttr, escapeAttr, escapeText, XML_DECLARATION } from '../../xml/xml.js';
 import { NS } from './relationships.js';
 export function tableXml(table, id) {

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

@@ -1,5 +1,5 @@
 import { DEFAULT_THEME_COLOR_SCHEME, isThemeColorSlot, normalizeThemeColor, } from '../../core/theme.js';
-import { decodeEntities } from '../../xml/xml-read.js';
+import { decodeEntities } from '../../xml/xml-scan.js';
 import { escapeAttr } from '../../xml/xml.js';
 const SCHEME_SLOT = new RegExp('<a:(dk1|lt1|dk2|lt2|accent[1-6]|hlink|folHlink)\\b[^>]*>' + '\\s*<a:(srgbClr|sysClr)\\b([^>]*)>', 'g');
 export function parseThemeColorScheme(themeXml) {

package/dist/io/xlsx/threaded-comments.js

@@ -1,6 +1,7 @@
 import { encodeAddress, tryDecodeCellRef } from '../../core/address.js';
 import { MENTION_OFFSET_MAX, } from '../../core/comment-thread.js';
-import { boolStrict, decodeSpreadsheetText, localName, numInteger, parseXml, TextCapture, } from '../../xml/xml-read.js';
+import { parseXml, TextCapture } from '../../xml/xml-read.js';
+import { boolStrict, decodeSpreadsheetText, localName, numInteger, } from '../../xml/xml-scan.js';
 import { escapeAttr, escapeSpreadsheetText, textAttr, XML_DECLARATION } from '../../xml/xml.js';
 import { THREADED_COMMENTS_NS } from './namespaces.js';
 export function parsePersons(xml) {

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

@@ -2,10 +2,11 @@ import { mangleFormula, quoteSheetName } from '../../core/formula.js';
 import { WORKBOOK_PROTECTION_CREDENTIAL_ATTRS } from '../../core/workbook-protection.js';
 import { isVisibility } from '../../core/worksheet.js';
 import { checkedToken, escapeAttr, escapeText, numAttr, textAttr, XML_DECLARATION, } from '../../xml/xml.js';
-import { extensionOf, relativePartPath, THEME_PART_PATH } from '../opc/part-paths.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 = {
@@ -72,37 +73,37 @@ 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'),
+        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)),
     ]);
 }
@@ -221,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,4 +1,5 @@
 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';
@@ -6,12 +7,12 @@ 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 { assertWritableNumber, escapeAttr, escapeSpreadsheetText, escapeText, numberText, textAttr, textElement, XML_DECLARATION, } from '../../xml/xml.js';
-import { relativePartPath } from '../opc/part-paths.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';
@@ -115,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 };
@@ -204,33 +205,35 @@ 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, link.target, {
@@ -409,11 +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_STYLE_FACETS.some((facet) => cell[facet] !== undefined) ||
-        cell.quotePrefix === true ||
-        cell[NAMED_STYLE_ID] !== undefined);
-}
 function cellFormulaXml(ref, s, value, shared) {
     if (shared !== undefined) {
         if (shared.ref !== undefined && isFormulaValue(value)) {

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

@@ -172,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>;
 }