@shbernal/ts-xlsx 2.0.0 → 2.1.0

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

@@ -1,9 +1,10 @@
-import { decodeRange, MAX_COLUMN, MAX_ROW } from '../../core/address.js';
+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 { SHEET_PROTECTION_FLAGS, } from '../../core/protection.js';
 import { assignStyleFacets } from '../../core/style.js';
-import { boolPresent, boolStrict, boolTristate, decodeSpreadsheetText, localName, numFinite, numInteger, parseXml, } from '../../xml/xml-read.js';
+import { boolPresent, boolStrict, boolTristate, decodeSpreadsheetText, enumToken, 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'];
@@ -90,13 +91,13 @@ class AutoFilterAccumulator {
     commit(sheet) {
         if (this.#ref === null)
             return;
-        try {
-            const { left, right } = decodeRange(this.#ref);
-            const width = left !== undefined && right !== undefined ? right - left + 1 : 0;
+        const decoded = tryDecodeRange(this.#ref);
+        const left = decoded?.left;
+        const right = decoded?.right;
+        if (left !== undefined && right !== undefined) {
+            const width = right - left + 1;
             sheet.autoFilter = { ref: this.#ref, columns: this.#columns.filter((c) => c.colId < width) };
         }
-        catch {
-        }
         this.#ref = null;
         this.#columns = [];
     }
@@ -214,9 +215,6 @@ export function parseWorksheet(xml, sheet, sharedStrings, xfStyles) {
                 case 'customFilter':
                     autoFilter.addCustom(attrs);
                     break;
-                default:
-                    cell.runs.applyProperty(local, attrs);
-                    break;
             }
         },
         onText(chunk) {
@@ -384,10 +382,10 @@ function applyPageSetup(pageSetup, attrs) {
     const fitToHeight = numInteger(attrs.fitToHeight, 0);
     if (fitToHeight !== undefined)
         pageSetup.fitToHeight = fitToHeight;
-    if (attrs.pageOrder === 'downThenOver' || attrs.pageOrder === 'overThenDown') {
-        pageSetup.pageOrder = attrs.pageOrder;
-    }
-    if (attrs.orientation === 'portrait' || attrs.orientation === 'landscape') {
-        pageSetup.orientation = attrs.orientation;
-    }
+    const pageOrder = enumToken(attrs.pageOrder, isPageOrder);
+    if (pageOrder !== undefined)
+        pageSetup.pageOrder = pageOrder;
+    const orientation = enumToken(attrs.orientation, isPageOrientation);
+    if (orientation !== undefined)
+        pageSetup.orientation = orientation;
 }

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

@@ -1,5 +1,5 @@
 import { Workbook, type WorkbookView } from '../../core/workbook.ts';
-import type { WorksheetState } from '../../core/worksheet.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';

package/dist/io/xlsx/read.js

@@ -3,7 +3,8 @@ import { unmangleFunctions } from '../../core/formula.js';
 import { INTERNAL } from '../../core/internal.js';
 import { WORKBOOK_PROTECTION_CREDENTIAL_ATTRS, } from '../../core/workbook-protection.js';
 import { Workbook } from '../../core/workbook.js';
-import { boolStrict, localName, numInteger, openElements, parseXml } from '../../xml/xml-read.js';
+import { isVisibility } from '../../core/worksheet.js';
+import { boolStrict, capturedText, enumToken, localName, numInteger, openElements, parseXml, } from '../../xml/xml-read.js';
 import { UnsupportedFormatError } from '../opc/errors.js';
 import { extensionOf } from '../opc/part-paths.js';
 import { capturePartClosure, contentTypeResolver, packageAccessors, parseRelationshipRecords, parseRelationships, readPartRelationships, relationshipTargetByType, resolveRelativePart, resolveWorkbookPart, } from '../opc/read-opc.js';
@@ -143,8 +144,19 @@ function readSheetPrinterSettings(sheetRels, pkg) {
     const path = sheetRels.targetPath('printerSettings');
     return path === undefined ? undefined : pkg.partBytes(path);
 }
+function internImage(workbook, pkg, imageIdByMediaPath, mediaPath) {
+    const known = imageIdByMediaPath.get(mediaPath);
+    if (known !== undefined)
+        return known;
+    const bytes = pkg.partBytes(mediaPath);
+    if (bytes === undefined)
+        return undefined;
+    const id = workbook.addImage({ buffer: bytes, extension: extensionOf(mediaPath) });
+    imageIdByMediaPath.set(mediaPath, id);
+    return id;
+}
 function readSheetImages(sheetRels, pkg, workbook, sheet, imageIdByMediaPath) {
-    const { partText, partBytes } = pkg;
+    const { partText } = pkg;
     const drawingPath = sheetRels.targetPath('drawing');
     if (drawingPath === undefined)
         return;
@@ -159,14 +171,9 @@ function readSheetImages(sheetRels, pkg, workbook, sheet, imageIdByMediaPath) {
         if (embedded === undefined)
             continue;
         const mediaPath = drawingRels.pathOf(embedded.target);
-        let id = imageIdByMediaPath.get(mediaPath);
-        if (id === undefined) {
-            const bytes = partBytes(mediaPath);
-            if (bytes === undefined)
-                continue;
-            id = workbook.addImage({ buffer: bytes, extension: extensionOf(mediaPath) });
-            imageIdByMediaPath.set(mediaPath, id);
-        }
+        const id = internImage(workbook, pkg, imageIdByMediaPath, mediaPath);
+        if (id === undefined)
+            continue;
         const rot = anchor.rotation !== undefined ? { rotation: anchor.rotation } : {};
         if (anchor.to !== undefined) {
             const mode = anchor.editAs !== undefined ? { editAs: anchor.editAs } : {};
@@ -181,15 +188,9 @@ function readSheetBackground(sheetRels, pkg, workbook, sheet, imageIdByMediaPath
     const mediaPath = sheetRels.targetPath('image');
     if (mediaPath === undefined)
         return;
-    let id = imageIdByMediaPath.get(mediaPath);
-    if (id === undefined) {
-        const bytes = pkg.partBytes(mediaPath);
-        if (bytes === undefined)
-            return;
-        id = workbook.addImage({ buffer: bytes, extension: extensionOf(mediaPath) });
-        imageIdByMediaPath.set(mediaPath, id);
-    }
-    sheet.addBackgroundImage(id);
+    const id = internImage(workbook, pkg, imageIdByMediaPath, mediaPath);
+    if (id !== undefined)
+        sheet.addBackgroundImage(id);
 }
 function readSheetPreservedReferences(sheetRels, sheetXml, pkg, contentTypeOf, sheet) {
     const { partText, partBytes } = pkg;
@@ -337,8 +338,9 @@ export function parseWorkbookSheets(xml) {
             name: attrs.name ?? '',
             relId: attrs['r:id'] ?? '',
         };
-        if (attrs.state === 'hidden' || attrs.state === 'veryHidden')
-            entry.state = attrs.state;
+        const state = enumToken(attrs.state, isVisibility);
+        if (state !== undefined && state !== 'visible')
+            entry.state = state;
         sheets.push(entry);
     }
     return sheets;
@@ -386,9 +388,9 @@ export function applyWorkbookView(view, xml) {
         const activeTab = numInteger(attrs.activeTab, 0);
         if (activeTab !== undefined)
             view.activeTab = activeTab;
-        if (attrs.visibility === 'hidden' || attrs.visibility === 'veryHidden') {
-            view.visibility = attrs.visibility;
-        }
+        const visibility = enumToken(attrs.visibility, isVisibility);
+        if (visibility !== undefined && visibility !== 'visible')
+            view.visibility = visibility;
         if (boolStrict(attrs.minimized))
             view.minimized = true;
         return;
@@ -439,57 +441,25 @@ const CORE_PROPERTY_LOCAL_NAMES = new Set([
     'modified',
 ]);
 function applyCoreProperties(workbook, xml) {
-    let capture = '';
-    let text = '';
-    parseXml(xml, {
-        onOpen(name) {
-            const local = localName(name);
-            capture = CORE_PROPERTY_LOCAL_NAMES.has(local) ? local : '';
-            text = '';
-        },
-        onText(chunk) {
-            if (capture !== '')
-                text += chunk;
-        },
-        onClose(name) {
-            if (capture === '' || localName(name) !== capture)
-                return;
-            if (capture === 'title')
-                workbook.properties.title = text;
-            else if (capture === 'creator')
-                workbook.properties.creator = text;
-            else if (capture === 'lastModifiedBy')
-                workbook.properties.lastModifiedBy = text;
-            else {
-                const date = new Date(text);
-                if (!Number.isNaN(date.getTime())) {
-                    if (capture === 'created')
-                        workbook.properties.created = date;
-                    else
-                        workbook.properties.modified = date;
-                }
+    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 = new Date(text);
+            if (!Number.isNaN(date.getTime())) {
+                if (local === 'created')
+                    workbook.properties.created = date;
+                else
+                    workbook.properties.modified = date;
             }
-            capture = '';
-        },
-    });
+        }
+    }
 }
 function applyAppProperties(workbook, xml) {
-    let capture = false;
-    let text = '';
-    parseXml(xml, {
-        onOpen(name) {
-            capture = localName(name) === 'Company';
-            text = '';
-        },
-        onText(chunk) {
-            if (capture)
-                text += chunk;
-        },
-        onClose(name) {
-            if (!capture || localName(name) !== 'Company')
-                return;
-            workbook.properties.company = text;
-            capture = false;
-        },
-    });
+    for (const { text } of capturedText(xml, 'Company'))
+        workbook.properties.company = text;
 }

package/dist/io/xlsx/rich-runs.d.ts

@@ -1,13 +1,47 @@
 import type { RichTextRun } from '../../core/value.ts';
-import type { XmlAttributes } from '../../xml/xml-read.ts';
+import { type XmlAttributes } from '../../xml/xml-read.ts';
+/**
+ * What {@link RunAccumulator.close} did with an element: `'container'` means the `<si>`/`<is>` itself
+ * closed and the caller should commit whatever it makes of the gathered runs, the one step the two
+ * readers do differently; `'claimed'` means the machine handled it; `'other'` leaves it to the caller.
+ *
+ * Three values rather than a boolean because both callers need to tell "the machine dealt with it"
+ * from "your string is complete", and a boolean would mean something different to each of them.
+ */
+export type RunClose = 'claimed' | 'container' | 'other';
 export declare class RunAccumulator {
     #private;
-    beginContainer(): void;
+    /**
+     * @param options.container the element that opens one string: `'si'` for the shared-string pool,
+     * `'is'` for an inline string in a worksheet body.
+     * @param options.readRuns whether `<r>`/`<rPr>` open a rich-text run. The buffered readers read
+     * them; the row stream deliberately does not, and with runs off every `<t>` falls through to
+     * {@link plainText}, which is exactly the documented flattening.
+     */
+    constructor(options: {
+        readonly container: 'si' | 'is';
+        readonly readRuns: boolean;
+    });
     /** The runs gathered so far. */
     get runs(): RichTextRun[];
-    beginRun(): void;
-    beginProperties(): void;
-    applyProperty(local: string, attrs: XmlAttributes): void;
-    appendText(text: string): boolean;
-    endRun(): void;
+    /** Whether the container held at least one `<r>`: what decides rich text from a plain string. */
+    get isRich(): boolean;
+    /** The container's own text: every `<t>` no run claimed, concatenated and already unescaped. */
+    get plainText(): string;
+    /**
+     * Open a string container by discarding whatever the last one gathered. Called for the machine's
+     * own container automatically; a caller whose own element may *hold* one (a `<c>` around an
+     * `<is>`) calls it too, or that container inherits the previous one's runs, which is the one way
+     * this accumulator can be misused.
+     *
+     * A new array is installed rather than the existing one emptied, so a value already built from the
+     * last container's runs keeps its own array.
+     */
+    beginContainer(): void;
+    /** Drive one element open, and return whether it was one of this machine's own. */
+    open(local: string, attrs: XmlAttributes, selfClosing: boolean): boolean;
+    /** Feed one run of character data. Ignored unless a `<t>` is open. */
+    text(chunk: string): void;
+    /** Drive one element close. See {@link RunClose}. */
+    close(local: string): RunClose;
 }

package/dist/io/xlsx/rich-runs.js

@@ -1,43 +1,107 @@
+import { decodeSpreadsheetText, TextCapture } from '../../xml/xml-read.js';
 import { applyFontChild } from './read-styles.js';
 export class RunAccumulator {
+    #container;
+    #readRuns;
+    #capture = new TextCapture('t');
     #runs = [];
     #font = null;
-    #text = '';
+    #inProperties = false;
+    #runText = '';
+    #plain = '';
     #inRun = false;
-    beginContainer() {
-        this.#runs = [];
-        this.#font = null;
-        this.#inRun = false;
+    #isRich = false;
+    #inContainer = false;
+    constructor(options) {
+        this.#container = options.container;
+        this.#readRuns = options.readRuns;
     }
     get runs() {
         return this.#runs;
     }
-    beginRun() {
-        this.#inRun = true;
+    get isRich() {
+        return this.#isRich;
+    }
+    get plainText() {
+        return this.#plain;
+    }
+    beginContainer() {
+        this.#runs = [];
         this.#font = null;
-        this.#text = '';
-    }
-    beginProperties() {
-        if (this.#inRun)
-            this.#font = {};
-    }
-    applyProperty(local, attrs) {
-        if (this.#font !== null)
-            applyFontChild(this.#font, local, attrs);
-    }
-    appendText(text) {
-        if (!this.#inRun)
-            return false;
-        this.#text += text;
-        return true;
-    }
-    endRun() {
-        if (!this.#inRun)
-            return;
-        const run = { text: this.#text };
-        if (this.#font !== null && Object.keys(this.#font).length > 0)
-            run.font = this.#font;
-        this.#runs.push(run);
+        this.#inProperties = false;
+        this.#runText = '';
+        this.#plain = '';
         this.#inRun = false;
+        this.#isRich = false;
+    }
+    open(local, attrs, selfClosing) {
+        switch (local) {
+            case this.#container:
+                this.#inContainer = true;
+                this.beginContainer();
+                return true;
+            case 'r':
+                if (!this.#readRuns || !this.#inContainer)
+                    return false;
+                this.#isRich = true;
+                this.#inRun = true;
+                this.#font = null;
+                this.#inProperties = false;
+                this.#runText = '';
+                return true;
+            case 'rPr':
+                if (!this.#readRuns || !this.#inRun)
+                    return false;
+                this.#font = {};
+                this.#inProperties = true;
+                return true;
+            case 't':
+                this.#capture.open(local, selfClosing);
+                return true;
+            default:
+                if (!this.#inProperties || this.#font === null)
+                    return false;
+                applyFontChild(this.#font, local, attrs);
+                return true;
+        }
+    }
+    text(chunk) {
+        this.#capture.text(chunk);
+    }
+    close(local) {
+        switch (local) {
+            case 't': {
+                const text = this.#capture.close(local);
+                if (text !== undefined) {
+                    const decoded = decodeSpreadsheetText(text);
+                    if (this.#inRun)
+                        this.#runText += decoded;
+                    else if (this.#inContainer)
+                        this.#plain += decoded;
+                }
+                return 'claimed';
+            }
+            case 'rPr':
+                if (!this.#readRuns || !this.#inProperties)
+                    return 'other';
+                this.#inProperties = false;
+                return 'claimed';
+            case 'r': {
+                if (!this.#readRuns || !this.#inRun)
+                    return 'other';
+                this.#inProperties = false;
+                const run = { text: this.#runText };
+                if (this.#font !== null && Object.keys(this.#font).length > 0)
+                    run.font = this.#font;
+                this.#runs.push(run);
+                this.#inRun = false;
+                return 'claimed';
+            }
+            case this.#container:
+                this.#inContainer = false;
+                return 'container';
+            default:
+                return 'other';
+        }
     }
 }

package/dist/io/xlsx/sheet-properties.d.ts

@@ -1,5 +1,5 @@
 import type { AutoFilter } from '../../core/autofilter.ts';
-import type { HeaderFooter, PageBreak, PageMargins, PageSetup, PrintOptions } from '../../core/page-setup.ts';
+import { type HeaderFooter, type PageBreak, type PageMargins, type PageSetup, type PrintOptions } from '../../core/page-setup.ts';
 import { type SheetProtection } from '../../core/protection.ts';
 import type { SheetView, Worksheet } from '../../core/worksheet.ts';
 export declare function sheetViewsXml(view: SheetView, active: boolean): string;

package/dist/io/xlsx/sheet-properties.js

@@ -1,6 +1,7 @@
 import { encodeAddress } from '../../core/address.js';
+import { isPageOrder, isPageOrientation, } from '../../core/page-setup.js';
 import { SHEET_PROTECTION_FLAGS } from '../../core/protection.js';
-import { attr, boolAttr, escapeAttr, escapeSpreadsheetText, numberText } from '../../xml/xml.js';
+import { boolAttr, checkedToken, escapeAttr, escapeSpreadsheetText, numAttr, numberText, } from '../../xml/xml.js';
 import { colorAttrs } from './color-xml.js';
 export function sheetViewsXml(view, active) {
     const selected = active ? ' tabSelected="1"' : '';
@@ -127,12 +128,16 @@ export function pageMarginsXml(margins) {
     return `<pageMargins ${attrs}/>`;
 }
 export function pageSetupXml(pageSetup, printerSettingsRelId) {
-    const attrs = attr('paperSize', pageSetup.paperSize) +
-        attr('scale', pageSetup.scale) +
-        attr('fitToWidth', pageSetup.fitToWidth) +
-        attr('fitToHeight', pageSetup.fitToHeight) +
-        (pageSetup.pageOrder !== undefined ? ` pageOrder="${pageSetup.pageOrder}"` : '') +
-        (pageSetup.orientation !== undefined ? ` orientation="${pageSetup.orientation}"` : '') +
+    const attrs = numAttr('paperSize', pageSetup.paperSize) +
+        numAttr('scale', pageSetup.scale) +
+        numAttr('fitToWidth', pageSetup.fitToWidth) +
+        numAttr('fitToHeight', pageSetup.fitToHeight) +
+        (pageSetup.pageOrder === undefined
+            ? ''
+            : ` pageOrder="${checkedToken(pageSetup.pageOrder, isPageOrder, 'page order')}"`) +
+        (pageSetup.orientation === undefined
+            ? ''
+            : ` orientation="${checkedToken(pageSetup.orientation, isPageOrientation, 'page orientation')}"`) +
         (printerSettingsRelId !== null ? ` r:id="${printerSettingsRelId}"` : '');
     return attrs === '' ? '' : `<pageSetup${attrs}/>`;
 }
@@ -141,8 +146,7 @@ export function pageBreaksXml(breaks, element) {
         return '';
     const brks = breaks
         .map((brk) => {
-        const maxAttr = brk.max !== undefined ? ` max="${brk.max}"` : '';
-        return `<brk id="${brk.id}"${maxAttr} man="1"/>`;
+        return `<brk${numAttr('id', brk.id)}${numAttr('max', brk.max)} man="1"/>`;
     })
         .join('');
     return `<${element} count="${breaks.length}" manualBreakCount="${breaks.length}">${brks}</${element}>`;

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

@@ -1,18 +1,6 @@
-import { type Alignment, type Border, type DifferentialStyle, type Fill, type Font, type NamedCellStyle, type Protection, type TableStyleTable } from '../../core/style.ts';
+import { type DifferentialStyle, type Font, type NamedCellStyle, type TableStyleTable } from '../../core/style.ts';
 import { type TableStyle } from '../../core/table-style.ts';
-/** A cell's style facets as the writer composes them: cell overrides atop row/column defaults. */
-export interface CellStyle {
-    readonly fill?: Fill | undefined;
-    readonly numFmt?: string | undefined;
-    readonly font?: Font | undefined;
-    readonly border?: Border | undefined;
-    readonly alignment?: Alignment | undefined;
-    readonly protection?: Protection | undefined;
-    /** The quote-prefix flag: an attribute on the xf, not a shared sub-table entry. */
-    readonly quotePrefix?: boolean | undefined;
-    /** The `xfId` link into `cellStyleXfs`: the named cell style this format inherits from (0 = Normal). */
-    readonly xfId?: number | undefined;
-}
+import type { XfStyle } from '../style/xf-style.ts';
 /** What a {@link StyleRegistry} needs from its workbook before any style is interned. */
 export interface StyleRegistryOptions {
     /**
@@ -41,7 +29,7 @@ export declare class StyleRegistry {
      * The `<cellXfs>` index for a composed cell/row/column style. A style with no facet needs
      * no entry and resolves to the default xf 0, so its owner emits no `s` attribute at all.
      */
-    styleId(style: CellStyle): number;
+    styleId(style: XfStyle): number;
     /**
      * Seed the named cell styles (`<cellStyleXfs>`/`<cellStyles>`) read from a file, in place of the
      * lone default, interning each style's facets into the shared sub-tables so its `fillId`/`fontId`/…