@shbernal/ts-xlsx 2.1.0 → 3.0.0

package/dist/io/xlsx/part-names.js

@@ -0,0 +1,46 @@
+import { relativePartPath } from '../opc/part-paths.js';
+export const WORKBOOK_PART = 'xl/workbook.xml';
+export const STYLES_PART = 'xl/styles.xml';
+export const SHARED_STRINGS_PART = 'xl/sharedStrings.xml';
+export const PERSONS_PART = 'xl/persons/person.xml';
+export const CORE_PROPS_PART = 'docProps/core.xml';
+export const APP_PROPS_PART = 'docProps/app.xml';
+export function worksheetPart(number) {
+    return `xl/worksheets/sheet${number}.xml`;
+}
+export function tablePart(number) {
+    return `xl/tables/table${number}.xml`;
+}
+export function mediaPart(number, extension) {
+    return `xl/media/image${number}.${extension}`;
+}
+export function drawingPart(number) {
+    return `xl/drawings/drawing${number}.xml`;
+}
+export function vmlDrawingPart(number) {
+    return `xl/drawings/vmlDrawing${number}.vml`;
+}
+export function commentsPart(number) {
+    return `xl/comments${number}.xml`;
+}
+export function threadedCommentsPart(number) {
+    return `xl/threadedComments/threadedComment${number}.xml`;
+}
+export function printerSettingsPart(number) {
+    return `xl/printerSettings/printerSettings${number}.bin`;
+}
+export function pivotTablePart(number) {
+    return `xl/pivotTables/pivotTable${number}.xml`;
+}
+export function pivotCacheDefinitionPart(number) {
+    return `xl/pivotCache/pivotCacheDefinition${number}.xml`;
+}
+export function pivotCacheRecordsPart(number) {
+    return `xl/pivotCache/pivotCacheRecords${number}.xml`;
+}
+export function targetFromWorksheet(partPath) {
+    return relativePartPath(worksheetPart(1), partPath);
+}
+export function targetFromWorkbook(partPath) {
+    return relativePartPath(WORKBOOK_PART, partPath);
+}

package/dist/io/xlsx/read-pivot.js

@@ -1,5 +1,6 @@
 import { isDeclarablePivotSourceKind, pivotMetricFromSubtotal, } from '../../core/pivot-table.js';
