@shbernal/ts-xlsx 1.3.1 → 2.0.0

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

@@ -1,6 +1,6 @@
-import { assignStyleFacets, isBorderStyle, isFillPatternType, isFontScheme, isFontVerticalAlignment, isHorizontalAlignment, isNamedUnderlineStyle, isVerticalAlignment, } from '../../core/style.js';
-import { boolPresent, boolStrict, closeEmptyElements, localName, openElements, xmlEvents, } from '../../xml/xml-read.js';
-import { numFmtCodeFor } from '../style/xf-style.js';
+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 { parseColor } from './color-xml.js';
 const BORDER_EDGE_NAMES = ['left', 'right', 'top', 'bottom', 'diagonal'];
 const BORDER_EDGES = new Set(BORDER_EDGE_NAMES);
@@ -53,24 +53,7 @@ export function parseStyleTable(xml) {
         }
         next = events.next();
     }
-    const cellXfs = xfStyles.map((xf) => {
-        if (xf.xfId === undefined)
-            return xf;
-        const named = namedXfs[xf.xfId];
-        return named === undefined ? xf : { ...named, ...xf };
-    });
-    const namedStyles = namedXfs.map((xf, index) => {
-        const label = cellStyleNames.find((entry) => entry.xfId === index);
-        const style = {};
-        assignStyleFacets(style, xf);
-        if (label?.name !== undefined)
-            style.name = label.name;
-        if (label?.builtinId !== undefined)
-            style.builtinId = label.builtinId;
-        return style;
-    });
-    const defaultFont = fonts[0];
-    return defaultFont === undefined ? { cellXfs, namedStyles } : { cellXfs, namedStyles, defaultFont };
+    return resolveStyleTable({ directXfs: xfStyles, namedXfs, labels: cellStyleNames, fonts });
 }
 function* until(events, container) {
     let next = events.next();
@@ -86,8 +69,8 @@ function parseNumFmts(events) {
     const codes = new Map();
     for (const event of until(events, 'numFmts')) {
         if (event.kind === 'open' && localName(event.name) === 'numFmt') {
-            const id = Number(event.attrs.numFmtId);
-            if (Number.isInteger(id) && id > 0 && event.attrs.formatCode !== undefined) {
+            const id = numInteger(event.attrs.numFmtId, 1);
+            if (id !== undefined && event.attrs.formatCode !== undefined) {
                 codes.set(id, event.attrs.formatCode);
             }
         }
@@ -151,8 +134,7 @@ function parseFills(events) {
                     break;
                 case 'stop':
                     if (gradientDraft !== null) {
-                        const position = Number(attrs.position);
-                        gradientDraft.stopPosition = Number.isFinite(position) ? position : 0;
+                        gradientDraft.stopPosition = numFinite(attrs.position) ?? 0;
                         gradientDraft.stopColor = undefined;
                     }
                     break;
@@ -271,12 +253,12 @@ function parseXfTable(events, container, deps) {
     return xfs;
 }
 function resolveXf(attrs, deps, captureXfId) {
-    const fillId = Number(attrs.fillId);
-    const fill = Number.isInteger(fillId) ? deps.fills[fillId] : undefined;
-    const fontId = Number(attrs.fontId);
-    const font = Number.isInteger(fontId) ? deps.fonts[fontId] : undefined;
-    const borderId = Number(attrs.borderId);
-    const border = Number.isInteger(borderId) && borderId > 0 ? deps.borders[borderId] : undefined;
+    const fillId = numInteger(attrs.fillId, 0);
+    const fill = fillId !== undefined ? deps.fills[fillId] : undefined;
+    const fontId = numInteger(attrs.fontId, 0);
+    const font = fontId !== undefined ? deps.fonts[fontId] : undefined;
+    const borderId = numInteger(attrs.borderId, 1);
+    const border = borderId !== undefined ? deps.borders[borderId] : undefined;
     const numFmt = resolveNumFmt(attrs.numFmtId, deps.numFmtCodes);
     const draft = {};
     if (fill)
@@ -289,9 +271,9 @@ function resolveXf(attrs, deps, captureXfId) {
         draft.border = border;
     if (boolStrict(attrs.quotePrefix))
         draft.quotePrefix = true;
-    if (captureXfId && attrs.xfId !== undefined) {
-        const xfId = Number(attrs.xfId);
-        if (Number.isInteger(xfId) && xfId > 0)
+    if (captureXfId) {
+        const xfId = numInteger(attrs.xfId, 1);
+        if (xfId !== undefined)
             draft.xfId = xfId;
     }
     return draft;
@@ -301,16 +283,14 @@ function parseCellStyles(events) {
     for (const event of until(events, 'cellStyles')) {
         if (event.kind === 'open' && localName(event.name) === 'cellStyle') {
             const attrs = event.attrs;
-            const xfId = Number(attrs.xfId);
-            if (Number.isInteger(xfId)) {
+            const xfId = numInteger(attrs.xfId);
+            if (xfId !== undefined) {
                 const entry = { xfId };
                 if (attrs.name !== undefined)
                     entry.name = attrs.name;
-                if (attrs.builtinId !== undefined) {
-                    const builtinId = Number(attrs.builtinId);
-                    if (Number.isInteger(builtinId))
-                        entry.builtinId = builtinId;
-                }
+                const builtinId = numInteger(attrs.builtinId);
+                if (builtinId !== undefined)
+                    entry.builtinId = builtinId;
                 names.push(entry);
             }
         }
@@ -346,8 +326,8 @@ export function applyFontChild(draft, local, attrs) {
                 draft.vertAlign = attrs.val;
             break;
         case 'sz': {
-            const size = Number(attrs.val);
-            if (Number.isFinite(size))
+            const size = numFinite(attrs.val);
+            if (size !== undefined)
                 draft.size = size;
             break;
         }
@@ -360,14 +340,14 @@ export function applyFontChild(draft, local, attrs) {
                 draft.name = attrs.val;
             break;
         case 'family': {
-            const family = Number(attrs.val);
-            if (Number.isInteger(family))
+            const family = numInteger(attrs.val);
+            if (family !== undefined)
                 draft.family = family;
             break;
         }
         case 'charset': {
-            const charset = Number(attrs.val);
-            if (Number.isInteger(charset))
+            const charset = numInteger(attrs.val);
+            if (charset !== undefined)
                 draft.charset = charset;
             break;
         }
@@ -380,7 +360,8 @@ export function applyFontChild(draft, local, attrs) {
     }
 }
 function resolveNumFmt(raw, custom) {
-    return raw === undefined ? undefined : numFmtCodeFor(Number(raw), custom);
+    const id = numInteger(raw, 1);
+    return id === undefined ? undefined : numFmtCodeFor(id, custom);
 }
 function toFill(pattern, fgColor, bgColor) {
     if (!isFillPatternType(pattern) || pattern === 'none')
@@ -394,8 +375,8 @@ function toFill(pattern, fgColor, bgColor) {
 }
 function assignGradientNumbers(fill, attrs) {
     for (const key of ['degree', 'left', 'right', 'top', 'bottom']) {
-        const value = Number(attrs[key]);
-        if (attrs[key] !== undefined && Number.isFinite(value))
+        const value = numFinite(attrs[key]);
+        if (value !== undefined)
             fill[key] = value;
     }
 }
@@ -414,25 +395,19 @@ function parseAlignment(attrs) {
     }
     if (attrs.vertical !== undefined && isVerticalAlignment(attrs.vertical))
         out.vertical = attrs.vertical;
-    if (attrs.textRotation !== undefined) {
-        const rotation = Number(attrs.textRotation);
-        if (Number.isFinite(rotation) && rotation !== 0)
-            out.textRotation = rotation;
-    }
+    const rotation = numFinite(attrs.textRotation);
+    if (rotation !== undefined && rotation !== 0)
+        out.textRotation = rotation;
     if (boolStrict(attrs.wrapText))
         out.wrapText = true;
-    if (attrs.indent !== undefined) {
-        const indent = Number(attrs.indent);
-        if (Number.isInteger(indent) && indent !== 0)
-            out.indent = indent;
-    }
+    const indent = numInteger(attrs.indent);
+    if (indent !== undefined && indent !== 0)
+        out.indent = indent;
     if (boolStrict(attrs.shrinkToFit))
         out.shrinkToFit = true;
-    if (attrs.readingOrder !== undefined) {
-        const order = Number(attrs.readingOrder);
-        if (Number.isInteger(order) && order !== 0)
-            out.readingOrder = order;
-    }
+    const order = numInteger(attrs.readingOrder);
+    if (order !== undefined && order !== 0)
+        out.readingOrder = order;
     return Object.keys(out).length > 0 ? out : undefined;
 }
 function parseProtection(attrs) {

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

@@ -1,9 +1,9 @@
-import { decodeRange } from '../../core/address.js';
+import { decodeRange, MAX_COLUMN, MAX_ROW } from '../../core/address.js';
 import { isCustomFilterOperator, } from '../../core/autofilter.js';
 import { INTERNAL } from '../../core/internal.js';
 import { SHEET_PROTECTION_FLAGS, } from '../../core/protection.js';
 import { assignStyleFacets } from '../../core/style.js';
-import { boolPresent, boolStrict, boolTristate, localName, parseXml, } from '../../xml/xml-read.js';
+import { boolPresent, boolStrict, boolTristate, decodeSpreadsheetText, localName, numFinite, numInteger, parseXml, } from '../../xml/xml-read.js';
 import { CellAccumulator } from './cell-accumulator.js';
 import { parseColor } from './color-xml.js';
 const MARGIN_SIDES = ['left', 'right', 'top', 'bottom', 'header', 'footer'];
@@ -27,20 +27,18 @@ function parseSheetProtection(attrs) {
             flags[key] = !boolStrict(raw);
     }
     const { algorithmName, hashValue, saltValue, spinCount } = attrs;
+    const spin = numInteger(spinCount, 0);
     if (algorithmName !== undefined &&
         hashValue !== undefined &&
         saltValue !== undefined &&
-        spinCount !== undefined) {
-        const spin = Number(spinCount);
-        if (Number.isFinite(spin)) {
-            const credential = {
-                algorithmName,
-                hashValue,
-                saltValue,
-                spinCount: spin,
-            };
-            return { flags, credential };
-        }
+        spin !== undefined) {
+        const credential = {
+            algorithmName,
+            hashValue,
+            saltValue,
+            spinCount: spin,
+        };
+        return { flags, credential };
     }
     return { flags };
 }
@@ -57,7 +55,7 @@ class AutoFilterAccumulator {
         this.#columns = [];
     }
     beginColumn(attrs) {
-        this.#colId = attrs.colId !== undefined ? Number(attrs.colId) : -1;
+        this.#colId = numInteger(attrs.colId, 0) ?? -1;
         this.#values = null;
         this.#blank = false;
         this.#predicates = null;
@@ -114,12 +112,12 @@ class PageBreakAccumulator {
     add(attrs) {
         if (this.#target === null)
             return;
-        const id = Number(attrs.id);
-        if (!Number.isInteger(id) || id < 1)
+        const id = numInteger(attrs.id, 1);
+        if (id === undefined)
             return;
         const brk = { id };
-        const max = Number(attrs.max);
-        if (Number.isInteger(max) && max >= 0)
+        const max = numInteger(attrs.max, 0);
+        if (max !== undefined)
             brk.max = max;
         if (boolStrict(attrs.man))
             brk.man = true;
@@ -127,10 +125,7 @@ class PageBreakAccumulator {
     }
 }
 export function parseWorksheet(xml, sheet, sharedStrings, xfStyles) {
-    const cell = new CellAccumulator();
-    let inInlineString = false;
-    let capture = false;
-    let text = '';
+    const cell = new CellAccumulator({ richRuns: true });
     let rowStyle = -1;
     let rowCustomFormat = false;
     const autoFilter = new AutoFilterAccumulator();
@@ -148,46 +143,24 @@ export function parseWorksheet(xml, sheet, sharedStrings, xfStyles) {
     parseXml(xml, {
         onOpen(name, attrs, selfClosing) {
             const local = localName(name);
-            text = '';
-            capture = false;
+            if (cell.openElement(local, attrs, selfClosing))
+                return;
             switch (local) {
                 case 'col':
                     applyColumn(sheet, attrs, xfStyles, columnStyle);
                     break;
                 case 'row':
                     applyRow(sheet, attrs);
-                    rowStyle = attrs.s !== undefined ? Number(attrs.s) : -1;
+                    rowStyle = numInteger(attrs.s, 0) ?? -1;
                     rowCustomFormat = boolStrict(attrs.customFormat);
                     break;
-                case 'c':
-                    cell.beginCell(attrs);
-                    break;
-                case 'is':
-                    inInlineString = true;
-                    cell.beginInlineString();
-                    break;
-                case 'r':
-                    if (inInlineString)
-                        cell.runs.beginRun();
-                    break;
-                case 'rPr':
-                    cell.runs.beginProperties();
-                    break;
-                case 'f':
-                    capture = true;
-                    cell.beginFormula(attrs, selfClosing);
-                    break;
-                case 'v':
-                case 't':
-                    capture = true;
-                    break;
                 case 'oddHeader':
                 case 'oddFooter':
                 case 'evenHeader':
                 case 'evenFooter':
                 case 'firstHeader':
                 case 'firstFooter':
-                    capture = true;
+                    cell.capture();
                     break;
                 case 'mergeCell':
                     if (attrs.ref !== undefined && attrs.ref !== '') {
@@ -245,41 +218,27 @@ export function parseWorksheet(xml, sheet, sharedStrings, xfStyles) {
                     cell.runs.applyProperty(local, attrs);
                     break;
             }
-            if (selfClosing && (local === 'f' || local === 'v'))
-                capture = false;
         },
         onText(chunk) {
-            if (capture)
-                text += chunk;
+            cell.appendChunk(chunk);
         },
         onClose(name) {
             const local = localName(name);
+            const claimed = cell.closeElement(local);
+            if (claimed === 'cell') {
+                finalizeCellFromState();
+                return;
+            }
+            if (claimed === 'claimed')
+                return;
             switch (local) {
-                case 'f':
-                    cell.setFormula(text);
-                    break;
-                case 'v':
-                    cell.setValue(text);
-                    break;
-                case 't':
-                    cell.appendText(text, inInlineString);
-                    break;
-                case 'r':
-                    cell.runs.endRun();
-                    break;
-                case 'is':
-                    inInlineString = false;
-                    break;
                 case 'oddHeader':
                 case 'oddFooter':
                 case 'evenHeader':
                 case 'evenFooter':
                 case 'firstHeader':
                 case 'firstFooter':
-                    sheet.headerFooter[local] = text;
-                    break;
-                case 'c':
-                    finalizeCellFromState();
+                    sheet.headerFooter[local] = decodeSpreadsheetText(cell.capturedText);
                     break;
                 case 'row':
                     rowStyle = -1;
@@ -298,7 +257,6 @@ export function parseWorksheet(xml, sheet, sharedStrings, xfStyles) {
                 default:
                     break;
             }
-            capture = false;
         },
     }, { closeEmptyElements: WORKSHEET_EMPTY_CLOSES });
 }
@@ -321,10 +279,12 @@ function applySheetProperties(local, attrs, sheet) {
         case 'pane':
             if (attrs.state === 'frozen' || attrs.state === 'frozenSplit') {
                 sheet.view.state = 'frozen';
-                if (attrs.xSplit !== undefined)
-                    sheet.view.xSplit = Number(attrs.xSplit);
-                if (attrs.ySplit !== undefined)
-                    sheet.view.ySplit = Number(attrs.ySplit);
+                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;
             }
@@ -345,25 +305,24 @@ function applySheetProperties(local, attrs, sheet) {
     }
 }
 function applyColumn(sheet, attrs, xfStyles, columnStyle) {
-    const min = Number(attrs.min);
-    const max = Number(attrs.max);
-    if (!Number.isInteger(min) || !Number.isInteger(max) || min < 1)
+    const min = numInteger(attrs.min, 1);
+    const max = numInteger(attrs.max, 1);
+    if (min === undefined || max === undefined || min > MAX_COLUMN)
         return;
-    const width = attrs.width !== undefined ? Number(attrs.width) : undefined;
+    const last = Math.min(max, MAX_COLUMN);
+    const width = numFinite(attrs.width);
     const hidden = boolStrict(attrs.hidden);
-    const styleIndex = attrs.style !== undefined ? Number(attrs.style) : -1;
+    const styleIndex = numInteger(attrs.style, 0) ?? -1;
     const style = styleIndex >= 0 ? xfStyles[styleIndex] : undefined;
-    for (let index = min; index <= max; index++) {
+    for (let index = min; index <= last; index++) {
         const column = sheet.getColumn(index);
-        if (width !== undefined && Number.isFinite(width) && attrs.customWidth !== '0')
+        if (width !== undefined && boolPresent(attrs.customWidth))
             column.width = width;
         if (hidden)
             column.hidden = true;
-        if (attrs.outlineLevel !== undefined) {
-            const level = Number(attrs.outlineLevel);
-            if (Number.isInteger(level) && level > 0)
-                column.outlineLevel = level;
-        }
+        const outlineLevel = numInteger(attrs.outlineLevel, 1);
+        if (outlineLevel !== undefined)
+            column.outlineLevel = outlineLevel;
         if (boolStrict(attrs.collapsed))
             column.collapsed = true;
         if (style !== undefined)
@@ -373,22 +332,18 @@ function applyColumn(sheet, attrs, xfStyles, columnStyle) {
     }
 }
 function applyRow(sheet, attrs) {
-    const number = Number(attrs.r);
-    if (!Number.isInteger(number) || number < 1)
+    const number = numInteger(attrs.r, 1);
+    if (number === undefined || number > MAX_ROW)
         return;
     const row = sheet.getRow(number);
-    if (attrs.ht !== undefined && attrs.customHeight !== '0') {
-        const height = Number(attrs.ht);
-        if (Number.isFinite(height))
-            row.height = height;
-    }
+    const height = numFinite(attrs.ht);
+    if (height !== undefined && boolPresent(attrs.customHeight))
+        row.height = height;
     if (boolStrict(attrs.hidden))
         row.hidden = true;
-    if (attrs.outlineLevel !== undefined) {
-        const level = Number(attrs.outlineLevel);
-        if (Number.isInteger(level) && level > 0)
-            row.outlineLevel = level;
-    }
+    const outlineLevel = numInteger(attrs.outlineLevel, 1);
+    if (outlineLevel !== undefined)
+        row.outlineLevel = outlineLevel;
     if (boolStrict(attrs.collapsed))
         row.collapsed = true;
 }
@@ -411,31 +366,22 @@ function applyPrintOptions(printOptions, attrs) {
 }
 function applyMargins(margins, attrs) {
     for (const side of MARGIN_SIDES) {
-        const raw = attrs[side];
-        if (raw === undefined)
-            continue;
-        const value = Number(raw);
-        if (Number.isFinite(value))
+        const value = numFinite(attrs[side]);
+        if (value !== undefined)
             margins[side] = value;
     }
 }
 function applyPageSetup(pageSetup, attrs) {
-    const num = (raw) => {
-        if (raw === undefined)
-            return undefined;
-        const value = Number(raw);
-        return Number.isFinite(value) ? value : undefined;
-    };
-    const paperSize = num(attrs.paperSize);
+    const paperSize = numInteger(attrs.paperSize, 0);
     if (paperSize !== undefined)
         pageSetup.paperSize = paperSize;
-    const scale = num(attrs.scale);
+    const scale = numInteger(attrs.scale, 0);
     if (scale !== undefined)
         pageSetup.scale = scale;
-    const fitToWidth = num(attrs.fitToWidth);
+    const fitToWidth = numInteger(attrs.fitToWidth, 0);
     if (fitToWidth !== undefined)
         pageSetup.fitToWidth = fitToWidth;
-    const fitToHeight = num(attrs.fitToHeight);
+    const fitToHeight = numInteger(attrs.fitToHeight, 0);
     if (fitToHeight !== undefined)
         pageSetup.fitToHeight = fitToHeight;
     if (attrs.pageOrder === 'downThenOver' || attrs.pageOrder === 'overThenDown') {

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

@@ -1,5 +1,4 @@
 import { Workbook, type WorkbookView } from '../../core/workbook.ts';
-import { type WorkbookProtection } from '../../core/workbook-protection.ts';
 import type { WorksheetState } from '../../core/worksheet.ts';
 import { type ReadXlsxOptions } from '../opc/read-options.ts';
 export { parseRelationships, resolveWorkbookPart } from '../opc/read-opc.ts';
@@ -11,14 +10,14 @@ export { parseStyleTable } from './read-styles.ts';
  *
  * Both OOXML serialisations are accepted: an XML `.xlsx`, and a binary `.xlsb` (BIFF12), which is the
  * same OPC container with binary office-document parts. The two are auto-detected from the package
- * itself rather than from a file extension, so a caller never branches on which form it holds — and
+ * itself rather than from a file extension, so a caller never branches on which form it holds, and
  * the model produced is the same either way. See `../xlsb/read.ts` for what the binary path does not
  * yet decode.
  *
- * @throws {UnsupportedFormatError} if the input is neither — a legacy `.xls` (`.format === 'xls'`) or
+ * @throws {UnsupportedFormatError} if the input is neither: a legacy `.xls` (`.format === 'xls'`) or
  *   an unrecognised/non-ZIP blob (`'unknown'`).
  * @throws {XlsbParseError} if a binary `.xlsb` part is malformed.
- * @throws {PackageReadError} if the input is a ZIP that cannot be unpacked — a corrupt or
+ * @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;
@@ -28,5 +27,4 @@ export interface SheetEntry {
     readonly state?: WorksheetState['state'];
 }
 export declare function parseWorkbookSheets(xml: string): SheetEntry[];
-export declare function parseWorkbookProtection(xml: string): WorkbookProtection | undefined;
 export declare function applyWorkbookView(view: WorkbookView, xml: string): void;