@shbernal/ts-xlsx 2.0.0 → 3.0.0

package/dist/io/xlsx/conditional-formatting.d.ts

@@ -1,4 +1,5 @@
-import type { ConditionalFormatting } from '../../core/conditional-formatting.ts';
+import { type ConditionalFormatting } from '../../core/conditional-formatting.ts';
+import { type CollectingPass } from '../../xml/xml-read.ts';
 import type { StyleRegistry } from './styles.ts';
 /**
  * Serialise every conditional formatting on a sheet into its `<conditionalFormatting>` blocks, in
@@ -15,14 +16,14 @@ export declare function conditionalFormattingsXml(formattings: readonly Conditio
  */
 export declare function conditionalFormattingsExtXml(formattings: readonly ConditionalFormatting[]): string;
 /**
- * Parse a worksheet's conditional formatting into the model. The classic `<conditionalFormatting>`
+ * A pass reading a worksheet's conditional formatting into the model. The classic `<conditionalFormatting>`
  * blocks supply every rule; the x14 extension (`<x14:conditionalFormatting>` inside `<extLst>`) is
  * read only to enrich a classic data bar with the facets the classic element cannot carry (the
  * gradient flag and the negative-fill and axis colours) matched by the shared id the two ends link
  * on. An extension rule with no classic counterpart (a rule that lives only in x14) is ignored, so it
  * is never half-read into a broken classic rule.
  */