-import { localName, numInteger, parseXml } from '../../xml/xml-read.js';
+import { parseXml } from '../../xml/xml-read.js';
+import { localName, numInteger } from '../../xml/xml-scan.js';
 export function parsePivotTable(tableXml, cacheXml) {
     const { fields, source } = parsePivotCacheDefinition(cacheXml);
     const def = parsePivotTableDefinition(tableXml);

package/dist/io/xlsx/read-rows.js

@@ -1,12 +1,13 @@
 import { MAX_COLUMN, MAX_ROW } from '../../core/address.js';
 import { AuthoringError } from '../../errors.js';
-import { boolStrict, closeEmptyElements, localName, numInteger, xmlEvents, } from '../../xml/xml-read.js';
-import { packageAccessors } from '../opc/read-opc.js';
-import { inflateSpreadsheetPackage, unsupportedWorkbookPart } from '../opc/sniff-format.js';
+import { closeEmptyElements } from '../../xml/xml-read.js';
+import { boolStrict, localName, numInteger, xmlEvents } from '../../xml/xml-scan.js';
+import { openSpreadsheetPackage, readPartRelationships } from '../opc/read-opc.js';
+import { unsupportedWorkbookPart } from '../opc/sniff-format.js';
 import { CellAccumulator } from './cell-accumulator.js';
 import { XlsxParseError } from './errors.js';
 import { parseSharedStrings } from './read-shared-strings.js';
-import { DEFAULT_MAX_UNCOMPRESSED, parseRelationships, parseStyleTable, parseWorkbookSheets, resolveWorkbookPart, } from './read.js';
+import { parseStyleTable, parseWorkbookSheets, } from './read.js';
 export function* readSheetRows(data, options = {}) {
     const pkg = openPackage(data, options.maxUncompressedBytes);
     const chosen = pickSheet(pkg.sheets, options.sheet);
@@ -23,14 +24,13 @@ export function* readWorkbookStream(data, options = {}) {
     }
 }
 function openPackage(data, maxUncompressedBytes) {
-    const cap = maxUncompressedBytes ?? DEFAULT_MAX_UNCOMPRESSED;
-    const { partText: text } = packageAccessors(inflateSpreadsheetPackage(data, cap));
-    const workbookXml = text('xl/workbook.xml');
+    const { pkg, workbookXml } = openSpreadsheetPackage(data, maxUncompressedBytes);
+    const { partText: text } = pkg;
     if (workbookXml === undefined) {
         throw unsupportedWorkbookPart(text, 'the binary .xlsb format (BIFF12) cannot be row-streamed yet; read it with readXlsx or readXlsb');
     }
     const sheets = parseWorkbookSheets(workbookXml);
-    const rels = parseRelationships(text('xl/_rels/workbook.xml.rels') ?? '');
+    const rels = readPartRelationships('xl/workbook.xml', text);
     const sharedStrings = parseSharedStrings(text('xl/sharedStrings.xml') ?? '');
     const { cellXfs: xfStyles } = parseStyleTable(text('xl/styles.xml') ?? '');
     return {
@@ -38,9 +38,8 @@ function openPackage(data, maxUncompressedBytes) {
         sharedStrings,
         xfStyles,
         sheetXml(relId) {
-            const target = rels.get(relId);
-            const path = target === undefined ? undefined : resolveWorkbookPart(target);
-            return path === undefined ? undefined : text(path);
+            const target = rels.byId(relId)?.target;
+            return target === undefined ? undefined : text(rels.pathOf(target));
         },
     };
 }
@@ -88,7 +87,7 @@ class StreamedSheetReader {
     }
     get merges() {
         this.#ensureScanned();
-        return this.#merges;
+        return [...this.#merges];
     }
     #ensureScanned() {
         if (this.#scanned)
@@ -156,7 +155,7 @@ function* scanSheet(xml, sharedStrings, xfStyles, hiddenColumns, merges) {
     }
 }
 function collectHiddenColumn(attrs, hiddenColumns) {
-    if (attrs.hidden !== '1' && attrs.hidden !== 'true')
+    if (!boolStrict(attrs.hidden))
         return;
     const min = numInteger(attrs.min, 1);
     const max = numInteger(attrs.max, 1);

package/dist/io/xlsx/read-shared-strings.js

@@ -1,4 +1,5 @@
-import { localName, parseXml } from '../../xml/xml-read.js';
+import { parseXml } from '../../xml/xml-read.js';
+import { localName } from '../../xml/xml-scan.js';
 import { RunAccumulator } from './rich-runs.js';
 export function parseSharedStrings(xml) {
     if (xml === '')

package/dist/io/xlsx/read-styles.d.ts

@@ -1,5 +1,5 @@
 import { type Font, type TableStyleTable } from '../../core/style.ts';
-import { type XmlAttributes } from '../../xml/xml-read.ts';
+import { type XmlAttributes } from '../../xml/xml-scan.ts';
 import { type StyleTable } from '../style/xf-style.ts';
 export type FontDraft = {
     -readonly [K in keyof Font]?: Font[K];

package/dist/io/xlsx/read-styles.js

@@ -1,6 +1,7 @@
-import { isBorderStyle, isFillPatternType, isFontScheme, isFontVerticalAlignment, isHorizontalAlignment, isNamedUnderlineStyle, isVerticalAlignment, } from '../../core/style.js';
-import { boolPresent, boolStrict, closeEmptyElements, localName, numFinite, numInteger, openElements, xmlEvents, } from '../../xml/xml-read.js';
-import { numFmtCodeFor, resolveStyleTable, } from '../style/xf-style.js';
+import { ALIGNMENT_FACETS, isBorderStyle, isFillPatternType, isFontScheme, isFontVerticalAlignment, isNamedUnderlineStyle, } from '../../core/style.js';
+import { closeEmptyElements, elementSubtrees, openElements, } from '../../xml/xml-read.js';
+import { boolPresent, boolStrict, boolTristate, localName, numFinite, numInteger, xmlEvents, } from '../../xml/xml-scan.js';
+import { NO_PRESERVED_STYLE_TABLES, numFmtCodeFor, resolveStyleTable, } from '../style/xf-style.js';
 import { parseColor } from './color-xml.js';
 const BORDER_EDGE_NAMES = ['left', 'right', 'top', 'bottom', 'diagonal'];
 const BORDER_EDGES = new Set(BORDER_EDGE_NAMES);
@@ -15,7 +16,7 @@ const STYLE_EMPTY_CLOSES = new Set([
 ]);
 export function parseStyleTable(xml) {
     if (xml === '')
-        return { cellXfs: [], namedStyles: [] };
+        return { cellXfs: [], namedStyles: [], preserved: NO_PRESERVED_STYLE_TABLES };
     let fills = [];
     let fonts = [];
     let borders = [];
@@ -54,7 +55,17 @@ export function parseStyleTable(xml) {
         }
         next = events.next();
     }
-    return resolveStyleTable({ directXfs: xfStyles, namedXfs, labels: cellStyleNames, fonts });
+    const { fragments, attributes } = elementSubtrees(xml, PRESERVED_SUBTREES);
+    const preserved = {
+        dxfs: fragments.get('dxfs') ?? [],
+        indexedColors: fragments.get('indexedColors') ?? [],
+        mruColors: fragments.get('mruColors') ?? [],
+        tableStyles: buildTableStyleTable(xml, fragments.get('tableStyles') ?? [], attributes.get('tableStyles')),
+    };
+    return {
+        ...resolveStyleTable({ directXfs: xfStyles, namedXfs, labels: cellStyleNames, fonts }),
+        preserved,
+    };
 }
 function* until(events, container) {
     let next = events.next();
@@ -389,53 +400,58 @@ function borderToStyle(draft) {
 }
 function parseAlignment(attrs) {
     const out = {};
-    if (attrs.horizontal !== undefined &&
-        attrs.horizontal !== 'general' &&
-        isHorizontalAlignment(attrs.horizontal)) {
-        out.horizontal = attrs.horizontal;
+    for (const facet of ALIGNMENT_FACETS) {
+        const raw = attrs[facet.key];
+        switch (facet.kind) {
+            case 'token':
+                if (raw !== undefined && raw !== facet.omit && facet.isValid(raw)) {
+                    assignAlignmentToken(out, facet.key, raw);
+                }
+                break;
+            case 'number': {
+                const value = numFinite(raw);
+                if (value !== undefined && value !== 0)
+                    out[facet.key] = value;
+                break;
+            }
+            case 'flag':
+                if (boolStrict(raw))
+                    out[facet.key] = true;
+                break;
+        }
     }
-    if (attrs.vertical !== undefined && isVerticalAlignment(attrs.vertical))
-        out.vertical = attrs.vertical;
-    const rotation = numFinite(attrs.textRotation);
-    if (rotation !== undefined && rotation !== 0)
-        out.textRotation = rotation;
-    if (boolStrict(attrs.wrapText))
-        out.wrapText = true;
-    const indent = numInteger(attrs.indent);
-    if (indent !== undefined && indent !== 0)
-        out.indent = indent;
-    if (boolStrict(attrs.shrinkToFit))
-        out.shrinkToFit = true;
-    const order = numInteger(attrs.readingOrder);
-    if (order !== undefined && order !== 0)
-        out.readingOrder = order;
     return Object.keys(out).length > 0 ? out : undefined;
 }
+function assignAlignmentToken(out, key, raw) {
+    out[key] = raw;
+}
 function parseProtection(attrs) {
     const out = {};
-    if (attrs.locked === '0' || attrs.locked === 'false')
+    if (boolTristate(attrs.locked) === false)
         out.locked = false;
     if (boolStrict(attrs.hidden))
         out.hidden = true;
     return Object.keys(out).length > 0 ? out : undefined;
 }
 export function parseIndexedColors(stylesXml) {
-    return elementFragments(stylesXml, 'indexedColors', 'rgbColor');
+    return capturedFragments(stylesXml, 'indexedColors');
 }
 export function parseMruColors(stylesXml) {
-    return elementFragments(stylesXml, 'mruColors', 'color');
+    return capturedFragments(stylesXml, 'mruColors');
 }
 export function parseTableStyles(stylesXml) {
-    const styles = elementFragments(stylesXml, 'tableStyles', 'tableStyle');
-    const table = { styles };
-    for (const { attrs } of openElements(stylesXml, 'tableStyles')) {
-        if (attrs.defaultTableStyle !== undefined)
-            table.defaultTableStyle = attrs.defaultTableStyle;
-        if (attrs.defaultPivotStyle !== undefined)
-            table.defaultPivotStyle = attrs.defaultPivotStyle;
-        break;
+    const { fragments, attributes } = elementSubtrees(stylesXml, new Map([['tableStyles', 'tableStyle']]));
+    return buildTableStyleTable(stylesXml, fragments.get('tableStyles') ?? [], attributes.get('tableStyles'));
+}
+function buildTableStyleTable(stylesXml, styles, containerAttrs) {
+    const table = { styles: [...styles] };
+    if (containerAttrs?.defaultTableStyle !== undefined) {
+        table.defaultTableStyle = containerAttrs.defaultTableStyle;
     }
-    const namespaces = fragmentNamespaces(stylesXml, styles);
+    if (containerAttrs?.defaultPivotStyle !== undefined) {
+        table.defaultPivotStyle = containerAttrs.defaultPivotStyle;
+    }
+    const namespaces = fragmentNamespaces(stylesXml, table.styles);
     if (namespaces.length > 0)
         table.namespaces = namespaces;
     return table;
@@ -470,11 +486,16 @@ function fragmentNamespaces(stylesXml, fragments) {
         ignorable: ignorable.has(prefix),
     }));
 }
-function elementFragments(xml, container, child) {
-    const block = new RegExp(`<${container}\\b[^>]*>([\\s\\S]*?)</${container}>`).exec(xml);
-    if (block === null)
+const PRESERVED_SUBTREES = new Map([
+    ['dxfs', 'dxf'],
+    ['indexedColors', 'rgbColor'],
+    ['mruColors', 'color'],
+    ['tableStyles', 'tableStyle'],
+]);
+function capturedFragments(xml, container) {
+    const child = PRESERVED_SUBTREES.get(container);
+    if (child === undefined)
         return [];
-    const inner = block[1] ?? '';
-    const pattern = new RegExp(`<${child}\\b[^>]*/>|<${child}\\b[^>]*>[\\s\\S]*?</${child}>`, 'g');
-    return [...inner.matchAll(pattern)].map((m) => m[0] ?? '');
+    const { fragments } = elementSubtrees(xml, new Map([[container, child]]));
+    return [...(fragments.get(container) ?? [])];
 }

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

@@ -1,4 +1,13 @@
 import type { Worksheet } from '../../core/worksheet.ts';
+import { type SaxPass } from '../../xml/xml-read.ts';
 import type { XfStyle } from '../style/xf-style.ts';
 import type { SharedString } from './cell-value.ts';
-export declare function parseWorksheet(xml: string, sheet: Worksheet, sharedStrings: readonly SharedString[], xfStyles: ReadonlyArray<XfStyle>): void;
+/**
+ * A pass reading a worksheet part into `sheet`: cells and their styles, the column and row metadata,
+ * merges, the autofilter, page breaks, and the view and print layout. It commits as it goes rather
+ * than gathering, so it has nothing to hand back once the parse ends.
+ *
+ * Offered as a pass because the worksheet is the largest part in a package and four other readers
+ * want the same events, so the five share one parse of it rather than scanning it once each.
+ */
+export declare function worksheetPass(sheet: Worksheet, sharedStrings: readonly SharedString[], xfStyles: ReadonlyArray<XfStyle>): SaxPass;

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

@@ -1,13 +1,17 @@
 import { MAX_COLUMN, MAX_ROW, tryDecodeRange } from '../../core/address.js';
 import { isCustomFilterOperator, } from '../../core/autofilter.js';
 import { INTERNAL } from '../../core/internal.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 { assignStyleFacets } from '../../core/style.js';
-import { boolPresent, boolStrict, boolTristate, decodeSpreadsheetText, enumToken, localName, numFinite, numInteger, parseXml, } from '../../xml/xml-read.js';
+import {} from '../../xml/xml-read.js';
+import { boolPresent, boolStrict, boolTristate, decodeSpreadsheetText, localName, numFinite, numInteger, } from '../../xml/xml-scan.js';
 import { CellAccumulator } from './cell-accumulator.js';
 import { parseColor } from './color-xml.js';
-const MARGIN_SIDES = ['left', 'right', 'top', 'bottom', 'header', 'footer'];
+const HEADER_FOOTER_CHILDREN = new Set(HEADER_FOOTER_ELEMENTS);
+function isHeaderFooterElement(local) {
+    return HEADER_FOOTER_CHILDREN.has(local);
+}
 const WORKSHEET_EMPTY_CLOSES = new Set(['c', 'autoFilter']);
 function pendingFilterCriteria(values, blank, predicates, and) {
     if (values !== null && (values.length > 0 || blank)) {
@@ -19,7 +23,7 @@ function pendingFilterCriteria(values, blank, predicates, and) {
     return null;
 }
 function parseSheetProtection(attrs) {
-    if (attrs.sheet === '0' || attrs.sheet === 'false')
+    if (boolTristate(attrs.sheet) === false)
         return undefined;
     const flags = {};
     for (const { key } of SHEET_PROTECTION_FLAGS) {
@@ -125,7 +129,7 @@ class PageBreakAccumulator {
         this.#target.push(brk);
     }
 }
-export function parseWorksheet(xml, sheet, sharedStrings, xfStyles) {
+export function worksheetPass(sheet, sharedStrings, xfStyles) {
     const cell = new CellAccumulator({ richRuns: true });
     let rowStyle = -1;
     let rowCustomFormat = false;
@@ -141,11 +145,15 @@ export function parseWorksheet(xml, sheet, sharedStrings, xfStyles) {
         const style = styleIndex >= 0 ? xfStyles[styleIndex] : xfStyles[0];
         cell.finalize(sheet, sharedStrings, style);
     };
-    parseXml(xml, {
+    const handlers = {
         onOpen(name, attrs, selfClosing) {
             const local = localName(name);
             if (cell.openElement(local, attrs, selfClosing))
                 return;
+            if (HEADER_FOOTER_CHILDREN.has(local)) {
+                cell.capture();
+                return;
+            }
             switch (local) {
                 case 'col':
                     applyColumn(sheet, attrs, xfStyles, columnStyle);
@@ -155,14 +163,6 @@ export function parseWorksheet(xml, sheet, sharedStrings, xfStyles) {
                     rowStyle = numInteger(attrs.s, 0) ?? -1;
                     rowCustomFormat = boolStrict(attrs.customFormat);
                     break;
-                case 'oddHeader':
-                case 'oddFooter':
-                case 'evenHeader':
-                case 'evenFooter':
-                case 'firstHeader':
-                case 'firstFooter':
-                    cell.capture();
-                    break;
                 case 'mergeCell':
                     if (attrs.ref !== undefined && attrs.ref !== '') {
                         try {
@@ -229,15 +229,11 @@ export function parseWorksheet(xml, sheet, sharedStrings, xfStyles) {
             }
             if (claimed === 'claimed')
                 return;
+            if (isHeaderFooterElement(local)) {
+                sheet.headerFooter[local] = decodeSpreadsheetText(cell.capturedText);
+                return;
+            }
             switch (local) {
-                case 'oddHeader':
-                case 'oddFooter':
-                case 'evenHeader':
-                case 'evenFooter':
-                case 'firstHeader':
-                case 'firstFooter':
-                    sheet.headerFooter[local] = decodeSpreadsheetText(cell.capturedText);
-                    break;
                 case 'row':
                     rowStyle = -1;
                     rowCustomFormat = false;
@@ -256,7 +252,8 @@ export function parseWorksheet(xml, sheet, sharedStrings, xfStyles) {
                     break;
             }
         },
-    }, { closeEmptyElements: WORKSHEET_EMPTY_CLOSES });
+    };
+    return { handlers, closeEmptyElements: WORKSHEET_EMPTY_CLOSES };
 }
 function applySheetProperties(local, attrs, sheet) {
     switch (local) {
@@ -346,21 +343,11 @@ function applyRow(sheet, attrs) {
         row.collapsed = true;
 }
 function applyPrintOptions(printOptions, attrs) {
-    const horizontalCentered = boolTristate(attrs.horizontalCentered);
-    if (horizontalCentered !== undefined)
-        printOptions.horizontalCentered = horizontalCentered;
-    const verticalCentered = boolTristate(attrs.verticalCentered);
-    if (verticalCentered !== undefined)
-        printOptions.verticalCentered = verticalCentered;
-    const headings = boolTristate(attrs.headings);
-    if (headings !== undefined)
-        printOptions.headings = headings;
-    const gridLines = boolTristate(attrs.gridLines);
-    if (gridLines !== undefined)
-        printOptions.gridLines = gridLines;
-    const gridLinesSet = boolTristate(attrs.gridLinesSet);
-    if (gridLinesSet !== undefined)
-        printOptions.gridLinesSet = gridLinesSet;
+    for (const flag of PRINT_OPTION_FLAGS) {
+        const value = boolTristate(attrs[flag]);
+        if (value !== undefined)
+            printOptions[flag] = value;
+    }
 }
 function applyMargins(margins, attrs) {
     for (const side of MARGIN_SIDES) {
@@ -370,22 +357,22 @@ function applyMargins(margins, attrs) {
     }
 }
 function applyPageSetup(pageSetup, attrs) {
-    const paperSize = numInteger(attrs.paperSize, 0);
-    if (paperSize !== undefined)
-        pageSetup.paperSize = paperSize;
-    const scale = numInteger(attrs.scale, 0);
-    if (scale !== undefined)
-        pageSetup.scale = scale;
-    const fitToWidth = numInteger(attrs.fitToWidth, 0);
-    if (fitToWidth !== undefined)
-        pageSetup.fitToWidth = fitToWidth;
-    const fitToHeight = numInteger(attrs.fitToHeight, 0);
-    if (fitToHeight !== undefined)
-        pageSetup.fitToHeight = fitToHeight;
-    const pageOrder = enumToken(attrs.pageOrder, isPageOrder);
-    if (pageOrder !== undefined)
-        pageSetup.pageOrder = pageOrder;
-    const orientation = enumToken(attrs.orientation, isPageOrientation);
-    if (orientation !== undefined)
-        pageSetup.orientation = orientation;
+    for (const facet of PAGE_SETUP_FACETS) {
+        const raw = attrs[facet.key];
+        switch (facet.kind) {
+            case 'count': {
+                const value = numInteger(raw, 0);
+                if (value !== undefined)
+                    pageSetup[facet.key] = value;
+                break;
+            }
+            case 'token':
+                if (raw !== undefined && facet.isValid(raw))
+                    assignPageSetupToken(pageSetup, facet.key, raw);
+                break;
+        }
+    }
+}
+function assignPageSetupToken(pageSetup, key, raw) {
+    pageSetup[key] = raw;
 }

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

@@ -1,8 +1,7 @@
 import { Workbook, type WorkbookView } from '../../core/workbook.ts';
 import { type WorksheetState } from '../../core/worksheet.ts';
-import { type ReadXlsxOptions } from '../opc/read-options.ts';
-export { parseRelationships, resolveWorkbookPart } from '../opc/read-opc.ts';
-export { DEFAULT_MAX_UNCOMPRESSED, type ReadXlsxOptions } from '../opc/read-options.ts';
+import type { ReadXlsxOptions } from '../opc/read-options.ts';
+export type { ReadXlsxOptions } from '../opc/read-options.ts';
 export type { StyleTable, XfStyle } from '../style/xf-style.ts';
 export { parseStyleTable } from './read-styles.ts';
 /**