@shbernal/ts-xlsx 1.1.0 → 1.2.0

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

@@ -1,24 +1,9 @@
-// The style-table reader: `xl/styles.xml` in, a flat table of resolved cell formats out. It is a
-// single streaming pass over the shared sub-tables (`<numFmts>`, `<fills>`, `<fonts>`, `<borders>`)
-// and the two xf tables (`<cellXfs>`, `<cellStyleXfs>`), flattening the id-indirection so a cell's
-// `s` index maps straight to its facets. A construct it does not recognise is skipped, never guessed.
-//
-// Only the parsing is XML-specific. What an xf resolves *to* — `XfStyle`, the built-in number
-// formats, applying an xf to a cell — is a property of the OOXML style model rather than of its
-// spelling, and lives above both codecs in `../style/xf-style.ts`; the `.xlsb` style reader builds
-// the same table from BIFF12 records.
 import { assignStyleFacets, isBorderStyle, isFillPatternType, isFontScheme, isFontVerticalAlignment, isHorizontalAlignment, isNamedUnderlineStyle, isVerticalAlignment, } from '../../core/style.js';
-import { boolPresent, boolStrict, closeEmptyElements, localName, xmlEvents, } from '../../xml/xml-read.js';
+import { boolPresent, boolStrict, closeEmptyElements, localName, openElements, xmlEvents, } from '../../xml/xml-read.js';
 import { numFmtCodeFor } from '../style/xf-style.js';
-import { parseColor } from './styles.js';
-// The four sides plus the diagonal — the edge elements a <border> can hold, in the order the
-// schema lists them. This one tuple drives the edge-name union, the membership set (which drives
-// edge parsing without a per-name branch), and the "does any edge carry a style" scan below.
+import { parseColor } from './color-xml.js';
 const BORDER_EDGE_NAMES = ['left', 'right', 'top', 'bottom', 'diagonal'];
 const BORDER_EDGES = new Set(BORDER_EDGE_NAMES);
