@rowsncolumns/toolkit 24.4.1

package/dist/cjs/exporter/xlsx/future-functions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Strip the `_xlfn.` / `_xlws.` / `_xludf.` prefixes and re-add the correct
+ * one to every future-function call in `formula`. Quoted spans are copied
+ * verbatim so string literals (`"…"`) and quoted sheet names (`'…'`) keep
+ * their original text; a doubled quote inside a span is an escaped quote.
+ * Because the strip pass runs first, already-qualified input comes out
+ * qualified exactly once.
+ */
+export declare function qualifyFutureFunctions(formula: string): string;
+//# sourceMappingURL=future-functions.d.ts.map

package/dist/cjs/exporter/xlsx/future-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"future-functions.d.ts","sourceRoot":"","sources":["../../../../exporter/xlsx/future-functions.ts"],"names":[],"mappings":"AAkPA;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA6B9D"}

package/dist/cjs/exporter/xlsx/future-functions.js

@@ -0,0 +1,264 @@
+import { __read, __spreadArray } from "tslib";
+/**
+ * Excel "future functions" — functions added after the Excel 2007 (.xlsx)
+ * file format was frozen. [MS-XLSX] requires them to be written into sheet
+ * XML behind a `_xlfn.` namespace prefix (`_xlfn._xlws.` for the
+ * worksheet-scoped dynamic-array functions); the UI never shows the prefix.
+ * Written bare, Excel does not resolve the name: it renders the call behind
+ * the implicit-intersection operator (`=@DAYS(...)`) and evaluates `#NAME?`.
+ *
+ * The list follows Microsoft's documentation of `_xlfn.`-prefixed functions
+ * ("Issue: An _xlfn. prefix is displayed in front of a function in a
+ * formula", support.microsoft.com) plus the dynamic-array / LAMBDA-era and
+ * 2024 additions that ship with the same prefix convention.
+ */
+var FUTURE_FUNCTION_NAMES = [
+    "ACOT",
+    "ACOTH",
+    "AGGREGATE",
+    "ANCHORARRAY",
+    "ARABIC",
+    "ARRAYTOTEXT",
+    "BASE",
+    "BETA.DIST",
+    "BETA.INV",
+    "BINOM.DIST",
+    "BINOM.DIST.RANGE",
+    "BINOM.INV",
+    "BITAND",
+    "BITLSHIFT",
+    "BITOR",
+    "BITRSHIFT",
+    "BITXOR",
+    "BYCOL",
+    "BYROW",
+    "CEILING.MATH",
+    "CEILING.PRECISE",
+    "CHISQ.DIST",
+    "CHISQ.DIST.RT",
+    "CHISQ.INV",
+    "CHISQ.INV.RT",
+    "CHISQ.TEST",
+    "CHOOSECOLS",
+    "CHOOSEROWS",
+    "COMBINA",
+    "CONCAT",
+    "CONFIDENCE.NORM",
+    "CONFIDENCE.T",
+    "COT",
+    "COTH",
+    "COVARIANCE.P",
+    "COVARIANCE.S",
+    "CSC",
+    "CSCH",
+    "DAYS",
+    "DECIMAL",
+    "DETECTLANGUAGE",
+    "DROP",
+    "ENCODEURL",
+    "ERF.PRECISE",
+    "ERFC.PRECISE",
+    "EXPAND",
+    "EXPON.DIST",
+    "F.DIST",
+    "F.DIST.RT",
+    "F.INV",
+    "F.INV.RT",
+    "F.TEST",
+    "FIELDVALUE",
+    "FILTER",
+    "FILTERXML",
+    "FLOOR.MATH",
+    "FLOOR.PRECISE",
+    "FORECAST.ETS",
+    "FORECAST.ETS.CONFINT",
+    "FORECAST.ETS.SEASONALITY",
+    "FORECAST.ETS.STAT",
+    "FORECAST.LINEAR",
+    "FORMULATEXT",
+    "GAMMA",
+    "GAMMA.DIST",
+    "GAMMA.INV",
+    "GAMMALN.PRECISE",
+    "GAUSS",
+    "GROUPBY",
+    "HSTACK",
+    "HYPGEOM.DIST",
+    "IFNA",
+    "IFS",
+    "IMAGE",
+    "IMCOSH",
+    "IMCOT",
+    "IMCSC",
+    "IMCSCH",
+    "IMSEC",
+    "IMSECH",
+    "IMSINH",
+    "IMTAN",
+    "ISFORMULA",
+    "ISOMITTED",
+    "ISOWEEKNUM",
+    "LAMBDA",
+    "LET",
+    "LOGNORM.DIST",
+    "LOGNORM.INV",
+    "MAKEARRAY",
+    "MAP",
+    "MAXIFS",
+    "MINIFS",
+    "MODE.MULT",
+    "MODE.SNGL",
+    "MUNIT",
+    "NEGBINOM.DIST",
+    "NETWORKDAYS.INTL",
+    "NORM.DIST",
+    "NORM.INV",
+    "NORM.S.DIST",
+    "NORM.S.INV",
+    "NUMBERVALUE",
+    "PDURATION",
+    "PERCENTILE.EXC",
+    "PERCENTILE.INC",
+    "PERCENTOF",
+    "PERCENTRANK.EXC",
+    "PERCENTRANK.INC",
+    "PERMUTATIONA",
+    "PHI",
+    "PIVOTBY",
+    "POISSON.DIST",
+    "QUARTILE.EXC",
+    "QUARTILE.INC",
+    "QUERYSTRING",
+    "RANDARRAY",
+    "RANK.AVG",
+    "RANK.EQ",
+    "REDUCE",
+    "REGEXEXTRACT",
+    "REGEXREPLACE",
+    "REGEXTEST",
+    "RRI",
+    "SCAN",
+    "SEC",
+    "SECH",
+    "SEQUENCE",
+    "SHEET",
+    "SHEETS",
+    "SINGLE",
+    "SKEW.P",
+    "SORT",
+    "SORTBY",
+    "STDEV.P",
+    "STDEV.S",
+    "STOCKHISTORY",
+    "SWITCH",
+    "T.DIST",
+    "T.DIST.2T",
+    "T.DIST.RT",
+    "T.INV",
+    "T.INV.2T",
+    "T.TEST",
+    "TAKE",
+    "TEXTAFTER",
+    "TEXTBEFORE",
+    "TEXTJOIN",
+    "TEXTSPLIT",
+    "TOCOL",
+    "TOROW",
+    "TRANSLATE",
+    "TRIMRANGE",
+    "UNICHAR",
+    "UNICODE",
+    "UNIQUE",
+    "VALUETOTEXT",
+    "VAR.P",
+    "VAR.S",
+    "VSTACK",
+    "WEBSERVICE",
+    "WEIBULL.DIST",
+    "WORKDAY.INTL",
+    "WRAPCOLS",
+    "WRAPROWS",
+    "XLOOKUP",
+    "XMATCH",
+    "XOR",
+    "Z.TEST",
+];
+/**
+ * Future functions that Excel writes behind the worksheet-scope prefix
+ * (`_xlfn._xlws.`) rather than plain `_xlfn.` — the dynamic-array functions
+ * that also exist as worksheet-only names.
+ */
+var WORKSHEET_SCOPED_FUTURE_FUNCTIONS = new Set([
+    "FILTER",
+    "SORT",
+]);
+var QUALIFIED_BY_NAME = new Map(FUTURE_FUNCTION_NAMES.map(function (name) { return [
+    name,
+    WORKSHEET_SCOPED_FUTURE_FUNCTIONS.has(name)
+        ? "_xlfn._xlws.".concat(name)
+        : "_xlfn.".concat(name),
+]; }));
+// Longest names first so `T.DIST.2T` wins over `T.DIST`. The match must be
+// followed by `(` — a bare name (e.g. the defined name `DAYS`) is not a call.
+var FUTURE_FUNCTION_REGEX = new RegExp("(" +
+    __spreadArray([], __read(FUTURE_FUNCTION_NAMES), false).sort(function (a, b) { return b.length - a.length; })
+        .map(function (name) { return name.replace(/\./g, "\\."); })
+        .join("|") +
+    ")(\\s*\\()", "gi");
+// `\b` is not enough of a left boundary: it would match the `DAYS` in
+// `_xlfn.DAYS` and in `MYDAYS`. The preceding character is checked by offset
+// instead of being consumed by the pattern, so nested calls
+// (`SORT(FILTER(...))`) still match after the enclosing one.
+var FUTURE_FUNCTION_LEFT_BOUNDARY = /[A-Za-z0-9_.$]/;
+function qualifySegment(segment) {
+    var stripped = segment
+        .replace(/_xlfn\./gi, "")
+        .replace(/_xlws\./gi, "")
+        .replace(/_xludf\./gi, "");
+    return stripped.replace(FUTURE_FUNCTION_REGEX, function (match, name, open, offset) {
+        if (offset > 0 &&
+            FUTURE_FUNCTION_LEFT_BOUNDARY.test(stripped[offset - 1])) {
+            return match;
+        }
+        var qualified = QUALIFIED_BY_NAME.get(name.toUpperCase());
+        return qualified ? qualified + open : match;
+    });
+}
+/**
+ * Strip the `_xlfn.` / `_xlws.` / `_xludf.` prefixes and re-add the correct
+ * one to every future-function call in `formula`. Quoted spans are copied
+ * verbatim so string literals (`"…"`) and quoted sheet names (`'…'`) keep
+ * their original text; a doubled quote inside a span is an escaped quote.
+ * Because the strip pass runs first, already-qualified input comes out
+ * qualified exactly once.
+ */
+export function qualifyFutureFunctions(formula) {
+    var result = "";
+    var segmentStart = 0;
+    var index = 0;
+    while (index < formula.length) {
+        var char = formula[index];
+        if (char !== '"' && char !== "'") {
+            index++;
+            continue;
+        }
+        result += qualifySegment(formula.slice(segmentStart, index));
+        var end = index + 1;
+        while (end < formula.length) {
+            if (formula[end] === char) {
+                if (formula[end + 1] === char) {
+                    end += 2;
+                    continue;
+                }
+                break;
+            }
+            end++;
+        }
+        // An unterminated literal consumes the rest of the formula.
+        var literalEnd = end < formula.length ? end + 1 : formula.length;
+        result += formula.slice(index, literalEnd);
+        index = literalEnd;
+        segmentStart = literalEnd;
+    }
+    return result + qualifySegment(formula.slice(segmentStart));
+}

