@shbernal/ts-xlsx 3.0.0 → 3.1.0

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

@@ -1,42 +1,50 @@
-import { MAX_COLUMN, MAX_ROW } from '../../core/address.js';
-import { AuthoringError } from '../../errors.js';
-import { closeEmptyElements } from '../../xml/xml-read.js';
-import { boolStrict, localName, numInteger, xmlEvents } from '../../xml/xml-scan.js';
+import { Workbook } from '../../core/workbook.js';
+import { AuthoringError, quoted } from '../../errors.js';
+import { closeEmptyElements, parseXmlPasses } from '../../xml/xml-read.js';
+import { boolStrict, localName, 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 { CellStyleResolver } from './cell-style-resolution.js';
+import { ColumnRecordBudget, takeColumnSpan } from './column-budget.js';
 import { XlsxParseError } from './errors.js';
+import { SHARED_STRINGS_PART, STYLES_PART } from './part-names.js';
 import { parseSharedStrings } from './read-shared-strings.js';
-import { parseStyleTable, parseWorkbookSheets, } from './read.js';
+import { workbookPropertiesPass, parseStyleTable, workbookSheetsPass, } from './read.js';
+import { RowPositionTracker } from './row-position.js';
 export function* readSheetRows(data, options = {}) {
     const pkg = openPackage(data, options.maxUncompressedBytes);
     const chosen = pickSheet(pkg.sheets, options.sheet);
     const sheetXml = pkg.sheetXml(chosen.relId);
     if (sheetXml === undefined)
         return;
-    yield* scanSheet(sheetXml, pkg.sharedStrings, pkg.xfStyles, new Set(), []);
+    yield* scanSheet(sheetXml, pkg.sharedStrings, pkg.xfStyles, pkg.dateEpoch, new Set(), []);
 }
 export function* readWorkbookStream(data, options = {}) {
     const pkg = openPackage(data, options.maxUncompressedBytes);
     for (const sheet of pkg.sheets) {
         const xml = pkg.sheetXml(sheet.relId) ?? '';
-        yield new StreamedSheetReader(sheet.name, xml, pkg.sharedStrings, pkg.xfStyles);
+        yield new StreamedSheetReader(sheet.name, xml, pkg.sharedStrings, pkg.xfStyles, pkg.dateEpoch);
     }
 }
 function openPackage(data, maxUncompressedBytes) {
-    const { pkg, workbookXml } = openSpreadsheetPackage(data, maxUncompressedBytes);
-    const { partText: text } = pkg;
+    const { pkg, documentPath, workbookXml } = openSpreadsheetPackage(data, maxUncompressedBytes);
+    const { partText: text, partBytes } = pkg;
     if (workbookXml === undefined) {
-        throw unsupportedWorkbookPart(text, 'the binary .xlsb format (BIFF12) cannot be row-streamed yet; read it with readXlsx or readXlsb');
+        throw unsupportedWorkbookPart(partBytes, documentPath, 'the binary .xlsb format (BIFF12) cannot be row-streamed yet; read it with readXlsx or readXlsb');
     }
-    const sheets = parseWorkbookSheets(workbookXml);
-    const rels = readPartRelationships('xl/workbook.xml', text);
-    const sharedStrings = parseSharedStrings(text('xl/sharedStrings.xml') ?? '');
-    const { cellXfs: xfStyles } = parseStyleTable(text('xl/styles.xml') ?? '');
+    const properties = new Workbook();
+    const sheetsPass = workbookSheetsPass();
+    parseXmlPasses(workbookXml, [sheetsPass, workbookPropertiesPass(properties)]);
+    const sheets = sheetsPass.result();
+    const rels = readPartRelationships(documentPath, text);
+    const sharedStrings = parseSharedStrings(rels.relatedTextOrPath('sharedStrings', SHARED_STRINGS_PART));
+    const { cellXfs: xfStyles } = parseStyleTable(rels.relatedTextOrPath('styles', STYLES_PART));
     return {
         sheets,
         sharedStrings,
         xfStyles,
+        dateEpoch: properties.dateEpoch,
         sheetXml(relId) {
             const target = rels.byId(relId)?.target;
             return target === undefined ? undefined : text(rels.pathOf(target));
@@ -57,7 +65,7 @@ function pickSheet(sheets, selector) {
     }
     const sheet = sheets.find((candidate) => candidate.name === selector);
     if (sheet === undefined)
-        throw new AuthoringError(`no worksheet named ${JSON.stringify(selector)}`);
+        throw new AuthoringError(`no worksheet named ${quoted(selector)}`);
     return sheet;
 }
 class StreamedSheetReader {
@@ -65,20 +73,22 @@ class StreamedSheetReader {
     #xml;
     #sharedStrings;
     #xfStyles;
+    #dateEpoch;
     #hiddenColumns = new Set();
     #merges = [];
     #scanned = false;
-    constructor(name, xml, sharedStrings, xfStyles) {
+    constructor(name, xml, sharedStrings, xfStyles, dateEpoch) {
         this.name = name;
         this.#xml = xml;
         this.#sharedStrings = sharedStrings;
         this.#xfStyles = xfStyles;
+        this.#dateEpoch = dateEpoch;
     }
     *rows() {
         this.#hiddenColumns = new Set();
         this.#merges = [];
         this.#scanned = false;
-        yield* scanSheet(this.#xml, this.#sharedStrings, this.#xfStyles, this.#hiddenColumns, this.#merges);
+        yield* scanSheet(this.#xml, this.#sharedStrings, this.#xfStyles, this.#dateEpoch, this.#hiddenColumns, this.#merges);
         this.#scanned = true;
     }
     get hiddenColumns() {
@@ -97,17 +107,20 @@ class StreamedSheetReader {
     }
 }
 const CELL_EMPTY_CLOSE = new Set(['c']);
-function* scanSheet(xml, sharedStrings, xfStyles, hiddenColumns, merges) {
+function* scanSheet(xml, sharedStrings, xfStyles, dateEpoch, hiddenColumns, merges) {
     let rowNumber = 0;
-    let lastRow = 0;
     let rowHidden = false;
     let rowInGrid = true;
     let cells = [];
-    const cell = new CellAccumulator({ richRuns: false });
+    const columnBudget = new ColumnRecordBudget();
+    const styleResolution = new CellStyleResolver();
+    const rowPosition = new RowPositionTracker();
+    const cell = new CellAccumulator({ richRuns: false, dateEpoch });
     const finalizeCell = () => {
         if (cell.ref === '' || cell.col < 0 || !rowInGrid)
             return;
-        const style = cell.styleIndex >= 0 ? xfStyles[cell.styleIndex] : undefined;
+        const styleIndex = styleResolution.indexFor(cell.col, cell.styleIndex);
+        const style = styleIndex >= 0 ? xfStyles[styleIndex] : undefined;
         const value = cell.decode(sharedStrings, style);
         if (value !== null) {
             const { col, ref } = cell;
@@ -125,15 +138,15 @@ function* scanSheet(xml, sharedStrings, xfStyles, hiddenColumns, merges) {
                 continue;
             switch (local) {
                 case 'row': {
-                    rowNumber = numInteger(event.attrs.r, 1) ?? lastRow + 1;
-                    lastRow = rowNumber;
-                    rowInGrid = rowNumber <= MAX_ROW;
+                    ({ number: rowNumber, inGrid: rowInGrid } = rowPosition.open(event.attrs));
                     rowHidden = boolStrict(event.attrs.hidden);
+                    cell.openRow(rowInGrid ? rowNumber : -1);
+                    styleResolution.openRow(event.attrs);
                     cells = [];
                     break;
                 }
                 case 'col':
-                    collectHiddenColumn(event.attrs, hiddenColumns);
+                    collectColumn(event.attrs, hiddenColumns, styleResolution, columnBudget);
                     break;
                 case 'mergeCell':
                     if (event.attrs.ref !== undefined)
@@ -149,19 +162,20 @@ function* scanSheet(xml, sharedStrings, xfStyles, hiddenColumns, merges) {
         if (claimed === 'cell')
             finalizeCell();
         else if (claimed === 'other' && local === 'row') {
+            styleResolution.closeRow();
             if (rowInGrid)
                 yield { number: rowNumber, hidden: rowHidden, cells };
         }
     }
 }
-function collectHiddenColumn(attrs, hiddenColumns) {
-    if (!boolStrict(attrs.hidden))
+function collectColumn(attrs, hiddenColumns, styleResolution, budget) {
+    const span = takeColumnSpan(attrs, budget);
+    if (span === undefined)
         return;
-    const min = numInteger(attrs.min, 1);
-    const max = numInteger(attrs.max, 1);
-    if (min === undefined || max === undefined)
+    const { first: min, last } = span;
+    styleResolution.noteColumnSpan(min, last, attrs);
+    if (!boolStrict(attrs.hidden))
         return;
-    const last = Math.min(max, MAX_COLUMN);
     for (let index = min; index <= last; index++)
         hiddenColumns.add(index);
 }

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

@@ -1,6 +1,7 @@
 import { parseXml } from '../../xml/xml-read.js';
 import { localName } from '../../xml/xml-scan.js';
-import { RunAccumulator } from './rich-runs.js';
+import { RunAccumulator } from './read-rich-runs.js';
+const SHARED_STRING_EMPTY_CLOSES = new Set(['si']);
 export function parseSharedStrings(xml) {
     if (xml === '')
         return [];
@@ -18,6 +19,6 @@ export function parseSharedStrings(xml) {
                 return;
             strings.push(runs.isRich ? { richText: runs.runs } : runs.plainText);
         },
-    });
+    }, { closeEmptyElements: SHARED_STRING_EMPTY_CLOSES });
     return strings;
 }

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

@@ -1,11 +1,6 @@
-import { type Font, type TableStyleTable } from '../../core/style.ts';
-import { type XmlAttributes } from '../../xml/xml-scan.ts';
+import type { TableStyleTable } from '../../core/workbook-styles.ts';
 import { type StyleTable } from '../style/xf-style.ts';
-export type FontDraft = {
-    -readonly [K in keyof Font]?: Font[K];
-};
 export declare function parseStyleTable(xml: string): StyleTable;
-export declare function applyFontChild(draft: FontDraft, local: string, attrs: XmlAttributes): void;
 /**
  * Extract the custom indexed-color palette (`<colors><indexedColors>`) from styles.xml as verbatim
  * `<rgbColor rgb="…"/>` fragments, or an empty list when the file rides the default palette. Kept raw

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

@@ -1,8 +1,10 @@
-import { ALIGNMENT_FACETS, isBorderStyle, isFillPatternType, isFontScheme, isFontVerticalAlignment, isNamedUnderlineStyle, } from '../../core/style.js';
+import { ALIGNMENT_FACETS, isBorderStyle, isFillPatternType, } from '../../core/style.js';
+import { numFinite, numInteger } from '../../xml/xml-attrs.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 { boolStrict, boolTristate, localName, xmlEvents, } from '../../xml/xml-scan.js';
+import { NO_PRESERVED_STYLE_TABLES, numFmtCodeFor, protectionFrom, resolveStyleTable, } from '../style/xf-style.js';
 import { parseColor } from './color-xml.js';
+import { applyFontChild } from './font-xml.js';
 const BORDER_EDGE_NAMES = ['left', 'right', 'top', 'bottom', 'diagonal'];
 const BORDER_EDGES = new Set(BORDER_EDGE_NAMES);
 const isBorderEdgeName = (name) => BORDER_EDGES.has(name);
@@ -309,68 +311,6 @@ function parseCellStyles(events) {
     }
     return names;
 }
-export function applyFontChild(draft, local, attrs) {
-    switch (local) {
-        case 'b':
-            draft.bold = boolPresent(attrs.val);
-            break;
-        case 'i':
-            draft.italic = boolPresent(attrs.val);
-            break;
-        case 'strike':
-            draft.strike = boolPresent(attrs.val);
-            break;
-        case 'outline':
-            draft.outline = boolPresent(attrs.val);
-            break;
-        case 'u':
-            draft.underline =
-                attrs.val === undefined
-                    ? true
-                    : attrs.val === 'none'
-                        ? false
-                        : isNamedUnderlineStyle(attrs.val)
-                            ? attrs.val
-                            : true;
-            break;
-        case 'vertAlign':
-            if (attrs.val !== undefined && isFontVerticalAlignment(attrs.val))
-                draft.vertAlign = attrs.val;
-            break;
-        case 'sz': {
-            const size = numFinite(attrs.val);
-            if (size !== undefined)
-                draft.size = size;
-            break;
-        }
-        case 'color':
-            draft.color = parseColor(attrs);
-            break;
-        case 'name':
-        case 'rFont':
-            if (attrs.val !== undefined)
-                draft.name = attrs.val;
-            break;
-        case 'family': {
-            const family = numInteger(attrs.val);
-            if (family !== undefined)
-                draft.family = family;
-            break;
-        }
-        case 'charset': {
-            const charset = numInteger(attrs.val);
-            if (charset !== undefined)
-                draft.charset = charset;
-            break;
-        }
-        case 'scheme':
-            if (attrs.val !== undefined && isFontScheme(attrs.val))
-                draft.scheme = attrs.val;
-            break;
-        default:
-            break;
-    }
-}
 function resolveNumFmt(raw, custom) {
     const id = numInteger(raw, 1);
     return id === undefined ? undefined : numFmtCodeFor(id, custom);
@@ -426,12 +366,7 @@ function assignAlignmentToken(out, key, raw) {
     out[key] = raw;
 }
 function parseProtection(attrs) {
-    const out = {};
-    if (boolTristate(attrs.locked) === false)
-        out.locked = false;
-    if (boolStrict(attrs.hidden))
-        out.hidden = true;
-    return Object.keys(out).length > 0 ? out : undefined;
+    return protectionFrom({ locked: boolTristate(attrs.locked), hidden: boolStrict(attrs.hidden) });
 }
 export function parseIndexedColors(stylesXml) {
     return capturedFragments(stylesXml, 'indexedColors');

package/dist/io/xlsx/read-workbook-xml.d.ts

@@ -0,0 +1,36 @@
+import { type WorkbookProtection } from '../../core/workbook-protection.ts';
+import type { DefinedName, Workbook, WorkbookView } from '../../core/workbook.ts';
+import { type WorksheetState } from '../../core/worksheet.ts';
+import { type CollectingPass, type SaxPass } from '../../xml/xml-read.ts';
+export interface SheetEntry {
+    readonly name: string;
+    readonly relId: string;
+    readonly state?: WorksheetState['state'];
+}
+export declare function workbookSheetsPass(): CollectingPass<SheetEntry[]>;
+export declare function workbookProtectionPass(): CollectingPass<WorkbookProtection | undefined>;
+/**
+ * Apply `<workbookPr>`: the workbook's date system and its VBA code name.
+ *
+ * Both are read for the same reason and it is not that the model computes anything from them. The
+ * date system is what every serial in every sheet counts from, so a workbook read without it is read
+ * with every date four years and a day out; the code name is what the VBA project means by
+ * `ThisWorkbook`, so a `.xlsm` written back without it has had its macros unbound from its document.
+ * Neither has any signal in the file other than this element.
+ */
+export declare function workbookPropertiesPass(workbook: Workbook): SaxPass;
+export declare function workbookViewPass(view: WorkbookView): SaxPass;
+export interface DefinedNamesPass extends SaxPass {
+    /**
+     * The names, scoped against the sheet order.
+     *
+     * The order is supplied here rather than to the pass, and that is what lets the names ride the same
+     * scan as everything else this part carries. A scoped name's `localSheetId` indexes the sheets in
+     * declaration order, and the model's answer for index n is known only after the sheet loop has run
+     * and repaired the names it had to; resolving during the scan would have forced a second one.
+     */
+    result(sheetOrder: readonly string[]): DefinedName[];
+}
+export declare function definedNamesPass(): DefinedNamesPass;
+export declare function applyCoreProperties(workbook: Workbook, xml: string): void;
+export declare function applyAppProperties(workbook: Workbook, xml: string): void;

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

@@ -0,0 +1,170 @@
+import { parseDateText } from '../../core/date.js';
+import { unmangleFunctions } from '../../core/formula.js';
+import { WORKBOOK_PROTECTION_CREDENTIAL_ATTRS, } from '../../core/workbook-protection.js';
+import { isVisibility } from '../../core/worksheet.js';
+import { enumToken, numInteger } from '../../xml/xml-attrs.js';
+import { capturedText, TextCapture } from '../../xml/xml-read.js';
+import { boolStrict, localName } from '../../xml/xml-scan.js';
+import { relAttr } from '../opc/namespaces.js';
+export function workbookSheetsPass() {
+    const sheets = [];
+    return {
+        handlers: {
+            onOpen(name, attrs, _selfClosing, scope) {
+                if (localName(name) !== 'sheet')
+                    return;
+                const entry = {
+                    name: attrs.name ?? '',
+                    relId: relAttr(scope, attrs, 'id') ?? '',
+                };
+                const state = enumToken(attrs.state, isVisibility);
+                if (state !== undefined && state !== 'visible')
+                    entry.state = state;
+                sheets.push(entry);
+            },
+        },
+        result: () => sheets,
+    };
+}
+export function workbookProtectionPass() {
+    let found;
+    const handlers = {
+        onOpen(name, attrs) {
+            if (localName(name) !== 'workbookProtection')
+                return;
+            const protection = {};
+            if (boolStrict(attrs.lockStructure))
+                protection.lockStructure = true;
+            if (boolStrict(attrs.lockWindows))
+                protection.lockWindows = true;
+            if (boolStrict(attrs.lockRevision))
+                protection.lockRevision = true;
+            const credentials = {};
+            for (const key of WORKBOOK_PROTECTION_CREDENTIAL_ATTRS) {
+                const value = attrs[key];
+                if (value !== undefined)
+                    credentials[key] = value;
+            }
+            if (Object.keys(credentials).length > 0)
+                protection.credentials = credentials;
+            found = protection;
+        },
+    };
+    return { handlers, result: () => found };
+}
+export function workbookPropertiesPass(workbook) {
+    let seen = false;
+    return {
+        handlers: {
+            onOpen(name, attrs) {
+                if (seen || localName(name) !== 'workbookPr')
+                    return;
+                seen = true;
+                if (boolStrict(attrs.date1904))
+                    workbook.dateEpoch = 1904;
+                if (attrs.codeName !== undefined)
+                    workbook.codeName = attrs.codeName;
+            },
+        },
+    };
+}
+export function workbookViewPass(view) {
+    let seen = false;
+    return {
+        handlers: {
+            onOpen(name, attrs) {
+                if (seen || localName(name) !== 'workbookView')
+                    return;
+                seen = true;
+                const x = numInteger(attrs.xWindow);
+                if (x !== undefined)
+                    view.x = x;
+                const y = numInteger(attrs.yWindow);
+                if (y !== undefined)
+                    view.y = y;
+                const width = numInteger(attrs.windowWidth, 0);
+                if (width !== undefined)
+                    view.width = width;
+                const height = numInteger(attrs.windowHeight, 0);
+                if (height !== undefined)
+                    view.height = height;
+                const activeTab = numInteger(attrs.activeTab, 0);
+                if (activeTab !== undefined)
+                    view.activeTab = activeTab;
+                const visibility = enumToken(attrs.visibility, isVisibility);
+                if (visibility !== undefined && visibility !== 'visible')
+                    view.visibility = visibility;
+                if (boolStrict(attrs.minimized))
+                    view.minimized = true;
+            },
+        },
+    };
+}
+export function definedNamesPass() {
+    const drafts = [];
+    const refersTo = new TextCapture('definedName');
+    let pending;
+    return {
+        handlers: {
+            onOpen(name, attrs, selfClosing) {
+                if (localName(name) !== 'definedName' || attrs.name === undefined)
+                    return;
+                if (attrs.name === '_xlnm._FilterDatabase')
+                    return;
+                refersTo.open(localName(name), selfClosing);
+                pending = { name: attrs.name, localSheetId: numInteger(attrs.localSheetId, 0) ?? -1 };
+                if (attrs.comment !== undefined)
+                    pending.comment = attrs.comment;
+                if (boolStrict(attrs.hidden))
+                    pending.hidden = true;
+            },
+            onText(chunk) {
+                refersTo.text(chunk);
+            },
+            onClose(name) {
+                const text = refersTo.close(localName(name));
+                if (text === undefined || pending === undefined)
+                    return;
+                drafts.push({ ...pending, refersTo: unmangleFunctions(text) });
+                pending = undefined;
+            },
+        },
+        closeEmptyElements: new Set(['definedName']),
+        result(sheetOrder) {
+            return drafts.map(({ localSheetId, ...draft }) => {
+                const scope = sheetOrder[localSheetId];
+                return scope === undefined ? draft : { ...draft, scope };
+            });
+        },
+    };
+}
+const CORE_PROPERTY_LOCAL_NAMES = new Set([
+    'title',
+    'creator',
+    'lastModifiedBy',
+    'created',
+    'modified',
+]);
+export function applyCoreProperties(workbook, xml) {
+    for (const { local, text } of capturedText(xml, CORE_PROPERTY_LOCAL_NAMES)) {
+        if (local === 'title')
+            workbook.properties.title = text;
+        else if (local === 'creator')
+            workbook.properties.creator = text;
+        else if (local === 'lastModifiedBy')
+            workbook.properties.lastModifiedBy = text;
+        else {
+            const date = parseDateText(text);
+            if (date !== null) {
+                if (local === 'created')
+                    workbook.properties.created = date;
+                else
+                    workbook.properties.modified = date;
+            }
+        }
+    }
+}
+export function applyAppProperties(workbook, xml) {
+    for (const { text } of capturedText(xml, 'Company'))
+        workbook.properties.company = text;
+}

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

@@ -1,3 +1,4 @@
+import type { DateEpoch } from '../../core/date.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
 import { type SaxPass } from '../../xml/xml-read.ts';
 import type { XfStyle } from '../style/xf-style.ts';
@@ -10,4 +11,4 @@ import type { SharedString } from './cell-value.ts';
  * 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;
+export declare function worksheetPass(sheet: Worksheet, sharedStrings: readonly SharedString[], xfStyles: ReadonlyArray<XfStyle>, dateEpoch: DateEpoch): SaxPass;