@shbernal/ts-xlsx 3.0.0 → 3.1.0

package/dist/io/xlsx/row-xml.d.ts

@@ -0,0 +1,128 @@
+import { type Cell } from '../../core/cell.ts';
+import { type DateEpoch } from '../../core/date.ts';
+import type { ColumnProperties, RowProperties, Worksheet } from '../../core/worksheet.ts';
+import type { CommentCell } from './comments.ts';
+import type { CollectedHyperlink } from './hyperlinks.ts';
+import type { SharedFormulaRole } from './shared-formulas.ts';
+import type { SharedStringTable } from './shared-strings.ts';
+import type { StyleRegistry } from './styles.ts';
+/**
+ * The used-cell extent of a sheet: the top-left/bottom-right grid bounds that fold into the
+ * `<dimension>`. Rows carrying only formatting (a row height, an outline level) do not extend the
+ * used range, matching how Excel records `<dimension>`, so {@link add} ignores them. A fresh extent
+ * holds the `Infinity`/`-Infinity` sentinels; {@link isEmpty} reports that no used cell has been seen.
+ */
+export declare class Extent {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+    constructor(seed?: Extent);
+    /** Whether no used cell has been folded in yet, in which case the dimension is the lone cell `A1`. */
+    get isEmpty(): boolean;
+    /** Fold a rendered row's used-column span into the extent. `minCol` is `Infinity` when the row
+     * carried no cells (only formatting), which extends nothing. */
+    add(row: number, minCol: number, maxCol: number): void;
+}
+/**
+ * A row the streaming writer already serialised, kept with the attribute string it was built from.
+ *
+ * The attributes are carried rather than re-read out of `xml`, and that is the whole point of the
+ * field. `collapsed="1"` is decided after the row is gone (see {@link FlushedSheet.rowOutline}), so
+ * the summary row has to be patched, and the patcher used to ask `xml.includes(' collapsed="1"')`
+ * whether the attribute was already there. The `<row>` tag's shape is known, but the *cell text*
+ * embedded in it is not: `escapeText` leaves a double quote verbatim, so a cell whose value was the
+ * literal string ` collapsed="1"` answered that question for the row and left the outline group
+ * rendering expanded. A file cannot forge a field.
+ */
+export interface FlushedRow {
+    readonly number: number;
+    readonly xml: string;
+    /** The `<row>` element's own attributes, exactly as {@link renderRow} emitted them. */
+    readonly attrs: string;
+}
+/**
+ * A worksheet's eagerly-serialised rows: each row's `<row>` XML tagged with its number (so it merges
+ * into ascending order with the sheet's remaining live rows, whatever order it was committed in), plus
+ * the used-cell {@link Extent} they span. The buffered pass folds that extent into the sheet's dimension.
+ */
+export interface FlushedSheet {
+    readonly rows: readonly FlushedRow[];
+    readonly extent: Extent;
+    /**
+     * Each flushed row's outline level and hidden flag. Carried across the eviction because both feed
+     * whole-sheet derivations made long after the row is gone from the model: `<sheetFormatPr
+     * outlineLevelRow>` is the deepest level on the sheet, and `collapsed="1"` rides a summary row only
+     * when its whole detail group is hidden, which is a question about *other* rows.
+     *
+     * Carried as the two inputs rather than the derived flag, because the derivation is a look-ahead a
+     * row being finalised cannot do, while its inputs are per-row and known exactly when the row flushes.
+     */
+    readonly rowOutline: ReadonlyMap<number, {
+        readonly outlineLevel: number;
+        readonly hidden: boolean;
+    }>;
+    /**
+     * The hyperlinks and notes the flushed rows carried, on the same terms and for the same reason.
+     * Both are serialised outside the `<row>`: a hyperlink into the sheet's `<hyperlinks>` element plus
+     * an external relationship, a note into the comments and VML parts. The buffered pass gathers them
+     * by walking the sheet's rows at commit time, which finds nothing on a row whose cells have already
+     * been evicted, so a streamed row's link kept its visible label and silently lost its destination.
+     */
+    readonly hyperlinks: readonly CollectedHyperlink[];
+    readonly notes: readonly CommentCell[];
+}
+/**
+ * A column's style facets are defaults its cells inherit unless they override them; the writer
+ * composes each cell's full style up front (cell over row over column, per facet) so a cell that
+ * overrides one facet still carries the column's others, rather than silently dropping them. Frozen
+ * once by the streaming writer at its first flush so every eagerly-rendered row sees the same defaults.
+ */
+export declare function buildColumnDefaults(sheet: Worksheet): Map<number, ColumnProperties>;
+/** The whole-sheet context a single row needs to serialise: the column defaults it inherits, the
+ * style/string tables it interns into, the shared-formula roles its cells play, and the collapsed
+ * outline summaries whose toggle it must stamp. The streaming writer supplies empty shared-formula
+ * and collapsed-summary sets, since those are whole-sheet derivations a flushed row cannot join. */
+export interface RowRenderContext {
+    readonly columnDefaults: ReadonlyMap<number, ColumnProperties>;
+    readonly styles: StyleRegistry;
+    readonly sharedStrings: SharedStringTable | null;
+    readonly sharedRoles: ReadonlyMap<string, SharedFormulaRole>;
+    readonly collapsedSummaries: ReadonlySet<number>;
+    /** The workbook's date system, which is what a `Date` cell's serial counts from. */
+    readonly dateEpoch: DateEpoch;
+}
+/**
+ * Serialise one row to its `<row>` element, or '' when the row has neither data nor its own
+ * formatting. Returns the used-column bounds (`Infinity`/`-Infinity` when nothing was rendered) so a
+ * caller can fold them into the sheet dimension, and the attribute string separately, so a later pass
+ * can ask what this row declared without reading it back out of markup that also holds cell text.
+ * Shared by the buffered sheet pass and the streaming writer's eager flush, so both emit
+ * byte-identical rows.
+ */
+export declare function renderRow(entry: {
+    readonly number: number;
+    readonly cells: readonly Cell[];
+    readonly properties: RowProperties | undefined;
+}, ctx: RowRenderContext): {
+    xml: string;
+    attrs: string;
+    minCol: number;
+    maxCol: number;
+};
+/**
+ * The `<row>` element's opening tag up to its first attribute: the one thing a later pass may rely on
+ * about a rendered row's shape, spelled here so it is the emitter's own string rather than a
+ * re-parse of the emitter's output.
+ */
+export declare function rowOpenTag(number: number): string;
+/**
+ * Refuse an outline depth that is not a non-negative integer, naming what carried it.
+ *
+ * `xsd:unsignedInt` is the attribute's type, so this is what the schema already says. It is asserted
+ * rather than clamped because a negative level is also a hang: the writer finds a group's end by
+ * walking outwards while the neighbouring level exceeds the summary's, and every unmapped row
+ * answers `0`, which exceeds `-1` for as long as there are rows to walk.
+ */
+export declare function assertWritableLevel(name: string, level: number): void;
+export declare function outlineAttr(name: string, level: number | undefined): string;