-// Style-table elements that commit on their close: a bare <font/>/<border/>/<patternFill/>/
-// <gradientFill/>/<xf/> or a self-closing border edge is expanded to open+close so each commits
-// exactly once in onClose, never in a duplicated (and easily-forgotten) self-closing branch.
 const STYLE_EMPTY_CLOSES = new Set([
     'font',
     'border',
@@ -27,11 +12,6 @@ const STYLE_EMPTY_CLOSES = new Set([
     'xf',
     ...BORDER_EDGES,
 ]);
-// styles.xml is a shared table: <numFmts> defines custom format codes by id, <fills> lists
-// the fills, and <cellXfs> lists the cell formats, each naming a fill and a number format by
-// id. We flatten that indirection into one array — cellXfs index → resolved {fill, numFmt} —
-// so a cell/row/column style index maps straight to its facets. The schema orders <numFmts>
-// and <fills> before <cellXfs>, so both lookups are complete before an xf references them.
 export function parseStyleTable(xml) {
     if (xml === '')
         return { cellXfs: [], namedStyles: [] };
@@ -40,16 +20,8 @@ export function parseStyleTable(xml) {
     let borders = [];
     let numFmtCodes = new Map();
     const xfStyles = [];
-    // The named-style layer: <cellStyleXfs> holds the base formats a cell's xfId links to; <cellStyles>
-    // labels them by name/builtinId. Parsed in parallel with cellXfs, then zipped and merged below.
     const namedXfs = [];
     let cellStyleNames = [];
-    // One streaming pass, but each top-level sub-table drives its own focused sub-parser over the slice
-    // of events between its open and close. The schema orders the shared tables (<numFmts>, <fonts>,
-    // <fills>, <borders>) before the xf tables, so their results are complete before an <xf> resolves
-    // against them. Every recognised container name is plural and unique to the styleSheet root — none
-    // appears inside a <dxf>'s singular <font>/<fill>/<border> children — so skipping an unrecognised
-    // section here drops exactly what the old flat pass gated off with its `in*` flags.
     const events = closeEmptyElements(xmlEvents(xml), STYLE_EMPTY_CLOSES);
     let next = events.next();
     while (next.done !== true) {
@@ -81,18 +53,12 @@ export function parseStyleTable(xml) {
         }
         next = events.next();
     }
-    // Layer each cellXfs entry over the named style its xfId links to: a facet the direct format sets
-    // wins; one it leaves unset falls through to the named style. The xfId is carried through so the
-    // link survives a re-write. A draft only holds keys for facets it actually set, so the spread merge
-    // takes the named base and lets the direct entry override exactly what it names.
     const cellXfs = xfStyles.map((xf) => {
         if (xf.xfId === undefined)
             return xf;
         const named = namedXfs[xf.xfId];
         return named === undefined ? xf : { ...named, ...xf };
     });
-    // Zip the resolved cellStyleXfs facets with their cellStyles name/builtinId into the model's named
-    // styles, index for index (a cellStyle's xfId is its cellStyleXfs index).
     const namedStyles = namedXfs.map((xf, index) => {
         const label = cellStyleNames.find((entry) => entry.xfId === index);
         const style = {};
@@ -103,15 +69,9 @@ export function parseStyleTable(xml) {
             style.builtinId = label.builtinId;
         return style;
     });
-    // Font 0 is the workbook's declared default, so it is carried out whole as well as flattened onto
-    // the xfs that name it — see {@link StyleTable.defaultFont}.
     const defaultFont = fonts[0];
     return defaultFont === undefined ? { cellXfs, namedStyles } : { cellXfs, namedStyles, defaultFont };
 }
-// Pull events off the shared stream up to — and consuming — the close of `container`, yielding only
-// those strictly inside it. A sub-table parser loops this to completion (never breaking), so it drives
-// its own small state machine over exactly its section without closing the underlying generator, and
-// the outer pass resumes at the element after the container's close.
 function* until(events, container) {
     let next = events.next();
     while (next.done !== true) {
@@ -122,8 +82,6 @@ function* until(events, container) {
         next = events.next();
     }
 }
-// <numFmts> entries are self-closing, so they are read on open. A code with no id, or the General
-// id 0, contributes nothing.
 function parseNumFmts(events) {
     const codes = new Map();
     for (const event of until(events, 'numFmts')) {
@@ -142,7 +100,6 @@ function parseFonts(events) {
     for (const event of until(events, 'fonts')) {
         if (event.kind === 'open') {
             const local = localName(event.name);
-            // A <font>'s children are self-closing, so they are read here on open.
             if (local === 'font')
                 fontDraft = {};
             else if (fontDraft !== null)
@@ -160,9 +117,6 @@ function parseFills(events) {
     let pattern = '';
     let fgColor;
     let bgColor;
-    // A gradient fill accumulates from <gradientFill> open to close; its stops fill in as <stop>/<color>
-    // pairs arrive. `fillSlotAt` marks where in `fills` the current <fill> began, so its close can keep a
-    // slot even when the fill body was neither a pattern nor a gradient — index alignment is load-bearing.
     let gradientDraft = null;
     let fillSlotAt = -1;
     for (const event of until(events, 'fills')) {
@@ -170,9 +124,6 @@ function parseFills(events) {
             const attrs = event.attrs;
             switch (localName(event.name)) {
                 case 'fill':
-                    // Mark where this <fill> starts so its close can guarantee exactly one slot — a fill body
-                    // that is neither <patternFill> nor <gradientFill> (or a gradient we could not parse) must
-                    // still consume an id, or every later fill index shifts and cells mis-resolve their fill.
                     fillSlotAt = fills.length;
                     break;
                 case 'patternFill':
@@ -206,7 +157,6 @@ function parseFills(events) {
                     }
                     break;
                 case 'color':
-                    // The colour of the open <stop>; committed to a GradientStop when the stop closes.
                     if (gradientDraft !== null)
                         gradientDraft.stopColor = parseColor(attrs);
                     break;
@@ -235,8 +185,6 @@ function parseFills(events) {
                     }
                     break;
                 case 'fill':
-                    // Backstop the slot: if this <fill>'s body pushed nothing (unparsed/unknown content), keep an
-                    // empty slot so id alignment holds and later fills still resolve to the right cells.
                     if (fills.length === fillSlotAt)
                         fills.push(undefined);
                     break;
@@ -248,7 +196,6 @@ function parseFills(events) {
 function parseBorders(events) {
     const borders = [];
     let borderDraft = null;
-    // Which edge of the current border a nested <color> belongs to; null between edges.
     let currentEdge = null;
     for (const event of until(events, 'borders')) {
         if (event.kind === 'open') {
@@ -263,9 +210,6 @@ function parseBorders(events) {
                     borderDraft.diagonalDown = true;
             }
             else if (borderDraft !== null) {
-                // A border's edges and their <color> children are all read on open (each is self-closing bar a
-                // coloured edge, whose colour child is itself self-closing). An edge whose style is absent or
-                // an unrecognised token is dropped — the side simply carries no border.
                 if (BORDER_EDGES.has(local)) {
                     if (attrs.style !== undefined && isBorderStyle(attrs.style)) {
                         currentEdge = local;
@@ -292,39 +236,28 @@ function parseBorders(events) {
                 }
             }
             else if (borderDraft !== null && BORDER_EDGES.has(local)) {
-                // A coloured edge closes after its <color> child; drop the edge context so a stray later
-                // <color> cannot attach to it.
                 currentEdge = null;
             }
         }
     }
     return borders;
 }
-// Both <cellXfs> and <cellStyleXfs> hold <xf> with identical structure; they differ only in which
-// table the result lands in and whether an xfId link is meaningful (only cellXfs entries link to a
-// named style). One parser serves both, told by `container` which it is reading.
 function parseXfTable(events, container, deps) {
     const xfs = [];
     const captureXfId = container === 'cellXfs';
-    // The xf being read; held from open to close so its <alignment>/<protection> children can attach
-    // before it is committed. null outside an <xf>.
     let pendingXf = null;
     for (const event of until(events, container)) {
         if (event.kind === 'open') {
             const local = localName(event.name);
             if (local === 'xf') {
-                // Hold the xf open until its close so an <alignment>/<protection> child can attach first; a
-                // self-closing <xf/> is expanded to a close, so it commits there too, child-free.
                 pendingXf = resolveXf(event.attrs, deps, captureXfId);
             }
             else if (pendingXf !== null && local === 'alignment') {
-                // An xf's <alignment> child arrives before the xf closes; attach it to the pending xf.
                 const alignment = parseAlignment(event.attrs);
                 if (alignment !== undefined)
                     pendingXf.alignment = alignment;
             }
             else if (pendingXf !== null && local === 'protection') {
-                // An xf's <protection> child likewise arrives before the xf closes.
                 const protection = parseProtection(event.attrs);
                 if (protection !== undefined)
                     pendingXf.protection = protection;
@@ -337,18 +270,12 @@ function parseXfTable(events, container, deps) {
     }
     return xfs;
 }
-// Resolve an <xf>'s facet ids against the shared sub-tables into a draft. `captureXfId` is set only
-// for cellXfs entries, the sole table whose xfId links to a named style.
 function resolveXf(attrs, deps, captureXfId) {
     const fillId = Number(attrs.fillId);
     const fill = Number.isInteger(fillId) ? deps.fills[fillId] : undefined;
     const fontId = Number(attrs.fontId);
-    // Font id 0 is the workbook default font (a real Calibri-11-style face), not an absence — unlike
-    // border id 0, which is a genuinely empty border. So an xf naming font 0 resolves to that default
-    // face, giving every cell a concrete font to render.
     const font = Number.isInteger(fontId) ? deps.fonts[fontId] : undefined;
     const borderId = Number(attrs.borderId);
-    // Border id 0 is the empty default; only a custom border (id > 0) is an explicit one.
     const border = Number.isInteger(borderId) && borderId > 0 ? deps.borders[borderId] : undefined;
     const numFmt = resolveNumFmt(attrs.numFmtId, deps.numFmtCodes);
     const draft = {};
@@ -360,12 +287,8 @@ function resolveXf(attrs, deps, captureXfId) {
         draft.font = font;
     if (border)
         draft.border = border;
-    // The quote-prefix flag is an attribute on the xf itself (no shared sub-table); carry it only when
-    // set so an ordinary cell does not gain a spurious `quotePrefix: false`.
     if (boolStrict(attrs.quotePrefix))
         draft.quotePrefix = true;
-    // A cellXfs entry's xfId links it to a named style; capture it only when it points beyond the Normal
-    // default (0), so an ordinary cell carries no spurious named-style link.
     if (captureXfId && attrs.xfId !== undefined) {
         const xfId = Number(attrs.xfId);
         if (Number.isInteger(xfId) && xfId > 0)
@@ -373,8 +296,6 @@ function resolveXf(attrs, deps, captureXfId) {
     }
     return draft;
 }
-// A <cellStyle> (inside <cellStyles>) names a cellStyleXfs entry by xfId; it is self-closing, so it
-// is read on open.
 function parseCellStyles(events) {
     const names = [];
     for (const event of until(events, 'cellStyles')) {
@@ -396,9 +317,6 @@ function parseCellStyles(events) {
     }
     return names;
 }
-// A <font> child element sets one facet on the draft. Boolean flags honour their `val`: a
-// bare tag or val="1"/"true" is on, val="0"/"false" is off (an explicit-false flag is not
-// truthy merely because the tag is present). An unrecognised child is ignored.
 export function applyFontChild(draft, local, attrs) {
     switch (local) {
         case 'b':
@@ -414,10 +332,6 @@ export function applyFontChild(draft, local, attrs) {
             draft.outline = boolPresent(attrs.val);
             break;
         case 'u':
-            // A bare <u/> is a single underline; a named style (single/double/…) carries through; but
-            // val="none" is the explicit ABSENCE of an underline, so it must read back falsy — not the
-            // truthy string "none" that a consumer's `if (font.underline)` would mistake for underlined. An
-            // unrecognised token keeps the "is underlined" fact but drops the unknown style (a plain true).
             draft.underline =
                 attrs.val === undefined
                     ? true
@@ -440,7 +354,6 @@ export function applyFontChild(draft, local, attrs) {
         case 'color':
             draft.color = parseColor(attrs);
             break;
-        // `<name>` in a styles `<font>`, `<rFont>` in a rich-text run's `<rPr>` — the same font face.
         case 'name':
         case 'rFont':
             if (attrs.val !== undefined)
@@ -466,15 +379,10 @@ export function applyFontChild(draft, local, attrs) {
             break;
     }
 }
-// An xf's numFmtId resolves against the custom codes first, then the built-in table; the
-// General format (id 0) and any unrecognised id mean the cell carries no explicit format.
 function resolveNumFmt(raw, custom) {
     return raw === undefined ? undefined : numFmtCodeFor(Number(raw), custom);
 }
 function toFill(pattern, fgColor, bgColor) {
-    // `none` (and an absent patternType) is the absence of a fill; an unrecognised token is dropped the
-    // same way — like the border-edge style above — so a foreign pattern we do not model leaves the cell
-    // unfilled rather than propagating a token the writer would later re-emit unvalidated.
     if (!isFillPatternType(pattern) || pattern === 'none')
         return undefined;
     return {
@@ -484,8 +392,6 @@ function toFill(pattern, fgColor, bgColor) {
         ...(bgColor ? { bgColor } : {}),
     };
 }
-// Copy the numeric <gradientFill> attributes (degree; the path insets) onto a gradient draft, keeping
-// only the finite ones so an absent or malformed attribute leaves the field its OOXML default (unset).
 function assignGradientNumbers(fill, attrs) {
     for (const key of ['degree', 'left', 'right', 'top', 'bottom']) {
         const value = Number(attrs[key]);
@@ -493,22 +399,14 @@ function assignGradientNumbers(fill, attrs) {
             fill[key] = value;
     }
 }
-// An accumulated border with no styled edge and no diagonal direction is the empty default:
-// it carries nothing, so it resolves to undefined rather than an all-empty Border object.
 function borderToStyle(draft) {
     const hasEdge = BORDER_EDGE_NAMES.some((edge) => draft[edge] !== undefined);
     if (!hasEdge && draft.diagonalUp === undefined && draft.diagonalDown === undefined)
         return undefined;
     return draft;
 }
-// Read an <alignment> element's attributes into an Alignment, keeping only facets that differ
-// from the default. Boolean flags honour their parsed value — wrapText="0" is off, so it must
-// not fabricate a { wrapText: false } alignment — and an element carrying only defaults yields
-// undefined rather than an empty alignment object.
 function parseAlignment(attrs) {
     const out = {};
-    // `general` is the default and reads back as no explicit horizontal alignment; an unrecognised
-    // token (like an out-of-enum vertical one) is dropped rather than trusted into the model.
     if (attrs.horizontal !== undefined &&
         attrs.horizontal !== 'general' &&
         isHorizontalAlignment(attrs.horizontal)) {
@@ -537,10 +435,6 @@ function parseAlignment(attrs) {
     }
     return Object.keys(out).length > 0 ? out : undefined;
 }
-// Read a <protection> element into a Protection, keeping only facets that differ from the OOXML
-// default. `locked` defaults to TRUE, so only an explicit `locked="0"` carries information (an
-// unlocked cell) — a default or explicit-true cell must not read back as { locked: true }; `hidden`
-// defaults to false, so only `hidden="1"` is carried. An element with only defaults yields undefined.
 function parseProtection(attrs) {
     const out = {};
     if (attrs.locked === '0' || attrs.locked === 'false')
@@ -549,3 +443,62 @@ function parseProtection(attrs) {
         out.hidden = true;
     return Object.keys(out).length > 0 ? out : undefined;
 }
+export function parseIndexedColors(stylesXml) {
+    return elementFragments(stylesXml, 'indexedColors', 'rgbColor');
+}
+export function parseMruColors(stylesXml) {
+    return elementFragments(stylesXml, 'mruColors', 'color');
+}
+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 namespaces = fragmentNamespaces(stylesXml, styles);
+    if (namespaces.length > 0)
+        table.namespaces = namespaces;
+    return table;
+}
+function fragmentNamespaces(stylesXml, fragments) {
+    if (fragments.length === 0)
+        return [];
+    const declared = new Map();
+    const ignorable = new Set();
+    for (const { attrs } of openElements(stylesXml, 'styleSheet')) {
+        for (const [name, value] of Object.entries(attrs)) {
+            if (name.startsWith('xmlns:'))
+                declared.set(name.slice('xmlns:'.length), value);
+        }
+        for (const prefix of (attrs['mc:Ignorable'] ?? '').split(/\s+/)) {
+            if (prefix !== '')
+                ignorable.add(prefix);
+        }
+        break;
+    }
+    const used = new Set();
+    for (const fragment of fragments) {
+        for (const match of fragment.matchAll(/[\s</]([A-Za-z_][\w.-]*):[A-Za-z_]/g)) {
+            used.add(match[1]);
+        }
+    }
+    return [...used]
+        .filter((prefix) => declared.has(prefix))
+        .map((prefix) => ({
+        prefix,
+        uri: declared.get(prefix),
+        ignorable: ignorable.has(prefix),
+    }));
+}
+function elementFragments(xml, container, child) {
+    const block = new RegExp(`<${container}\\b[^>]*>([\\s\\S]*?)</${container}>`).exec(xml);
+    if (block === null)
+        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] ?? '');
+}