@shbernal/ts-xlsx 1.1.0 → 1.3.1

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

@@ -1,29 +1,10 @@
-// The shared-strings table: `xl/sharedStrings.xml`, the workbook-wide pool a `t="s"` cell indexes.
-//
-// When the writer runs with `useSharedStrings`, a plain string cell value is interned here — an
-// identical string is stored once and every cell holding it references the single `<si>` entry by
-// index — rather than repeating the text inline in each cell. This trades a second part and an
-// indirection for a smaller package when strings repeat, the storage Excel itself prefers.
-//
-// Both plain strings and rich text are pooled: a plain value becomes a `<si><t>…</t></si>` entry, a
-// rich value a `<si><r>…</r>…</si>` entry carrying its per-run formatting — the rich `<si>` runs Excel
-// itself writes. A `t="s"` cell then indexes either, and the reader reconstructs the runs, so pooled
-// rich text round-trips its formatting rather than flattening to text.
 import { textElement, XML_DECLARATION } from '../../xml/xml.js';
 import { SPREADSHEETML_NS } from './namespaces.js';
 import { richTextRunsXml } from './rich-text.js';
-/**
- * Interns cell string values into the shared-strings pool. {@link intern} returns the index a
- * `t="s"` cell writes as its `<v>`; identical entries collapse to one, so `count` (total references)
- * and `uniqueCount` (distinct entries) diverge exactly as Excel records them. Each entry is stored as
- * its rendered `<si>` inner XML, which is also its dedup key — a plain string (`<t>…`) and rich runs
- * (`<r>…`) render to distinct markup, so the two kinds never collide in the pool.
- */
 export class SharedStringTable {
     #indexByEntry = new Map();
     #entries = [];
     #references = 0;
-    /** Intern a plain or rich string and return its `<si>` index, reusing the entry when it repeats. */
     intern(value) {
         this.#references += 1;
         const inner = typeof value === 'string' ? textElement(value) : richTextRunsXml(value.richText);
@@ -35,11 +16,9 @@ export class SharedStringTable {
         this.#entries.push(inner);
         return index;
     }
-    /** Whether no string has been interned — the writer omits the part entirely when so. */
     get isEmpty() {
         return this.#entries.length === 0;
     }
-    /** Serialise the pool as the `xl/sharedStrings.xml` part. */
     toXml() {
         const items = this.#entries.map((inner) => `<si>${inner}</si>`).join('');
         return (XML_DECLARATION +

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

@@ -1,27 +1,14 @@
-// The worksheet's non-cell property blocks: `<sheetPr>`, `<sheetViews>`, `<sheetProtection>`,
-// `<autoFilter>`, and the print settings (`<printOptions>`, `<pageMargins>`, `<pageSetup>`,
-// `<headerFooter>`, `<rowBreaks>`/`<colBreaks>`). Each renders one CT_Worksheet child (or child
-// group) independently of the row/cell body `worksheet-xml.ts` orchestrates them alongside.
 import { encodeAddress } from '../../core/address.js';
 import { SHEET_PROTECTION_FLAGS } from '../../core/protection.js';
 import { attr, boolAttr, escapeAttr, escapeText, numberText } from '../../xml/xml.js';
-import { colorAttrs } from './styles.js';
-// `<sheetViews>` holds the sheet's single view. A frozen view adds a `<pane>` recording the split
-// and a `<selection>` naming the pane the split activates, exactly as Excel writes it — a normal
-// view carries neither, so unfreezing leaves no leftover `<pane>` that would trip a repair prompt.
-// The active pane is whichever scrolling region the freeze creates: bottom-right when both axes are
-// frozen, else top-right (columns only) or bottom-left (rows only).
-//
-// `active` marks this sheet as the one selected on open (`tabSelected`). Exactly one sheet in a
-// workbook carries it — with none, the consumer opens with no sheet view initialised; with several,
-// the sheets form a *group selection*, where an edit to one is applied to all of them. The caller
-// (`worksheetXml`, fed from `Workbook.activeTabIndex`) is what guarantees the "exactly one".
+import { colorAttrs } from './color-xml.js';
 export function sheetViewsXml(view, active) {
     const selected = active ? ' tabSelected="1"' : '';
+    const gridLines = view.showGridLines === false ? ' showGridLines="0"' : '';
     const xSplit = view.xSplit ?? 0;
     const ySplit = view.ySplit ?? 0;
     if (view.state !== 'frozen' || (xSplit === 0 && ySplit === 0)) {
-        return `<sheetViews><sheetView${selected} workbookViewId="0"/></sheetViews>`;
+        return `<sheetViews><sheetView${gridLines}${selected} workbookViewId="0"/></sheetViews>`;
     }
     const topLeftCell = view.topLeftCell ?? encodeAddress(xSplit + 1, ySplit + 1);
     const activePane = xSplit > 0 && ySplit > 0 ? 'bottomRight' : xSplit > 0 ? 'topRight' : 'bottomLeft';
@@ -30,41 +17,21 @@ export function sheetViewsXml(view, active) {
         (ySplit > 0 ? ` ySplit="${ySplit}"` : '') +
         ` topLeftCell="${escapeAttr(topLeftCell)}" activePane="${activePane}" state="frozen"/>`;
     const selection = `<selection pane="${activePane}" activeCell="${escapeAttr(topLeftCell)}" sqref="${escapeAttr(topLeftCell)}"/>`;
-    return `<sheetViews><sheetView${selected} workbookViewId="0">${pane}${selection}</sheetView></sheetViews>`;
+    return `<sheetViews><sheetView${gridLines}${selected} workbookViewId="0">${pane}${selection}</sheetView></sheetViews>`;
 }
-// `<sheetPr>` carries the sheet's appearance properties: the tab colour, the outline
-// summary-position flags, and the fit-to-page flag. It is the first child of `<worksheet>` in
-// CT_Worksheet order; its own children follow CT_SheetPr order — `<tabColor>`, `<outlinePr>`, then
-// `<pageSetUpPr>`. Omitted entirely when the sheet carries none, so an unadorned sheet stays
-// byte-clean.
 export function sheetPrXml(sheet) {
     const children = (sheet.tabColor !== undefined ? `<tabColor ${colorAttrs(sheet.tabColor)}/>` : '') +
         outlinePrXml(sheet.outline) +
         pageSetUpPrXml(sheet.pageSetup);
     return children === '' ? '' : `<sheetPr>${children}</sheetPr>`;
 }
-// `<pageSetUpPr>` holds the fit-to-page toggle, which lives on the sheet properties rather than on
-// `<pageSetup>` — Excel reads it from here to decide whether the `fitToWidth`/`fitToHeight` counts
-// or the fixed `scale` govern printing. Emitted only when the author set the flag.
 function pageSetUpPrXml(pageSetup) {
     return pageSetup.fitToPage ? '<pageSetUpPr fitToPage="1"/>' : '';
 }
-// `<outlinePr>` carries only the summary-position flags today. Each is emitted solely when the
-// caller set it, so an inverted placement (`summaryBelow="0"`) is honoured while an untouched sheet
-// keeps the element out of the file entirely.
 function outlinePrXml(outline) {
     const attrs = boolAttr('summaryBelow', outline.summaryBelow) + boolAttr('summaryRight', outline.summaryRight);
     return attrs === '' ? '' : `<outlinePr${attrs}/>`;
 }
-// Each sheet-protection flag maps to a `<sheetProtection>` attribute whose value is INVERTED
-// from the author-facing allow-flag: the attribute records that an operation is *forbidden*
-// ("1"), so `allow: true` serialises as "0". Only a value that differs from OOXML's per-
-// attribute default (see SHEET_PROTECTION_FLAGS) is written — most editing operations default
-// to forbidden under protection, while selecting cells defaults to permitted.
-//
-// <sheetProtection> is what makes the per-cell locked/hidden flags bite. `sheet="1"` marks the
-// sheet protected; the password credential (when present) guards lifting it; the flag attributes
-// carve out the operations that stay available. base64 salt/hash use only XML-safe characters.
 export function sheetProtectionXml(protection) {
     if (protection === undefined)
         return '';
@@ -89,10 +56,6 @@ export function sheetProtectionXml(protection) {
     }
     return `<sheetProtection${attrs}/>`;
 }
-// The sheet's autofilter: `<autoFilter ref="A1:C10"/>` when it only draws dropdowns, or with nested
-// `<filterColumn>` children when columns carry criteria. Its companion `_FilterDatabase` defined name
-// (the range Excel derives filtering from) is written in the workbook part, so a sheet with no filter
-// emits nothing here and nothing there.
 export function autoFilterXml(filter) {
     if (filter === undefined)
         return '';
@@ -104,9 +67,6 @@ export function autoFilterXml(filter) {
 function filterColumnXml(column) {
     return `<filterColumn colId="${column.colId}">${filterCriteriaXml(column.criteria)}</filterColumn>`;
 }
-// A values filter is `<filters>` with a `<filter val>` per allowed value (and `blank="1"` to admit
-// empty cells); a custom filter is `<customFilters>` with one or two `<customFilter operator val>`
-// predicates, `and="1"` when they are AND-combined rather than OR.
 function filterCriteriaXml(criteria) {
     if (criteria.kind === 'values') {
         const blankAttr = criteria.blank ? ' blank="1"' : '';
@@ -119,9 +79,6 @@ function filterCriteriaXml(criteria) {
         .join('');
     return `<customFilters${andAttr}>${predicates}</customFilters>`;
 }
-// CT_HeaderFooter child order, paired with the flag their presence gates: the even- and
-// first-page variants are silently ignored by Excel unless differentOddEven / differentFirst
-// are set, so the writer derives each flag from whether any variant in its class was provided.
 const HF_CHILDREN = [
     { tag: 'oddHeader', key: 'oddHeader' },
     { tag: 'oddFooter', key: 'oddFooter' },
@@ -146,7 +103,6 @@ export function headerFooterXml(hf) {
         .join('');
     return `<headerFooter${attrs}>${body}</headerFooter>`;
 }
-// Excel's "Normal" margins, in inches — the defaults Excel writes for an untouched sheet.
 const DEFAULT_MARGINS = {
     left: 0.7,
     right: 0.7,
@@ -156,10 +112,6 @@ const DEFAULT_MARGINS = {
     footer: 0.3,
 };
 const MARGIN_SIDES = ['left', 'right', 'top', 'bottom', 'header', 'footer'];
-// `<printOptions>` carries the print-toggle flags and sits just before `<pageMargins>` in
-// CT_Worksheet order. Each attribute is emitted only when the model carries it — as an explicit
-// `="1"`/`="0"` so a caller can force a flag off against Excel's default — and an untouched sheet
-// keeps the element out of the file entirely.
 export function printOptionsXml(printOptions) {
     const attrs = boolAttr('horizontalCentered', printOptions.horizontalCentered) +
         boolAttr('verticalCentered', printOptions.verticalCentered) +
@@ -168,21 +120,12 @@ export function printOptionsXml(printOptions) {
         boolAttr('gridLinesSet', printOptions.gridLinesSet);
     return attrs === '' ? '' : `<printOptions${attrs}/>`;
 }
-// OOXML's <pageMargins> is all-or-nothing: setting any one margin requires all six, or Excel
-// repairs the file. So the element is emitted only when the caller set at least one, and the
-// untouched sides fall back to the Normal-preset defaults.
 export function pageMarginsXml(margins) {
     if (MARGIN_SIDES.every((side) => margins[side] === undefined))
         return '';
     const attrs = MARGIN_SIDES.map((side) => `${side}="${numberText(margins[side] ?? DEFAULT_MARGINS[side])}"`).join(' ');
     return `<pageMargins ${attrs}/>`;
 }
-// `<pageSetup>` carries the print-scaling attributes (all but `fitToPage`, which is a `<sheetPr>`
-// flag). It sits between `<pageMargins>` and `<headerFooter>` in CT_Worksheet order. Each attribute
-// is emitted only when the author set it, so an untouched sheet keeps the element out of the file
-// and a partially-set one never fabricates the counts Excel would otherwise default. A non-null
-// `printerSettingsRelId` links the sheet's opaque printer-settings blob and forces the element out
-// even when no scaling attribute is set — the reference is the only thing the model has to carry.
 export function pageSetupXml(pageSetup, printerSettingsRelId) {
     const attrs = attr('paperSize', pageSetup.paperSize) +
         attr('scale', pageSetup.scale) +
@@ -193,11 +136,6 @@ export function pageSetupXml(pageSetup, printerSettingsRelId) {
         (printerSettingsRelId !== null ? ` r:id="${printerSettingsRelId}"` : '');
     return attrs === '' ? '' : `<pageSetup${attrs}/>`;
 }
-// Manual page breaks (`<rowBreaks>`/`<colBreaks>`): one `<brk>` per row/column the layout splits
-// before. Excel records both the running total (`count`) and the manual subset (`manualBreakCount`);
-// every break the model carries is a manual, author-set one, so the two counts coincide. `max` bounds
-// the break across the other axis (Excel writes the last row/column index); a break without one is
-// emitted bare. Row and column breaks share this shape, differing only in the wrapping element.
 export function pageBreaksXml(breaks, element) {
     if (breaks.length === 0)
         return '';

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

@@ -1,4 +1,4 @@
-import { type Alignment, type Border, type Color, type DifferentialStyle, type Fill, type Font, type NamedCellStyle, type Protection, type TableStyleTable } from '../../core/style.ts';
+import { type Alignment, type Border, type DifferentialStyle, type Fill, type Font, type NamedCellStyle, type Protection, 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 {
@@ -106,33 +106,5 @@ export declare class StyleRegistry {
     /** Serialise the accumulated table into a complete, valid styles.xml part. */
     toXml(): string;
 }
-/**
- * Extract the custom indexed-color palette (`<colors><indexedColors>`) from styles.xml as verbatim
- * `<rgbColor rgb="…"/>` fragments, or an empty list when the file rides the default palette. Kept raw
- * — rather than parsed into RGB and re-serialised — so the exact entries (count, order, casing) a
- * source file declared survive a round-trip and every `indexed="…"` reference keeps its RGB.
- */
-export declare function parseIndexedColors(stylesXml: string): string[];
-/**
- * Extract the most-recently-used colour swatches (`<colors><mruColors>`) from styles.xml as verbatim
- * `<color .../>` fragments, or an empty list when the file declares none. Kept raw for the same reason
- * the indexed palette is: the list is the author's own working set of colours and the model has no
- * use for its contents, only for not losing them.
- */
-export declare function parseMruColors(stylesXml: string): string[];
-/**
- * Extract the `<tableStyles>` block from styles.xml: each `<tableStyle>` definition verbatim, plus the
- * container's nominated `defaultTableStyle`/`defaultPivotStyle`. See {@link TableStyleTable} for why
- * the definitions stay raw while the two names are decoded.
- *
- * A file with no such block — or with the self-closing `count="0"` container Excel writes when it has
- * only defaults to state — yields an empty {@link TableStyleTable.styles} and whichever names it did
- * carry.
- */
-export declare function parseTableStyles(stylesXml: string): TableStyleTable;
 export declare function fontXml(font: Font, nameTag?: 'name' | 'rFont'): string;
 export declare function dxfXml(style: DifferentialStyle): string;
-export declare function colorAttrs(color: Color): string;
-export declare function parseColor(attrs: {
-    readonly [k: string]: string;
-}): Color;