package/dist/io/xlsx/row-xml.js

@@ -0,0 +1,203 @@
+import { cellHasOwnStyle } from '../../core/cell.js';
+import { DEFAULT_DATE_NUMFMT, dateToSerial } from '../../core/date.js';
+import { mangleFormula } from '../../core/formula.js';
+import { NAMED_STYLE_ID } from '../../core/internal.js';
+import { CELL_STYLE_FACETS } from '../../core/style.js';
+import { detectValueType, isDataTableFormulaValue, isErrorValue, isFormulaValue, isHyperlinkValue, isRichTextValue, isSharedFormulaValue, } from '../../core/value.js';
+import { AuthoringError, InternalError } from '../../errors.js';
+import { boolAttr, escapeAttr, escapeSpreadsheetText, escapeText, numberText, textAttr, textElement, } from '../../xml/xml.js';
+import { richTextRunsXml } from './rich-text.js';
+export class Extent {
+    top = Infinity;
+    left = Infinity;
+    bottom = -Infinity;
+    right = -Infinity;
+    constructor(seed) {
+        if (seed) {
+            this.top = seed.top;
+            this.left = seed.left;
+            this.bottom = seed.bottom;
+            this.right = seed.right;
+        }
+    }
+    get isEmpty() {
+        return this.bottom === -Infinity;
+    }
+    add(row, minCol, maxCol) {
+        if (minCol === Infinity)
+            return;
+        if (row < this.top)
+            this.top = row;
+        if (row > this.bottom)
+            this.bottom = row;
+        if (minCol < this.left)
+            this.left = minCol;
+        if (maxCol > this.right)
+            this.right = maxCol;
+    }
+}
+export function buildColumnDefaults(sheet) {
+    const columnDefaults = new Map();
+    for (const { index, properties } of sheet.columns())
+        columnDefaults.set(index, properties ?? {});
+    return columnDefaults;
+}
+export function renderRow(entry, ctx) {
+    const { number, cells, properties } = entry;
+    const rendered = cells.filter((cell) => cell.value !== null || cellHasOwnStyle(cell));
+    const attrs = rowAttrs(properties, ctx.styles, ctx.collapsedSummaries.has(number));
+    if (rendered.length === 0 && attrs === '') {
+        return { xml: '', attrs: '', minCol: Infinity, maxCol: -Infinity };
+    }
+    const rowFill = properties?.fill;
+    const cellsXml = rendered
+        .map((cell) => {
+        const style = ctx.styles.styleId(composeCellStyle(cell, rowFill, ctx.columnDefaults.get(cell.col)));
+        return cellXml(cell, style, ctx.sharedRoles.get(cell.address), ctx.sharedStrings, ctx.dateEpoch);
+    })
+        .join('');
+    let minCol = Infinity;
+    let maxCol = -Infinity;
+    for (const cell of rendered) {
+        if (cell.col < minCol)
+            minCol = cell.col;
+        if (cell.col > maxCol)
+            maxCol = cell.col;
+    }
+    return { xml: `${rowOpenTag(number)}${attrs}>${cellsXml}</row>`, attrs, minCol, maxCol };
+}
+export function rowOpenTag(number) {
+    return `<row r="${number}"`;
+}
+function composeCellStyle(cell, rowFill, colDef) {
+    const style = {};
+    for (const facet of CELL_STYLE_FACETS)
+        inheritFacet(style, facet, cell, colDef);
+    style.fill = cell.fill ?? rowFill ?? colDef?.fill;
+    style.numFmt = cell.numFmt ?? colDef?.numFmt ?? dateDefaultNumFmt(cell.value);
+    if (cell.quotePrefix !== undefined)
+        style.quotePrefix = cell.quotePrefix;
+    const xfId = cell[NAMED_STYLE_ID];
+    if (xfId !== undefined)
+        style.xfId = xfId;
+    return style;
+}
+function inheritFacet(target, key, cell, colDef) {
+    target[key] = cell[key] ?? colDef?.[key];
+}
+function rowAttrs(properties, styles, collapsedSummary) {
+    if (properties === undefined)
+        return collapsedSummary ? ' collapsed="1"' : '';
+    let attrs = '';
+    if (properties.height !== undefined)
+        attrs += ` ht="${numberText(properties.height)}" customHeight="1"`;
+    if (properties.hidden)
+        attrs += ' hidden="1"';
+    attrs += outlineAttr('outlineLevel', properties.outlineLevel);
+    if (properties.collapsed || collapsedSummary)
+        attrs += ' collapsed="1"';
+    const style = styles.styleId({ fill: properties.fill });
+    if (style !== 0)
+        attrs += ` s="${style}" customFormat="1"`;
+    return attrs;
+}
+function dateDefaultNumFmt(value) {
+    const date = value instanceof Date
+        ? value
+        : (isFormulaValue(value) || isSharedFormulaValue(value)) && value.result instanceof Date
+            ? value.result
+            : undefined;
+    return date !== undefined && !Number.isNaN(date.getTime()) ? DEFAULT_DATE_NUMFMT : undefined;
+}
+function cellElement(ref, s, type, body) {
+    const t = type === '' ? '' : ` t="${type}"`;
+    return body === '' ? `<c r="${ref}"${s}${t}/>` : `<c r="${ref}"${s}${t}>${body}</c>`;
+}
+const UNWRITABLE = { type: '', v: null };
+const vElement = (v) => (v === null ? '' : `<v>${v}</v>`);
+function valueBody(value, epoch) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? { type: '', v: numberText(value) } : UNWRITABLE;
+    }
+    if (typeof value === 'boolean')
+        return { type: 'b', v: value ? '1' : '0' };
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime())
+            ? UNWRITABLE
+            : { type: '', v: numberText(dateToSerial(value, epoch)) };
+    }
+    if (isErrorValue(value))
+        return { type: 'e', v: value.error };
+    return undefined;
+}
+function cellXml(cell, style, shared, sharedStrings, epoch) {
+    const ref = cell.address;
+    const value = cell.value;
+    const s = style !== 0 ? ` s="${style}"` : '';
+    const formula = cellFormulaXml(ref, s, value, shared, epoch);
+    if (formula !== undefined)
+        return formula;
+    const body = valueBody(value, epoch);
+    if (body !== undefined)
+        return cellElement(ref, s, body.type, vElement(body.v));
+    if (typeof value === 'string' || isRichTextValue(value)) {
+        if (sharedStrings !== null) {
+            return cellElement(ref, s, 's', vElement(`${sharedStrings.intern(value)}`));
+        }
+        const inline = typeof value === 'string' ? textElement(value) : richTextRunsXml(value.richText);
+        return cellElement(ref, s, 'inlineStr', `<is>${inline}</is>`);
+    }
+    if (isHyperlinkValue(value)) {
+        const label = typeof value.text === 'string'
+            ? textElement(value.text)
+            : richTextRunsXml(value.text.richText);
+        return cellElement(ref, s, 'inlineStr', `<is>${label}</is>`);
+    }
+    if (value === null)
+        return cellElement(ref, s, '', '');
+    throw new InternalError(`writing a ${detectValueType(value)} cell value has no arm: every CellValue kind is handled above`);
+}
+function cellFormulaXml(ref, s, value, shared, epoch) {
+    if (shared !== undefined) {
+        if (shared.ref !== undefined && isFormulaValue(value)) {
+            const f = `<f t="shared" ref="${shared.ref}" si="${shared.si}">${escapeText(mangleFormula(value.formula))}</f>`;
+            return formulaBodyXml(ref, s, f, value.result, epoch);
+        }
+        const result = isSharedFormulaValue(value) ? value.result : undefined;
+        return formulaBodyXml(ref, s, `<f t="shared" si="${shared.si}"/>`, result, epoch);
+    }
+    if (isDataTableFormulaValue(value)) {
+        const attrs = `ref="${escapeAttr(value.ref)}"` +
+            boolAttr('dt2D', value.dataTable2D) +
+            boolAttr('dtr', value.dataTableRow) +
+            textAttr('r1', value.r1) +
+            textAttr('r2', value.r2);
+        return formulaBodyXml(ref, s, `<f t="dataTable" ${attrs}/>`, value.result, epoch);
+    }
+    if (isFormulaValue(value)) {
+        return formulaBodyXml(ref, s, `<f>${escapeText(mangleFormula(value.formula))}</f>`, value.result, epoch);
+    }
+    return undefined;
+}
+function formulaBodyXml(ref, s, f, result, epoch) {
+    if (result === undefined)
+        return cellElement(ref, s, '', f);
+    const body = valueBody(result, epoch);
+    if (body !== undefined)
+        return cellElement(ref, s, body.type, f + vElement(body.v));
+    if (typeof result === 'string') {
+        return cellElement(ref, s, 'str', f + vElement(escapeSpreadsheetText(result)));
+    }
+    throw new InternalError('writing a non-primitive formula result has no arm: every FormulaResult kind is handled above');
+}
+export function assertWritableLevel(name, level) {
+    if (Number.isInteger(level) && level >= 0)
+        return;
+    throw new AuthoringError(`${name} must be a non-negative integer, not ${level}`);
+}
+export function outlineAttr(name, level) {
+    if (level === undefined)
+        return '';
+    assertWritableLevel(name, level);
+    return level > 0 ? ` ${name}="${numberText(level)}"` : '';
+}

