@shbernal/ts-xlsx 2.1.0 → 3.1.0

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

@@ -1,7 +1,10 @@
-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, } from '../../core/style.js';
+import { numFinite, numInteger } from '../../xml/xml-attrs.js';
+import { closeEmptyElements, elementSubtrees, openElements, } from '../../xml/xml-read.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);
@@ -15,7 +18,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 +57,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();
@@ -298,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);
@@ -389,53 +340,53 @@ 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')
-        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 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 +421,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-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,4 +1,14 @@
+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';
 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>, dateEpoch: DateEpoch): SaxPass;