package/dist/cjs/exporter/xlsx/pivot-builder.d.ts

@@ -0,0 +1,58 @@
+/**
+ * XLSX pivot table XML builders — Phase D2.
+ *
+ * Emits two XML families:
+ *   1. xl/pivotTables/pivotTable<N>.xml         — layout
+ *   2. xl/pivotCache/pivotCacheDefinition<N>.xml — field definitions
+ *
+ * `xl/pivotCache/pivotCacheRecords<N>.xml` is intentionally omitted.
+ * We set `refreshOnLoad="1"` so Excel recomputes the cache from the
+ * live source range on open — avoids the "cache stale vs. source"
+ * desync that records would cause.
+ *
+ * INTEGRATION POINTS (need wiring in xlsx-export.ts):
+ *   - Add `pivotTables: PivotTable[]` to ExportExcelProps
+ *   - Group pivots by sheetId, similar to charts/slicers
+ *   - For each pivot:
+ *     • Generate pivotTable XML + pivotCacheDefinition XML
+ *     • Add to zip at xl/pivotTables/pivotTable<N>.xml + xl/pivotCache/pivotCacheDefinition<N>.xml
+ *     • Add pivotTable → pivotCacheDefinition relationship file
+ *     • Add worksheet → pivotTable relationship
+ *     • Add workbook → pivotCacheDefinition relationship (in workbook.xml.rels)
+ *     • Add <pivotCaches> ref in workbook.xml
+ *     • Add ContentTypes overrides for both pivotTable and pivotCacheDefinition
+ *
+ * The slicer-builder integration (lines 1-128 of slicer-builder.ts
+ * + ~100 lines in xlsx-export.ts) is the closest reference template.
+ */
+import type { PivotTable } from "@rowsncolumns/spreadsheet";
+/**
+ * Build pivotCacheDefinition XML for a pivot. The cacheSource
+ * points at the live worksheet range; `refreshOnLoad="1"` makes
+ * Excel rebuild the cache when the user opens the file.
+ *
+ * @param pivot       The PivotTable record
+ * @param sheetName   Name of the sheet containing the source range
+ * @param fieldNames  All source column headers (becomes <cacheFields>)
+ */
+export declare const buildPivotCacheDefinitionXml: (pivot: PivotTable, sheetName: string, fieldNames: string[]) => string | null;
+/**
+ * Build the pivotTable layout XML. Excel determines whether a cell
+ * is a "row label", "column label", or "data" by the field axes
+ * declared here.
+ *
+ * @param pivot         The PivotTable record
+ * @param cacheId       Numeric cache ID (matches workbook.xml's <pivotCaches>)
+ * @param fieldIndices  Maps row/col/value field names → cacheField indices
+ */
+export declare const buildPivotTableXml: (pivot: PivotTable, cacheId: number, fieldIndices: Map<string, number>) => string | null;
+/**
+ * Build the pivotTable.xml.rels file (links the pivot to its
+ * cache definition).
+ *
+ * @param cacheRid  Relationship id (e.g. "rId1")
+ * @param cacheTarget  Path relative to pivotTable, e.g.
+ *                     "../pivotCache/pivotCacheDefinition1.xml"
+ */
+export declare const buildPivotTableRelsXml: (cacheRid: string, cacheTarget: string) => string;
+//# sourceMappingURL=pivot-builder.d.ts.map