package/dist/io/xlsx/shared-formulas.js

@@ -1,4 +1,4 @@
-import { encodeAddress } from '../../core/address.js';
+import { encodeRect } from '../../core/address.js';
 import { isFormulaValue, isSharedFormulaValue } from '../../core/value.js';
 import { AuthoringError } from '../../errors.js';
 export function planSharedFormulas(sheet) {
@@ -35,7 +35,7 @@ export function planSharedFormulas(sheet) {
         }
         roles.set(masterAddress, {
             si,
-            ref: `${encodeAddress(master.col, master.row)}:${encodeAddress(maxCol, maxRow)}`,
+            ref: encodeRect({ top: master.row, left: master.col, bottom: maxRow, right: maxCol }),
         });
         for (const clone of clones)
             roles.set(clone.address, { si });

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

@@ -1,7 +1,8 @@
-import type { AutoFilter } from '../../core/autofilter.ts';
+import { type AutoFilter } from '../../core/autofilter.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';
+import { type XmlAttributes } from '../../xml/xml-scan.ts';
 export declare function sheetViewsXml(view: SheetView, active: boolean): string;
 export declare function sheetPrXml(sheet: Worksheet): string;
 export declare function sheetProtectionXml(protection: SheetProtection | undefined): string;
@@ -11,3 +12,11 @@ export declare function printOptionsXml(printOptions: PrintOptions): string;
 export declare function pageMarginsXml(margins: PageMargins): string;
 export declare function pageSetupXml(pageSetup: PageSetup, printerSettingsRelId: string | null): string;
 export declare function pageBreaksXml(breaks: readonly PageBreak[], element: 'rowBreaks' | 'colBreaks'): string;
+export declare function parseSheetProtection(attrs: XmlAttributes): SheetProtection | undefined;
+export declare class PageBreakAccumulator {
+    #private;
+    begin(target: PageBreak[]): void;
+    end(): void;
+    add(attrs: XmlAttributes): void;
+}
+export declare function applySheetProperties(local: string, attrs: XmlAttributes, sheet: Worksheet): void;

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

@@ -1,8 +1,11 @@
 import { encodeAddress } from '../../core/address.js';
+import { isCustomFilterOperator, } from '../../core/autofilter.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 { SHEET_PROTECTION_FLAGS, } from '../../core/protection.js';
+import { numFinite, numInteger } from '../../xml/xml-attrs.js';
+import { boolPresent, boolStrict, boolTristate } from '../../xml/xml-scan.js';
 import { boolAttr, checkedToken, escapeAttr, escapeSpreadsheetText, numAttr, numberText, } from '../../xml/xml.js';
-import { colorAttrs } from './color-xml.js';
+import { colorAttrs, parseColor } from './color-xml.js';
 export function sheetViewsXml(view, active) {
     const selected = active ? ' tabSelected="1"' : '';
     const gridLines = view.showGridLines === false ? ' showGridLines="0"' : '';
@@ -21,10 +24,13 @@ export function sheetViewsXml(view, active) {
     return `<sheetViews><sheetView${gridLines}${selected} workbookViewId="0">${pane}${selection}</sheetView></sheetViews>`;
 }
 export function sheetPrXml(sheet) {
+    const attrs = sheet.codeName === undefined ? '' : ` codeName="${escapeAttr(sheet.codeName)}"`;
     const children = (sheet.tabColor !== undefined ? `<tabColor ${colorAttrs(sheet.tabColor)}/>` : '') +
         outlinePrXml(sheet.outline) +
         pageSetUpPrXml(sheet.pageSetup);
-    return children === '' ? '' : `<sheetPr>${children}</sheetPr>`;
+    if (attrs === '' && children === '')
+        return '';
+    return children === '' ? `<sheetPr${attrs}/>` : `<sheetPr${attrs}>${children}</sheetPr>`;
 }
 function pageSetUpPrXml(pageSetup) {
     return pageSetup.fitToPage ? '<pageSetUpPr fitToPage="1"/>' : '';
@@ -40,10 +46,10 @@ export function sheetProtectionXml(protection) {
     let attrs = '';
     if (credential !== undefined) {
         attrs +=
-            ` algorithmName="${credential.algorithmName}"` +
-                ` hashValue="${credential.hashValue}"` +
-                ` saltValue="${credential.saltValue}"` +
-                ` spinCount="${credential.spinCount}"`;
+            ` algorithmName="${escapeAttr(credential.algorithmName)}"` +
+                ` hashValue="${escapeAttr(credential.hashValue)}"` +
+                ` saltValue="${escapeAttr(credential.saltValue)}"` +
+                numAttr('spinCount', credential.spinCount);
     }
     attrs += ' sheet="1"';
     for (const { key, defaultForbidden } of SHEET_PROTECTION_FLAGS) {
@@ -66,7 +72,7 @@ export function autoFilterXml(filter) {
     return `<autoFilter ref="${ref}">${filter.columns.map(filterColumnXml).join('')}</autoFilter>`;
 }
 function filterColumnXml(column) {
-    return `<filterColumn colId="${column.colId}">${filterCriteriaXml(column.criteria)}</filterColumn>`;
+    return `<filterColumn colId="${numberText(column.colId)}">${filterCriteriaXml(column.criteria)}</filterColumn>`;
 }
 function filterCriteriaXml(criteria) {
     if (criteria.kind === 'values') {
@@ -76,7 +82,7 @@ function filterCriteriaXml(criteria) {
     }
     const andAttr = criteria.and ? ' and="1"' : '';
     const predicates = criteria.predicates
-        .map((p) => `<customFilter operator="${p.operator}" val="${escapeAttr(p.val)}"/>`)
+        .map((p) => `<customFilter operator="${checkedToken(p.operator, isCustomFilterOperator, 'custom filter operator')}" val="${escapeAttr(p.val)}"/>`)
         .join('');
     return `<customFilters${andAttr}>${predicates}</customFilters>`;
 }
@@ -144,3 +150,133 @@ export function pageBreaksXml(breaks, element) {
         .join('');
     return `<${element} count="${breaks.length}" manualBreakCount="${breaks.length}">${brks}</${element}>`;
 }
+export 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 };
+}
+export 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 applySheetProperties(local, attrs, sheet) {
+    switch (local) {
+        case 'sheetPr':
+            if (attrs.codeName !== undefined)
+                sheet.codeName = attrs.codeName;
+            break;
+        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 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/style-elements.d.ts

@@ -0,0 +1,43 @@
+import { type Alignment, type Border, type Fill, type Protection } from '../../core/style.ts';
+import type { DifferentialStyle } from '../../core/workbook-styles.ts';
+export declare const CUSTOM_NUMFMT_BASE = 164;
+export declare const DEFAULT_FONT_BODY = "<sz val=\"11\"/><color theme=\"1\"/><name val=\"Calibri\"/><family val=\"2\"/><scheme val=\"minor\"/>";
+export declare const DEFAULT_BORDER = "<border><left/><right/><top/><bottom/><diagonal/></border>";
+export interface CellFormat {
+    readonly fillId: number;
+    readonly numFmtId: number;
+    readonly fontId: number;
+    readonly borderId: number;
+    readonly alignment: string;
+    readonly protection: string;
+    readonly quotePrefix: boolean;
+    readonly xfId: number;
+}
+export declare const DEFAULT_FORMAT: CellFormat;
+export declare function formatSignature(format: CellFormat): string;
+/**
+ * Whether a format is the do-nothing default: no facet, General number format, no quote prefix, and
+ * linked to the Normal named style. Such a cellXfs entry adds nothing, so its owner needs no `s`.
+ *
+ * Asked of the signature rather than field by field, because the two questions have to be answered
+ * from the same field set and both answer silently when they are not. A facet the signature forgets
+ * makes two distinct formats intern to one entry, and every cell carrying the facet quietly loses it;
+ * a facet *this* forgets forces a spurious entry and an `s` attribute onto every cell in the book.
+ * Neither is a type error, and neither is visible in the file until someone compares two of them.
+ */
+export declare function isDefaultFormat(format: CellFormat): boolean;
+export declare function xfXml(format: CellFormat, xfId: number | null): string;
+export declare function cellStyleTag(entry: {
+    name: string;
+    builtinId?: number;
+    xfId: number;
+}): string;
+export declare function alignmentAttrs(alignment: Alignment): string;
+export declare function protectionAttrs(protection: Protection): string;
+export declare function tableStyleName(fragment: string): string;
+export declare function dxfXml(style: DifferentialStyle): string;
+export declare function borderXml(border: Border): string;
+export declare function fillSignature(fill: Fill): string;
+export declare function patternFillXml(fill: Fill, { solidBgFallback }: {
+    solidBgFallback: boolean;
+}): string;