@shbernal/ts-xlsx 3.0.0 → 3.2.0

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

@@ -0,0 +1,175 @@
+import { parseDateText } from '../../core/date.js';
+import { definedNameKeys, 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: text });
+                pending = undefined;
+            },
+        },
+        closeEmptyElements: new Set(['definedName']),
+        result(sheetOrder) {
+            const names = definedNameKeys(drafts);
+            return drafts.map(({ localSheetId, refersTo: stored, ...draft }) => {
+                const named = { ...draft, refersTo: unmangleFunctions(stored, names) };
+                const scope = sheetOrder[localSheetId];
+                return scope === undefined ? named : { ...named, scope };
+            });
+        },
+        spellings() {
+            return definedNameKeys(drafts);
+        },
+    };
+}
+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,5 +1,7 @@
+import type { DateEpoch } from '../../core/date.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
 import { type SaxPass } from '../../xml/xml-read.ts';
+import type { CellMetadataIndex } from '../cell-metadata/metadata.ts';
 import type { XfStyle } from '../style/xf-style.ts';
 import type { SharedString } from './cell-value.ts';
 /**
@@ -7,7 +9,11 @@ import type { SharedString } from './cell-value.ts';
  * 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.
+ * Offered as a pass because the worksheet is the largest part in a package and other readers want
+ * the same events, so they all share one parse of it rather than scanning it once each.
+ *
+ * `definedNames` is every name the workbook defines, as `definedNameKeys` spells them: the workbook
+ * part is read before any sheet, so they are known before the first formula is. `cellMetadata` is
+ * what the workbook's `cm` and `vm` values resolve to, read from the parts they index.
  */
-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, definedNames: ReadonlySet<string>, cellMetadata: CellMetadataIndex): SaxPass;

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

@@ -1,18 +1,26 @@
-import { MAX_COLUMN, MAX_ROW, tryDecodeRange } from '../../core/address.js';
+import { boundedRect, tryDecodeRange } from '../../core/address.js';
 import { isCustomFilterOperator, } from '../../core/autofilter.js';
 import { INTERNAL } from '../../core/internal.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 { HEADER_FOOTER_ELEMENTS } from '../../core/page-setup.js';
 import { assignStyleFacets } from '../../core/style.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';
+import { decodeSpreadsheetText, numFinite, numInteger } from '../../xml/xml-attrs.js';
+import { TextCapture } from '../../xml/xml-read.js';
+import { boolPresent, boolStrict, localName } from '../../xml/xml-scan.js';
+import { ColumnRecordBudget } from '../read-policy/column-budget.js';
+import { admitting } from '../read-policy/read-repair.js';
+import { CellStyleResolver } from '../style/cell-style-resolution.js';
+import { CellAccumulator, WORKSHEET_BODY_EMPTY_CLOSES } from './cell-accumulator.js';
+import { takeColumnSpan } from './column-span.js';
+import { RowPositionTracker } from './row-position.js';
+import { applySheetProperties, PageBreakAccumulator, parseSheetProtection, } from './sheet-properties.js';
 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']);