package/dist/cjs/exporter/xlsx/pivot-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pivot-builder.d.ts","sourceRoot":"","sources":["../../../../exporter/xlsx/pivot-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AA4D5D;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,GACvC,OAAO,UAAU,EACjB,WAAW,MAAM,EACjB,YAAY,MAAM,EAAE,KACnB,MAAM,GAAG,IAgCX,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,UAAU,EACjB,SAAS,MAAM,EACf,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAChC,MAAM,GAAG,IAkHX,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GACjC,UAAU,MAAM,EAChB,aAAa,MAAM,KAClB,MAcF,CAAC"}

package/dist/cjs/exporter/xlsx/pivot-builder.js

@@ -0,0 +1,277 @@
+import { __read, __spreadArray, __values } from "tslib";
+import { XMLBuilder } from "fast-xml-parser";
+var xmlBuilder = new XMLBuilder({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    format: true,
+    indentBy: "  ",
+});
+/**
+ * Convert numeric col/row to A1 notation. 1-indexed.
+ * e.g. (1, 1) → "A1", (28, 5) → "AB5".
+ */
+var a1 = function (col, row) {
+    var s = "";
+    var c = col;
+    while (c > 0) {
+        var rem = (c - 1) % 26;
+        s = String.fromCharCode(65 + rem) + s;
+        c = Math.floor((c - 1) / 26);
+    }
+    return "".concat(s).concat(row);
+};
+var rangeRef = function (range) {
+    return "".concat(a1(range.startColumnIndex, range.startRowIndex), ":").concat(a1(range.endColumnIndex, range.endRowIndex));
+};
+/**
+ * Map our aggFunc → XLSX subtotal attribute.
+ */
+var aggToSubtotal = function (agg) {
+    var _a;
+    var map = {
+        sum: "sum",
+        count: "countNums",
+        counta: "count",
+        avg: "average",
+        min: "min",
+        max: "max",
+        product: "product",
+        stddev: "stdDev",
+        stddevp: "stdDevp",
+        var: "var",
+        varp: "varp",
+        median: "average", // No native MEDIAN; fall back so Excel doesn't error.
+        countunique: "count",
+    };
+    return (_a = map[agg]) !== null && _a !== void 0 ? _a : "sum";
+};
+/**
+ * Build pivotCacheDefinition XML for a pivot. The cacheSource
+ * points at the live worksheet range; `refreshOnLoad="1"` makes
+ * Excel rebuild the cache when the user opens the file.
+ *
+ * @param pivot       The PivotTable record
+ * @param sheetName   Name of the sheet containing the source range
+ * @param fieldNames  All source column headers (becomes <cacheFields>)
+ */
+export var buildPivotCacheDefinitionXml = function (pivot, sheetName, fieldNames) {
+    if (!pivot.source)
+        return null;
+    var sourceRef = rangeRef(pivot.source);
+    var cacheFields = fieldNames.map(function (name) { return ({
+        "@_name": name,
+        sharedItems: { "@_count": "0" },
+    }); });
+    var doc = {
+        "?xml": { "@_version": "1.0", "@_encoding": "UTF-8", "@_standalone": "yes" },
+        pivotCacheDefinition: {
+            "@_xmlns": "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+            "@_xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+            "@_invalid": "1",
+            "@_refreshOnLoad": "1",
+            "@_refreshedBy": "Rows n Columns",
+            "@_recordCount": "0",
+            cacheSource: {
+                "@_type": "worksheet",
+                worksheetSource: {
+                    "@_ref": sourceRef,
+                    "@_sheet": sheetName,
+                },
+            },
+            cacheFields: {
+                "@_count": String(cacheFields.length),
+                cacheField: cacheFields,
+            },
+        },
+    };
+    return xmlBuilder.build(doc);
+};
+/**
+ * Build the pivotTable layout XML. Excel determines whether a cell
+ * is a "row label", "column label", or "data" by the field axes
+ * declared here.
+ *
+ * @param pivot         The PivotTable record
+ * @param cacheId       Numeric cache ID (matches workbook.xml's <pivotCaches>)
+ * @param fieldIndices  Maps row/col/value field names → cacheField indices
+ */
+export var buildPivotTableXml = function (pivot, cacheId, fieldIndices) {
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+    var _e, _f, _g, _h, _j, _k, _l;
+    if (!pivot.pivotRange)
+        return null;
+    var ref = rangeRef(pivot.pivotRange);
+    // pivotFields: one entry per cacheField, with axis attribute
+    // (axisRow / axisCol / dataField). Order = cacheField order.
+    var pivotFields = [];
+    // We don't know the full field universe here without the source
+    // schema. Best-effort: declare entries for the union of row/col/
+    // value fields and tag with the appropriate axis.
+    var fieldAxis = new Map();
+    try {
+        for (var _m = __values((_e = pivot.rows) !== null && _e !== void 0 ? _e : []), _o = _m.next(); !_o.done; _o = _m.next()) {
+            var r = _o.value;
+            var idx = fieldIndices.get(r.field);
+            if (idx != null)
+                fieldAxis.set(idx, "axisRow");
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_o && !_o.done && (_a = _m.return)) _a.call(_m);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    try {
+        for (var _p = __values((_f = pivot.columns) !== null && _f !== void 0 ? _f : []), _q = _p.next(); !_q.done; _q = _p.next()) {
+            var c = _q.value;
+            var idx = fieldIndices.get(c.field);
+            if (idx != null)
+                fieldAxis.set(idx, "axisCol");
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_q && !_q.done && (_b = _p.return)) _b.call(_p);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    try {
+        for (var _r = __values((_g = pivot.values) !== null && _g !== void 0 ? _g : []), _s = _r.next(); !_s.done; _s = _r.next()) {
+            var v = _s.value;
+            var idx = fieldIndices.get(v.field);
+            if (idx != null)
+                fieldAxis.set(idx, "dataField");
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_s && !_s.done && (_c = _r.return)) _c.call(_r);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    // Need to emit one <pivotField> per cacheField in order, even
+    // for unused fields (Excel requires the array shapes match).
+    // Caller passes us the full field set via fieldIndices.
+    var sortedFieldIndices = __spreadArray([], __read(fieldIndices.entries()), false).sort(function (a, b) { return a[1] - b[1]; });
+    try {
+        for (var sortedFieldIndices_1 = __values(sortedFieldIndices), sortedFieldIndices_1_1 = sortedFieldIndices_1.next(); !sortedFieldIndices_1_1.done; sortedFieldIndices_1_1 = sortedFieldIndices_1.next()) {
+            var _t = __read(sortedFieldIndices_1_1.value, 2), idx = _t[1];
+            var axis = fieldAxis.get(idx);
+            if (axis) {
+                pivotFields.push({ "@_axis": axis, "@_compact": "0", items: {} });
+            }
+            else {
+                pivotFields.push({ "@_compact": "0" });
+            }
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (sortedFieldIndices_1_1 && !sortedFieldIndices_1_1.done && (_d = sortedFieldIndices_1.return)) _d.call(sortedFieldIndices_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    var rowFields = ((_h = pivot.rows) !== null && _h !== void 0 ? _h : [])
+        .map(function (r) { return fieldIndices.get(r.field); })
+        .filter(function (i) { return i != null; })
+        .map(function (i) { return ({ "@_x": String(i) }); });
+    var colFields = ((_j = pivot.columns) !== null && _j !== void 0 ? _j : [])
+        .map(function (c) { return fieldIndices.get(c.field); })
+        .filter(function (i) { return i != null; })
+        .map(function (i) { return ({ "@_x": String(i) }); });
+    var dataFields = ((_k = pivot.values) !== null && _k !== void 0 ? _k : [])
+        .map(function (v) {
+        var _a;
+        var idx = fieldIndices.get(v.field);
+        if (idx == null)
+            return null;
+        return {
+            "@_name": (_a = v.displayName) !== null && _a !== void 0 ? _a : "".concat(v.aggFunc, " of ").concat(v.field),
+            "@_fld": String(idx),
+            "@_subtotal": aggToSubtotal(v.aggFunc),
+        };
+    })
+        .filter(function (d) { return d !== null; });
+    var doc = {
+        "?xml": { "@_version": "1.0", "@_encoding": "UTF-8", "@_standalone": "yes" },
+        pivotTableDefinition: {
+            "@_xmlns": "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+            "@_name": (_l = pivot.name) !== null && _l !== void 0 ? _l : "PivotTable".concat(pivot.pivotId),
+            "@_cacheId": String(cacheId),
+            "@_dataOnRows": "0",
+            "@_applyNumberFormats": "0",
+            "@_applyBorderFormats": "0",
+            "@_applyFontFormats": "0",
+            "@_applyPatternFormats": "0",
+            "@_applyAlignmentFormats": "0",
+            "@_applyWidthHeightFormats": "1",
+            "@_dataCaption": "Values",
+            "@_updatedVersion": "8",
+            "@_minRefreshableVersion": "3",
+            "@_showCalcMbrs": "0",
+            "@_useAutoFormatting": "1",
+            "@_itemPrintTitles": "1",
+            "@_createdVersion": "8",
+            "@_indent": "0",
+            "@_outline": "1",
+            "@_outlineData": "1",
+            "@_multipleFieldFilters": "0",
+            "@_rowGrandTotals": pivot.showRowGrandTotals === false ? "0" : "1",
+            "@_colGrandTotals": pivot.showColumnGrandTotals === false ? "0" : "1",
+            location: {
+                "@_ref": ref,
+                "@_firstHeaderRow": "1",
+                "@_firstDataRow": "1",
+                "@_firstDataCol": "1",
+            },
+            pivotFields: pivotFields.length
+                ? { "@_count": String(pivotFields.length), pivotField: pivotFields }
+                : undefined,
+            rowFields: rowFields.length
+                ? { "@_count": String(rowFields.length), field: rowFields }
+                : undefined,
+            colFields: colFields.length
+                ? { "@_count": String(colFields.length), field: colFields }
+                : undefined,
+            dataFields: dataFields.length
+                ? { "@_count": String(dataFields.length), dataField: dataFields }
+                : undefined,
+            pivotTableStyleInfo: {
+                "@_name": "PivotStyleLight16",
+                "@_showRowHeaders": "1",
+                "@_showColHeaders": "1",
+                "@_showRowStripes": "0",
+                "@_showColStripes": "0",
+                "@_showLastColumn": "1",
+            },
+        },
+    };
+    return xmlBuilder.build(doc);
+};
+/**
+ * Build the pivotTable.xml.rels file (links the pivot to its
+ * cache definition).
+ *
+ * @param cacheRid  Relationship id (e.g. "rId1")
+ * @param cacheTarget  Path relative to pivotTable, e.g.
+ *                     "../pivotCache/pivotCacheDefinition1.xml"
+ */
+export var buildPivotTableRelsXml = function (cacheRid, cacheTarget) {
+    var doc = {
+        "?xml": { "@_version": "1.0", "@_encoding": "UTF-8", "@_standalone": "yes" },
+        Relationships: {
+            "@_xmlns": "http://schemas.openxmlformats.org/package/2006/relationships",
+            Relationship: {
+                "@_Id": cacheRid,
+                "@_Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition",
+                "@_Target": cacheTarget,
+            },
+        },
+    };
+    return xmlBuilder.build(doc);
+};

package/dist/cjs/exporter/xlsx/power-query-builder.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Power Query part re-emission — the export half of the parser's `getPowerQuery()` preservation,
+ * and the JS mirror of the Rust engine's `rnc-export` `inject_power_query` pass (same rules, same
+ * envelope shape).
+ *
+ * Runs as a post-pass over the exporter's assembled `files` map (just before zipping):
+ *
+ * - `customXml/item{N}.xml` (the `<DataMashup>` blob) + `customXml/itemProps{N}.xml` + the item's
+ *   rels, related from `xl/workbook.xml`.
+ * - `xl/connections.xml`, verbatim.
+ * - `xl/queryTables/queryTable{N}.xml`, re-attached to the regenerated table part when the exported
+ *   table still matches the imported one (same `displayName`, same ordered column names): the table
+ *   part gains `tableType="queryTable"`, its `<tableColumn>`s get their ORIGINAL ids back (the
+ *   verbatim queryTable part references them) plus their `queryTableFieldId`s, and a
+ *   table→queryTable rel is written. A table that was renamed or had columns
+ *   added/removed/reordered degrades to a plain table (its queryTable part is dropped) while the
+ *   query itself (DataMashup + connection) still round-trips — Excel's own
+ *   connection-without-load-target state.
+ */
+import { type PowerQueryParts } from "../../power-query";
+/**
+ * Apply the preserved Power Query parts onto the exporter's `files` map (part name → bytes).
+ * No-op when the envelope is empty, keeping every other export byte-for-byte unchanged.
+ */
+export declare const applyPowerQueryParts: (files: Record<string, Uint8Array>, powerQuery: PowerQueryParts | null | undefined) => void;
+//# sourceMappingURL=power-query-builder.d.ts.map

package/dist/cjs/exporter/xlsx/power-query-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"power-query-builder.d.ts","sourceRoot":"","sources":["../../../../exporter/xlsx/power-query-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,mBAAmB,CAAC;AAuB3B;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EACjC,YAAY,eAAe,GAAG,IAAI,GAAG,SAAS,KAC7C,IAqHF,CAAC"}