-export declare function parseConditionalFormattings(xml: string): ConditionalFormatting[];
+export declare function conditionalFormattingPass(): CollectingPass<ConditionalFormatting[]>;
 /**
  * Extract the differential-style (`<dxf>`) fragments from styles.xml, each verbatim. Preserving the
  * raw XML, rather than reparsing and re-serialising, is what keeps a foreign dxf's number format a

package/dist/io/xlsx/conditional-formatting.js

@@ -1,5 +1,7 @@
-import { boolPresent, boolStrict, coerceNumericLiteral, localName, numFinite, numInteger, parseXml, } from '../../xml/xml-read.js';
-import { boolAttr, escapeAttr, escapeText, stripFormulaEquals } from '../../xml/xml.js';
+import { isCfValueObjectType, isConditionalFormattingOperator, isConditionalFormattingType, isIconSetType, isCfTimePeriod, } from '../../core/conditional-formatting.js';
+import { elementSubtrees, TextCapture, } from '../../xml/xml-read.js';
+import { boolPresent, boolStrict, coerceNumericLiteral, enumToken, localName, numFinite, numInteger, } from '../../xml/xml-scan.js';
+import { boolAttr, checkedToken, escapeAttr, escapeText, numberText, stripFormulaEquals, textAttr, } from '../../xml/xml.js';
 import { colorAttrs, parseColor } from './color-xml.js';
 import { CF_EXT_URI, DATABAR_LINK_EXT_URI, XM_NS } from './namespaces.js';
 import { x14Ext } from './x14-ext.js';
@@ -61,7 +63,7 @@ function x14DataBarXml(ref, rule, guid) {
         `</x14:cfRule><xm:sqref>${escapeText(ref)}</xm:sqref></x14:conditionalFormatting>`);
 }
 function x14CfvoXml(cfvo) {
-    const type = escapeAttr(cfvo.type);
+    const type = checkedToken(cfvo.type, isCfValueObjectType, 'conditional format value type');
     if (cfvo.value === undefined)
         return `<x14:cfvo type="${type}"/>`;
     return `<x14:cfvo type="${type}"><xm:f>${escapeText(String(cfvo.value))}</xm:f></x14:cfvo>`;
@@ -71,12 +73,16 @@ function cfRuleExtLinkXml(guid) {
 }
 function blockXml(cf, styles, priority, extLinks) {
     const rules = cf.rules.map((rule) => ruleXml(rule, styles, priority, extLinks)).join('');
+    if (rules === '')
+        return '';
     return `<conditionalFormatting sqref="${escapeAttr(cf.ref)}">${rules}</conditionalFormatting>`;
 }
 function ruleXml(rule, styles, priority, extLinks) {
     const p = rule.priority ?? priority.next;
     priority.next = Math.max(priority.next, p) + 1;
-    const attrs = [`type="${escapeAttr(rule.type)}"`];
+    const attrs = [
+        `type="${checkedToken(rule.type, isConditionalFormattingType, 'conditional formatting type')}"`,
+    ];
     const dxfId = resolveDxfId(rule, styles);
     if (dxfId !== undefined)
         attrs.push(`dxfId="${dxfId}"`);
@@ -91,16 +97,18 @@ function ruleXml(rule, styles, priority, extLinks) {
         attrs.push('bottom="1"');
     if (rule.percent)
         attrs.push('percent="1"');
-    if (rule.operator !== undefined)
-        attrs.push(`operator="${escapeAttr(rule.operator)}"`);
+    if (rule.operator !== undefined) {
+        attrs.push(`operator="${checkedToken(rule.operator, isConditionalFormattingOperator, 'conditional formatting operator')}"`);
+    }
     if (rule.text !== undefined)
         attrs.push(`text="${escapeAttr(rule.text)}"`);
-    if (rule.timePeriod !== undefined)
-        attrs.push(`timePeriod="${escapeAttr(rule.timePeriod)}"`);
+    if (rule.timePeriod !== undefined) {
+        attrs.push(`timePeriod="${checkedToken(rule.timePeriod, isCfTimePeriod, 'time period')}"`);
+    }
     if (rule.rank !== undefined)
-        attrs.push(`rank="${rule.rank}"`);
+        attrs.push(`rank="${numberText(rule.rank)}"`);
     if (rule.stdDev !== undefined)
-        attrs.push(`stdDev="${rule.stdDev}"`);
+        attrs.push(`stdDev="${numberText(rule.stdDev)}"`);
     let body = SCALE_TYPES.has(rule.type) ? scaleXml(rule) : formulaeXml(rule.formulae);
     const extGuid = extLinks.get(rule);
     if (extGuid !== undefined)
@@ -112,8 +120,9 @@ function ruleXml(rule, styles, priority, extLinks) {
 function resolveDxfId(rule, styles) {
     if (SCALE_TYPES.has(rule.type))
         return undefined;
-    if (rule.dxfId !== undefined)
-        return Number(rule.dxfId);
+    const preserved = dxfIndex(rule.dxfId);
+    if (preserved !== undefined)
+        return preserved;
     if (rule.style !== undefined)
         return styles.differentialStyleId(rule.style);
     return undefined;
@@ -142,34 +151,34 @@ function colorScaleXml(rule) {
     return `<colorScale>${anchors}${colors}</colorScale>`;
 }
 function iconSetXml(rule) {
-    const name = rule.iconSet !== undefined ? ` iconSet="${escapeAttr(rule.iconSet)}"` : '';
+    const name = rule.iconSet === undefined
+        ? ''
+        : ` iconSet="${checkedToken(rule.iconSet, isIconSetType, 'icon set')}"`;
     const anchors = (rule.cfvo ?? []).map(cfvoXml).join('');
     return `<iconSet${name}>${anchors}</iconSet>`;
 }
 function cfvoXml(cfvo) {
-    const val = cfvo.value !== undefined ? ` val="${escapeAttr(String(cfvo.value))}"` : '';
-    return `<cfvo type="${escapeAttr(cfvo.type)}"${val}/>`;
+    const type = checkedToken(cfvo.type, isCfValueObjectType, 'conditional format value type');
+    const val = cfvo.value === undefined ? '' : textAttr('val', String(cfvo.value));
+    return `<cfvo type="${type}"${val}/>`;
 }
-export function parseConditionalFormattings(xml) {
+export function conditionalFormattingPass() {
     const blocks = [];
     let block;
     let draft;
     let scale;
-    let capturingFormula = false;
-    let formulaText = '';
+    const formulaCapture = new TextCapture('formula');
     const linked = [];
     const extById = new Map();
     let x14Ext;
     let x14ExtId;
-    let capturingX14Id = false;
-    let x14IdText = '';
-    parseXml(xml, {
+    const x14IdCapture = new TextCapture('id');
+    const handlers = {
         onOpen(name, attrs, selfClosing) {
             const ln = localName(name);
             if (name.includes(':')) {
                 if (ln === 'id' && draft !== undefined) {
-                    capturingX14Id = true;
-                    x14IdText = '';
+                    x14IdCapture.open(ln, selfClosing);
                 }
                 else if (ln === 'cfRule') {
                     x14Ext = attrs.type === 'dataBar' && attrs.id !== undefined ? emptyExt() : undefined;
@@ -191,7 +200,9 @@ export function parseConditionalFormattings(xml) {
             }
             else if (ln === 'cfRule' && block !== undefined) {
                 if (selfClosing) {
-                    block.rules.push(finalizeRule(newDraft(attrs)));
+                    const rule = finalizeRule(newDraft(attrs));
+                    if (rule !== undefined)
+                        block.rules.push(rule);
                 }
                 else {
                     draft = newDraft(attrs);
@@ -201,8 +212,8 @@ export function parseConditionalFormattings(xml) {
             else if (draft !== undefined &&
                 (ln === 'dataBar' || ln === 'colorScale' || ln === 'iconSet')) {
                 scale = ln;
-                if (ln === 'iconSet' && attrs.iconSet !== undefined)
-                    draft.iconSet = attrs.iconSet;
+                if (ln === 'iconSet')
+                    draft.iconSet = enumToken(attrs.iconSet, isIconSetType);
             }
             else if (draft !== undefined && ln === 'cfvo') {
                 draft.cfvo.push(parseCfvo(attrs));
@@ -215,23 +226,20 @@ export function parseConditionalFormattings(xml) {
                     draft.colors.push(color);
             }
             else if (draft !== undefined && ln === 'formula') {
-                capturingFormula = true;
-                formulaText = '';
+                formulaCapture.open(ln, selfClosing);
             }
         },
         onText(chunk) {
-            if (capturingFormula)
-                formulaText += chunk;
-            if (capturingX14Id)
-                x14IdText += chunk;
+            formulaCapture.text(chunk);
+            x14IdCapture.text(chunk);
         },
         onClose(name) {
             const ln = localName(name);
             if (name.includes(':')) {
-                if (ln === 'id' && capturingX14Id) {
+                const id = x14IdCapture.close(ln);
+                if (id !== undefined) {
                     if (draft !== undefined)
-                        draft.x14Id = x14IdText;
-                    capturingX14Id = false;
+                        draft.x14Id = id;
                 }
                 else if (ln === 'cfRule' && x14Ext !== undefined && x14ExtId !== undefined) {
                     extById.set(x14ExtId, x14Ext);
@@ -240,20 +248,22 @@ export function parseConditionalFormattings(xml) {
                 }
                 return;
             }
-            if (ln === 'formula' && capturingFormula) {
+            const formula = formulaCapture.close(ln);
+            if (formula !== undefined) {
                 if (draft !== undefined)
-                    draft.formulae.push(coerceNumericLiteral(formulaText));
-                capturingFormula = false;
+                    draft.formulae.push(coerceNumericLiteral(formula));
             }
             else if (ln === 'dataBar' || ln === 'colorScale' || ln === 'iconSet') {
                 scale = undefined;
             }
             else if (ln === 'cfRule' && draft !== undefined) {
                 const rule = finalizeRule(draft);
-                if (block !== undefined)
-                    block.rules.push(rule);
-                if (draft.x14Id !== undefined)
-                    linked.push({ rule, id: draft.x14Id });
+                if (rule !== undefined) {
+                    if (block !== undefined)
+                        block.rules.push(rule);
+                    if (draft.x14Id !== undefined)
+                        linked.push({ rule, id: draft.x14Id });
+                }
                 draft = undefined;
             }
             else if (ln === 'conditionalFormatting' && block !== undefined) {
@@ -261,38 +271,38 @@ export function parseConditionalFormattings(xml) {
                 block = undefined;
             }
         },
-    });
-    for (const { rule, id } of linked) {
-        const ext = extById.get(id);
-        if (ext === undefined)
-            continue;
-        if (ext.gradient !== undefined)
-            rule.gradient = ext.gradient;
-        if (ext.negativeFillColor !== undefined)
-            rule.negativeFillColor = ext.negativeFillColor;
-        if (ext.axisColor !== undefined)
-            rule.axisColor = ext.axisColor;
-    }
-    return blocks;
+    };
+    const result = () => {
+        for (const { rule, id } of linked) {
+            const ext = extById.get(id);
+            if (ext === undefined)
+                continue;
+            if (ext.gradient !== undefined)
+                rule.gradient = ext.gradient;
+            if (ext.negativeFillColor !== undefined)
+                rule.negativeFillColor = ext.negativeFillColor;
+            if (ext.axisColor !== undefined)
+                rule.axisColor = ext.axisColor;
+        }
+        return blocks;
+    };
+    return { handlers, result };
 }
 function emptyExt() {
     return { gradient: undefined, negativeFillColor: undefined, axisColor: undefined };
 }
 export function parseDxfs(stylesXml) {
-    const block = /<dxfs\b[^>]*>([\s\S]*?)<\/dxfs>/.exec(stylesXml);
-    if (block === null)
-        return [];
-    const inner = block[1] ?? '';
-    return [...inner.matchAll(/<dxf\b[^>]*>[\s\S]*?<\/dxf>|<dxf\b[^>]*\/>/g)].map((m) => m[0] ?? '');
+    const { fragments } = elementSubtrees(stylesXml, new Map([['dxfs', 'dxf']]));
+    return [...(fragments.get('dxfs') ?? [])];
 }
 function newDraft(attrs) {
     return {
-        type: attrs.type ?? '',
+        type: enumToken(attrs.type, isConditionalFormattingType),
         priority: numFinite(attrs.priority),
         stopIfTrue: boolStrict(attrs.stopIfTrue),
-        operator: attrs.operator,
+        operator: enumToken(attrs.operator, isConditionalFormattingOperator),
         text: attrs.text,
-        timePeriod: attrs.timePeriod,
+        timePeriod: enumToken(attrs.timePeriod, isCfTimePeriod),
         rank: numFinite(attrs.rank),
         stdDev: numFinite(attrs.stdDev),
         percent: boolStrict(attrs.percent),
@@ -308,10 +318,15 @@ function newDraft(attrs) {
         x14Id: undefined,
     };
 }
+function dxfIndex(value) {
+    return numInteger(value, 0);
+}
 function parseIndexAttr(value) {
-    return numInteger(value, 0) === undefined ? undefined : value;
+    return dxfIndex(value) === undefined ? undefined : value;
 }
 function finalizeRule(draft) {
+    if (draft.type === undefined)
+        return undefined;
     const rule = { type: draft.type };
     if (draft.priority !== undefined)
         rule.priority = draft.priority;
@@ -350,7 +365,8 @@ function finalizeRule(draft) {
     return rule;
 }
 function parseCfvo(attrs) {
-    const type = (attrs.type ?? 'num');
+    const raw = attrs.type;
+    const type = raw !== undefined && isCfValueObjectType(raw) ? raw : 'num';
     const cfvo = { type };
     if (attrs.val !== undefined) {
         cfvo.value = type === 'formula' ? attrs.val : coerceNumericLiteral(attrs.val);

package/dist/io/xlsx/data-validation.d.ts

@@ -1,5 +1,6 @@
-import type { DataValidationEntry } from '../../core/data-validation.ts';
+import { type DataValidationEntry } from '../../core/data-validation.ts';
 import type { Worksheet } from '../../core/worksheet.ts';
+import { type CollectingPass } from '../../xml/xml-read.ts';
 /** The standard `<dataValidations>` element for the rules stored in the legacy form, or '' when the
  * sheet has none of them, so a sheet with only extended (or no) validations stays byte-clean here.
  * The extended rules are emitted separately by {@link dataValidationsExtXml}. */