+const WORKSHEET_EMPTY_CLOSES = new Set([
+    ...WORKSHEET_BODY_EMPTY_CLOSES,
+    'autoFilter',
+]);
 function pendingFilterCriteria(values, blank, predicates, and) {
     if (values !== null && (values.length > 0 || blank)) {
         return { kind: 'values', values, blank };
@@ -22,31 +30,6 @@ function pendingFilterCriteria(values, blank, predicates, and) {
     }
     return null;
 }
-function parseSheetProtection(attrs) {
-    if (boolTristate(attrs.sheet) === false)
-        return undefined;
-    const flags = {};
-    for (const { key } of SHEET_PROTECTION_FLAGS) {
-        const raw = attrs[key];
-        if (raw !== undefined)
-            flags[key] = !boolStrict(raw);
-    }
-    const { algorithmName, hashValue, saltValue, spinCount } = attrs;
-    const spin = numInteger(spinCount, 0);
-    if (algorithmName !== undefined &&
-        hashValue !== undefined &&
-        saltValue !== undefined &&
-        spin !== undefined) {
-        const credential = {
-            algorithmName,
-            hashValue,
-            saltValue,
-            spinCount: spin,
-        };
-        return { flags, credential };
-    }
-    return { flags };
-}
 class AutoFilterAccumulator {
     #ref = null;
     #columns = [];
@@ -96,82 +79,67 @@ class AutoFilterAccumulator {
         if (this.#ref === null)
             return;
         const decoded = tryDecodeRange(this.#ref);
-        const left = decoded?.left;
-        const right = decoded?.right;
-        if (left !== undefined && right !== undefined) {
-            const width = right - left + 1;
+        const rect = decoded === undefined ? undefined : boundedRect(decoded);
+        if (rect !== undefined) {
+            const width = rect.right - rect.left + 1;
             sheet.autoFilter = { ref: this.#ref, columns: this.#columns.filter((c) => c.colId < width) };
         }
         this.#ref = null;
         this.#columns = [];
     }
 }
-class PageBreakAccumulator {
-    #target = null;
-    begin(target) {
-        this.#target = target;
-    }
-    end() {
-        this.#target = null;
-    }
-    add(attrs) {
-        if (this.#target === null)
-            return;
-        const id = numInteger(attrs.id, 1);
-        if (id === undefined)
-            return;
-        const brk = { id };
-        const max = numInteger(attrs.max, 0);
-        if (max !== undefined)
-            brk.max = max;
-        if (boolStrict(attrs.man))
-            brk.man = true;
-        this.#target.push(brk);
-    }
-}
-export function worksheetPass(sheet, sharedStrings, xfStyles) {
-    const cell = new CellAccumulator({ richRuns: true });
-    let rowStyle = -1;
-    let rowCustomFormat = false;
+export function worksheetPass(sheet, sharedStrings, xfStyles, dateEpoch, definedNames, cellMetadata) {
+    const cell = new CellAccumulator({ dateEpoch, definedNames, cellMetadata });
     const autoFilter = new AutoFilterAccumulator();
     const pageBreaks = new PageBreakAccumulator();
-    const columnStyle = new Map();
+    const styleResolution = new CellStyleResolver();
+    const columnBudget = new ColumnRecordBudget();
+    const rowPosition = new RowPositionTracker();
+    const headerFooterText = new TextCapture(HEADER_FOOTER_ELEMENTS);
+    let customViewDepth = 0;
     const finalizeCellFromState = () => {
-        const styleIndex = cell.styleIndex >= 0
-            ? cell.styleIndex
-            : rowCustomFormat && rowStyle >= 0
-                ? rowStyle
-                : (columnStyle.get(cell.col) ?? -1);
-        const style = styleIndex >= 0 ? xfStyles[styleIndex] : xfStyles[0];
-        cell.finalize(sheet, sharedStrings, style);
+        cell.finalize(sheet, sharedStrings, styleResolution.styleFor(cell.col, cell.styleIndex, xfStyles));
     };
     const handlers = {
         onOpen(name, attrs, selfClosing) {
             const local = localName(name);
+            if (customViewDepth > 0) {
+                if (!selfClosing)
+                    customViewDepth++;
+                return;
+            }
+            if (local === 'customSheetViews') {
+                if (!selfClosing)
+                    customViewDepth = 1;
+                return;
+            }
             if (cell.openElement(local, attrs, selfClosing))
                 return;
-            if (HEADER_FOOTER_CHILDREN.has(local)) {
-                cell.capture();
+            if (isHeaderFooterElement(local)) {
+                headerFooterText.open(local, selfClosing);
                 return;
             }
             switch (local) {
                 case 'col':
-                    applyColumn(sheet, attrs, xfStyles, columnStyle);
+                    applyColumn(sheet, attrs, xfStyles, styleResolution, columnBudget);
                     break;
-                case 'row':
-                    applyRow(sheet, attrs);
-                    rowStyle = numInteger(attrs.s, 0) ?? -1;
-                    rowCustomFormat = boolStrict(attrs.customFormat);
+                case 'row': {
+                    const { number, inGrid } = rowPosition.open(attrs);
+                    if (inGrid)
+                        applyRow(sheet, number, attrs);
+                    cell.openRow(number, inGrid);
+                    styleResolution.openRow(numInteger(attrs.s, 0) ?? -1, boolStrict(attrs.customFormat));
                     break;
+                }
                 case 'mergeCell':
                     if (attrs.ref !== undefined && attrs.ref !== '') {
-                        try {
-                            sheet.mergeCells(attrs.ref);
-                        }
-                        catch {
-                        }
+                        const ref = attrs.ref;
+                        admitting(() => {
+                            sheet.mergeCells(ref);
+                        });
                     }
                     break;
+                case 'sheetPr':
                 case 'tabColor':
                 case 'outlinePr':
                 case 'sheetView':
@@ -218,9 +186,16 @@ export function worksheetPass(sheet, sharedStrings, xfStyles) {
             }
         },
         onText(chunk) {
+            if (customViewDepth > 0)
+                return;
             cell.appendChunk(chunk);
+            headerFooterText.text(chunk);
         },
         onClose(name) {
+            if (customViewDepth > 0) {
+                customViewDepth--;
+                return;
+            }
             const local = localName(name);
             const claimed = cell.closeElement(local);
             if (claimed === 'cell') {
@@ -229,14 +204,15 @@ export function worksheetPass(sheet, sharedStrings, xfStyles) {
             }
             if (claimed === 'claimed')
                 return;
-            if (isHeaderFooterElement(local)) {
-                sheet.headerFooter[local] = decodeSpreadsheetText(cell.capturedText);
+            const headerFooter = headerFooterText.close(local);
+            if (headerFooter !== undefined && isHeaderFooterElement(local)) {
+                sheet.headerFooter[local] = decodeSpreadsheetText(headerFooter);
                 return;
             }
             switch (local) {
                 case 'row':
-                    rowStyle = -1;
-                    rowCustomFormat = false;
+                    styleResolution.closeRow();
+                    cell.closeRow();
                     break;
                 case 'filterColumn':
                     autoFilter.endColumn();
@@ -255,56 +231,11 @@ export function worksheetPass(sheet, sharedStrings, xfStyles) {
     };
     return { handlers, closeEmptyElements: WORKSHEET_EMPTY_CLOSES };
 }
-function applySheetProperties(local, attrs, sheet) {
-    switch (local) {
-        case 'tabColor':
-            sheet.tabColor = parseColor(attrs);
-            break;
-        case 'outlinePr':
-            if (attrs.summaryBelow !== undefined)
-                sheet.outline.summaryBelow = boolPresent(attrs.summaryBelow);
-            if (attrs.summaryRight !== undefined)
-                sheet.outline.summaryRight = boolPresent(attrs.summaryRight);
-            break;
-        case 'sheetView':
-            if (attrs.showGridLines !== undefined && !boolPresent(attrs.showGridLines)) {
-                sheet.view.showGridLines = false;
-            }
-            break;
-        case 'pane':
-            if (attrs.state === 'frozen' || attrs.state === 'frozenSplit') {
-                sheet.view.state = 'frozen';
-                const xSplit = numInteger(attrs.xSplit, 0);
-                const ySplit = numInteger(attrs.ySplit, 0);
-                if (xSplit !== undefined)
-                    sheet.view.xSplit = xSplit;
-                if (ySplit !== undefined)
-                    sheet.view.ySplit = ySplit;
-                if (attrs.topLeftCell !== undefined)
-                    sheet.view.topLeftCell = attrs.topLeftCell;
-            }
-            break;
-        case 'pageSetUpPr':
-            if (attrs.fitToPage !== undefined)
-                sheet.pageSetup.fitToPage = boolPresent(attrs.fitToPage);
-            break;
-        case 'printOptions':
-            applyPrintOptions(sheet.printOptions, attrs);
-            break;
-        case 'pageMargins':
-            applyMargins(sheet.pageMargins, attrs);
-            break;
-        case 'pageSetup':
-            applyPageSetup(sheet.pageSetup, attrs);
-            break;
-    }
-}
-function applyColumn(sheet, attrs, xfStyles, columnStyle) {
-    const min = numInteger(attrs.min, 1);
-    const max = numInteger(attrs.max, 1);
-    if (min === undefined || max === undefined || min > MAX_COLUMN)
+function applyColumn(sheet, attrs, xfStyles, styleResolution, budget) {
+    const span = takeColumnSpan(attrs, budget);
+    if (span === undefined)
         return;
-    const last = Math.min(max, MAX_COLUMN);
+    const { first: min, last } = span;
     const width = numFinite(attrs.width);
     const hidden = boolStrict(attrs.hidden);
     const styleIndex = numInteger(attrs.style, 0) ?? -1;
@@ -322,14 +253,10 @@ function applyColumn(sheet, attrs, xfStyles, columnStyle) {
             column.collapsed = true;
         if (style !== undefined)
             assignStyleFacets(column, style);
-        if (styleIndex >= 0)
-            columnStyle.set(index, styleIndex);
     }
+    styleResolution.noteColumnSpan(min, last, numInteger(attrs.style, 0) ?? -1);
 }
-function applyRow(sheet, attrs) {
-    const number = numInteger(attrs.r, 1);
-    if (number === undefined || number > MAX_ROW)
-        return;
+function applyRow(sheet, number, attrs) {
     const row = sheet.getRow(number);
     const height = numFinite(attrs.ht);
     if (height !== undefined && boolPresent(attrs.customHeight))
@@ -342,37 +269,3 @@ function applyRow(sheet, attrs) {
     if (boolStrict(attrs.collapsed))
         row.collapsed = true;
 }
-function applyPrintOptions(printOptions, attrs) {
-    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) {
-        const value = numFinite(attrs[side]);
-        if (value !== undefined)
-            margins[side] = value;
-    }
-}
-function applyPageSetup(pageSetup, attrs) {
-    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,9 +1,5 @@
-import { Workbook, type WorkbookView } from '../../core/workbook.ts';
-import { type WorksheetState } from '../../core/worksheet.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';
+import { Workbook } from '../../core/workbook.ts';
+import type { ReadPackageOptions } from '../opc/read-options.ts';
 /**
  * Read a spreadsheet package into a {@link Workbook}.
  *
@@ -19,11 +15,4 @@ export { parseStyleTable } from './read-styles.ts';
  * @throws {PackageReadError} if the input is a ZIP that cannot be unpacked: a corrupt or
  *   truncated archive, or one exceeding the inflate bound (a probable zip bomb).
  */
-export declare function readXlsx(data: Uint8Array, options?: ReadXlsxOptions): Workbook;
-export interface SheetEntry {
-    readonly name: string;
-    readonly relId: string;
-    readonly state?: WorksheetState['state'];
-}
-export declare function parseWorkbookSheets(xml: string): SheetEntry[];
-export declare function applyWorkbookView(view: WorkbookView, xml: string): void;
+export declare function readXlsx(data: Uint8Array, options?: ReadPackageOptions): Workbook;