@@ -8,13 +9,14 @@ export declare function dataValidationsXml(entries: readonly DataValidationEntry
  * none. Emitted bare (no `<extLst>` wrapper) so the worksheet serialiser can gather it into a single
  * `<extLst>` beside the conditional-formatting extension: a worksheet may carry at most one. */
 export declare function dataValidationsExtXml(entries: readonly DataValidationEntry[]): string;
-/** Parse every standard `<dataValidation>` out of a worksheet part into range-bound rules. */
-export declare function parseDataValidations(xml: string): DataValidationEntry[];
-/** Parse every extended `<x14:dataValidation>` out of a worksheet's `<extLst>` into range-bound
- * rules tagged `extended`, so a cross-sheet or whole-column list validation Excel stored only in the
- * 2009 extension form is read back rather than dropped. The standard parser ignores these (they are
- * prefixed); this one, symmetrically, handles only the prefixed elements. */
-export declare function parseExtendedDataValidations(xml: string): DataValidationEntry[];
+/** A pass gathering the standard `<dataValidation>` elements of a worksheet part, for a caller
+ * reading the part alongside its other readers in one parse. */
+export declare function dataValidationPass(): CollectingPass<DataValidationEntry[]>;
+/** A pass gathering the extended `<x14:dataValidation>` elements of a worksheet's `<extLst>`, so a
+ * cross-sheet or whole-column list validation Excel stored only in the 2009 extension form is read
+ * back rather than dropped. The standard pass ignores these (they are prefixed); this one,
+ * symmetrically, handles only the prefixed elements. */
+export declare function extendedDataValidationPass(): CollectingPass<DataValidationEntry[]>;
 /** Fold parsed validations onto a sheet, each bound to its original range and carrying its form: an
  * `extended` entry is re-attached as extended so a round-trip writes it back to the x14 block. */
 export declare function applyDataValidations(sheet: Worksheet, entries: readonly DataValidationEntry[]): void;

package/dist/io/xlsx/data-validation.js

@@ -1,5 +1,8 @@
-import { boolStrict, coerceNumericLiteral, localName, parseXml } from '../../xml/xml-read.js';
-import { escapeAttr, escapeText, stripFormulaEquals } from '../../xml/xml.js';
+import { isDataValidationErrorStyle, isDataValidationOperator, isDataValidationType, } from '../../core/data-validation.js';
+import { decodeSqrefRects } from '../../core/merge.js';
+import { TextCapture } from '../../xml/xml-read.js';
+import { boolStrict, coerceNumericLiteral, localName } from '../../xml/xml-scan.js';
+import { checkedToken, escapeAttr, escapeText, stripFormulaEquals, textAttr } from '../../xml/xml.js';
 import { DATA_VALIDATION_EXT_URI, XM_NS } from './namespaces.js';
 import { x14Ext } from './x14-ext.js';
 const TYPED = new Set(['whole', 'decimal', 'date', 'time', 'textLength']);
@@ -18,16 +21,20 @@ export function dataValidationsExtXml(entries) {
     return x14Ext(DATA_VALIDATION_EXT_URI, `<x14:dataValidations count="${extended.length}" xmlns:xm="${XM_NS}">${items}</x14:dataValidations>`);
 }
 function ruleAttrs(rule) {
-    return (` type="${rule.type}"` +
-        (rule.errorStyle !== undefined ? ` errorStyle="${rule.errorStyle}"` : '') +
-        (rule.operator !== undefined ? ` operator="${rule.operator}"` : '') +
+    return (` type="${checkedToken(rule.type, isDataValidationType, 'data validation type')}"` +
+        (rule.errorStyle === undefined
+            ? ''
+            : ` errorStyle="${checkedToken(rule.errorStyle, isDataValidationErrorStyle, 'data validation error style')}"`) +
+        (rule.operator === undefined
+            ? ''
+            : ` operator="${checkedToken(rule.operator, isDataValidationOperator, 'data validation operator')}"`) +
         (rule.allowBlank ? ' allowBlank="1"' : '') +
         (rule.showInputMessage ? ' showInputMessage="1"' : '') +
         (rule.showErrorMessage ? ' showErrorMessage="1"' : '') +
-        (rule.errorTitle !== undefined ? ` errorTitle="${escapeAttr(rule.errorTitle)}"` : '') +
-        (rule.error !== undefined ? ` error="${escapeAttr(rule.error)}"` : '') +
-        (rule.promptTitle !== undefined ? ` promptTitle="${escapeAttr(rule.promptTitle)}"` : '') +
-        (rule.prompt !== undefined ? ` prompt="${escapeAttr(rule.prompt)}"` : ''));
+        textAttr('errorTitle', rule.errorTitle) +
+        textAttr('error', rule.error) +
+        textAttr('promptTitle', rule.promptTitle) +
+        textAttr('prompt', rule.prompt));
 }
 function dataValidationXml(sqref, rule) {
     const [f1, f2] = operands(rule);
@@ -51,11 +58,11 @@ function extendedDataValidationXml(sqref, rule) {
         `<xm:sqref>${escapeText(sqref)}</xm:sqref>`;
     return `<x14:dataValidation${ruleAttrs(rule)}>${body}</x14:dataValidation>`;
 }
-export function parseDataValidations(xml) {
+export function dataValidationPass() {
     const entries = [];
     let current;
     let slot;
-    parseXml(xml, {
+    const handlers = {
         onOpen(name, attrs) {
             const ln = localName(name);
             if (ln === 'dataValidation' && !name.includes(':')) {
@@ -88,8 +95,8 @@ export function parseDataValidations(xml) {
                 current = undefined;
             }
         },
-    });
-    return entries;
+    };
+    return { handlers, result: () => entries };
 }
 function buildEntry(attrs, formulae) {
     const { sqref } = attrs;
@@ -100,11 +107,12 @@ function buildEntry(attrs, formulae) {
 }
 function buildRule(attrs, formulae) {
     const { type } = attrs;
-    if (type === undefined)
+    if (type === undefined || !isDataValidationType(type))
         return undefined;
-    const rule = { type: type };
+    const rule = { type };
     if (attrs.operator !== undefined) {
-        rule.operator = attrs.operator;
+        if (isDataValidationOperator(attrs.operator))
+            rule.operator = attrs.operator;
     }
     else if (TYPED.has(type)) {
         rule.operator = 'between';
@@ -115,7 +123,7 @@ function buildRule(attrs, formulae) {
         rule.showInputMessage = true;
     if (boolStrict(attrs.showErrorMessage))
         rule.showErrorMessage = true;
-    if (attrs.errorStyle !== undefined)
+    if (attrs.errorStyle !== undefined && isDataValidationErrorStyle(attrs.errorStyle))
         rule.errorStyle = attrs.errorStyle;
     if (attrs.error !== undefined)
         rule.error = attrs.error;
@@ -132,14 +140,13 @@ function buildRule(attrs, formulae) {
         rule.formulae = parsed;
     return rule;
 }
-export function parseExtendedDataValidations(xml) {
+export function extendedDataValidationPass() {
     const entries = [];
     let current;
     let slot;
-    let capture;
-    let text = '';
-    parseXml(xml, {
-        onOpen(name, attrs) {
+    const capture = new TextCapture(['f', 'sqref']);
+    const handlers = {
+        onOpen(name, attrs, selfClosing) {
             const ln = localName(name);
             const prefixed = name.includes(':');
             if (ln === 'dataValidation' && prefixed) {
@@ -151,30 +158,24 @@ export function parseExtendedDataValidations(xml) {
             else if (current !== undefined && prefixed && ln === 'formula2') {
                 slot = 1;
             }
-            else if (current !== undefined && ln === 'f') {
-                capture = 'formula';
-                text = '';
-            }
-            else if (current !== undefined && ln === 'sqref') {
-                capture = 'sqref';
-                text = '';
+            else if (current !== undefined) {
+                capture.open(ln, selfClosing);
             }
         },
         onText(chunk) {
-            if (capture !== undefined)
-                text += chunk;
+            capture.text(chunk);
         },
         onClose(name) {
             const ln = localName(name);
-            if (ln === 'f' && capture === 'formula') {
-                if (current !== undefined && slot !== undefined)
-                    current.formulae[slot] = text;
-                capture = undefined;
-            }
-            else if (ln === 'sqref' && capture === 'sqref') {
-                if (current !== undefined)
+            const text = capture.close(ln);
+            if (text !== undefined) {
+                if (ln === 'f') {
+                    if (current !== undefined && slot !== undefined)
+                        current.formulae[slot] = text;
+                }
+                else if (current !== undefined) {
                     current.sqref = text;
-                capture = undefined;
+                }
             }
             else if ((ln === 'formula1' || ln === 'formula2') && name.includes(':')) {
                 slot = undefined;
@@ -186,8 +187,8 @@ export function parseExtendedDataValidations(xml) {
                 current = undefined;
             }
         },
-    });
-    return entries;
+    };
+    return { handlers, result: () => entries };
 }
 function buildExtendedEntry(attrs, formulae, sqref) {
     if (sqref === '')
@@ -197,6 +198,8 @@ function buildExtendedEntry(attrs, formulae, sqref) {
 }
 export function applyDataValidations(sheet, entries) {
     for (const { sqref, rule, extended } of entries) {
+        if (decodeSqrefRects(sqref).length === 0)
+            continue;
         sheet.addDataValidation(sqref, rule, extended ? { extended: true } : {});
     }
 }

package/dist/io/xlsx/edit-vba.js

@@ -1,8 +1,8 @@
 import { strFromU8, strToU8, unzipSync, zipSync } from 'fflate';
 import { VbaAuthorError } from '../../vba/errors.js';
 import { addVbaReference, removeVbaModule, } from '../../vba/project-editor.js';
-import { relsPathFor } from '../opc/part-paths.js';
-import { parseRelationshipRecords, relationshipTargetByType, resolveRelativePart, resolveWorkbookPart, } from '../opc/read-opc.js';
+import { relsPathFor, resolveRelativePart } from '../opc/part-paths.js';
+import { parseRelationshipRecords, relationshipTargetByType } from '../opc/read-opc.js';
 import { FIXED_ENTRY_MTIME } from '../opc/zip-mtime.js';
 const OFFICE_DOCUMENT_REL = 'officeDocument';
 const VBA_PROJECT_REL = 'vbaProject';
@@ -14,7 +14,7 @@ export function editXlsxVbaAddReference(xlsx, ref) {
     return applyToVbaProjectPart(xlsx, (bin) => addVbaReference(bin, ref));
 }
 function applyToVbaProjectPart(xlsx, apply) {
-    const files = unzipSync(xlsx);
+    const files = Object.assign(Object.create(null), unzipSync(xlsx));
     const binPath = locateVbaProjectPart(files);
     const bin = binPath === undefined ? undefined : files[binPath];
     if (binPath === undefined || bin === undefined) {
@@ -38,14 +38,7 @@ function locateVbaProjectPart(files) {
     const vbaTarget = relationshipTargetByType(workbookRels, VBA_PROJECT_REL);
     if (vbaTarget === undefined)
         return undefined;
-    return resolveVbaTarget(workbookPath, vbaTarget);
-}
-function resolveVbaTarget(workbookPath, target) {
-    if (target.startsWith('/'))
-        return target.slice(1);
-    if (workbookPath.startsWith('xl/'))
-        return resolveWorkbookPart(target);
-    return resolveRelativePart(workbookPath, target);
+    return resolveRelativePart(workbookPath, vbaTarget);
 }
 function dropStaleSignature(files, binPath) {
     const binRelsPath = relsPathFor(binPath);

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

@@ -1,4 +1,5 @@
 import type { Worksheet } from '../../core/worksheet.ts';
+import { type CollectingPass } from '../../xml/xml-read.ts';
 import type { SheetRelIds } from './package-plan.ts';
 /** A hyperlink gathered from a sheet for serialisation: the cell it sits on, its target, and an
  * optional tooltip. The visible label is the cell's own value and is serialised as that value. */
@@ -34,8 +35,9 @@ interface ParsedHyperlink {
     readonly location?: string;
     readonly tooltip?: string;
 }
-/** Parse every `<hyperlink>` element out of a worksheet part. */
-export declare function parseSheetHyperlinks(xml: string): ParsedHyperlink[];
+/** A pass gathering every `<hyperlink>` element of a worksheet part, for a caller reading the part
+ * alongside its other readers in one parse. */
+export declare function sheetHyperlinkPass(): CollectingPass<ParsedHyperlink[]>;
 /** Fold parsed hyperlinks onto a sheet's cells, wrapping each cell's existing value (its visible
  * label) into a {@link HyperlinkValue}. `targetOf` resolves a relationship id to its raw Target: a
  * URL for the external links hyperlinks almost always are, so it must stay unresolved against the