@cj-tech-master/excelts 5.0.6 → 5.1.0

package/dist/cjs/modules/excel/xlsx/xform/pivot-table/pivot-cache-definition-xform.js

@@ -5,17 +5,36 @@ const base_xform_1 = require("../base-xform.js");
 const cache_field_1 = require("./cache-field.js");
 const cache_field_xform_1 = require("./cache-field-xform.js");
 const xml_stream_1 = require("../../../utils/xml-stream.js");
+const raw_xml_collector_1 = require("./raw-xml-collector.js");
+/** Attribute keys on <pivotCacheDefinition> that are individually parsed (not collected into extraRootAttrs). */
+const KNOWN_CACHE_DEF_ROOT_KEYS = new Set([
+    "xmlns",
+    "xmlns:r",
+    "r:id",
+    "refreshOnLoad",
+    "createdVersion",
+    "refreshedVersion",
+    "minRefreshableVersion",
+    "recordCount",
+    "backgroundQuery",
+    "supportSubquery",
+    "supportAdvancedDrill"
+]);
 class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
     constructor() {
         super();
-        this.map = {};
-        this.model = null;
+        // Parser state
         this.currentCacheField = null;
         this.inCacheFields = false;
         this.inCacheSource = false;
-    }
-    prepare(_model) {
-        // No preparation needed for writing
+        // Raw XML collectors
+        this.extLstCollector = new raw_xml_collector_1.RawXmlCollector("extLst");
+        this.unknownCollector = new raw_xml_collector_1.RawXmlCollector("");
+        this.unknownElementsXmlParts = [];
+        // R8-B9: Collector for non-worksheetSource children inside <cacheSource>
+        this.cacheSourceChildCollector = new raw_xml_collector_1.RawXmlCollector("");
+        this.cacheSourceXmlParts = [];
+        this.model = null;
     }
     get tag() {
         // http://www.datypic.com/sc/ooxml/e-ssml_pivotCacheDefinition.html
@@ -26,6 +45,11 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
         this.currentCacheField = null;
         this.inCacheFields = false;
         this.inCacheSource = false;
+        this.extLstCollector.reset();
+        this.unknownCollector.reset();
+        this.unknownElementsXmlParts = [];
+        this.cacheSourceChildCollector.reset();
+        this.cacheSourceXmlParts = [];
     }
     /**
      * Render pivot cache definition XML.
@@ -33,7 +57,7 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
      */
     render(xmlStream, model) {
         // Check if this is a loaded model (has isLoaded flag or no source property)
-        const isLoaded = model.isLoaded || !("source" in model);
+        const isLoaded = ("isLoaded" in model && model.isLoaded) || !("source" in model);
         if (isLoaded) {
             this.renderLoaded(xmlStream, model);
         }
@@ -46,8 +70,8 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
      */
     renderNew(xmlStream, model) {
         const { source, cacheFields } = model;
-        // Record count = number of data rows (excluding header row)
-        const recordCount = source.getSheetValues().slice(2).length;
+        // R8-O2: Use Array.isArray for type safety — getSheetValues() returns a sparse array of row arrays
+        const recordCount = source.getSheetValues().slice(2).filter(Array.isArray).length;
         xmlStream.openXml(xml_stream_1.XmlStream.StdDocAttributes);
         xmlStream.openNode(this.tag, {
             ...PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES,
@@ -59,14 +83,16 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
             recordCount
         });
         xmlStream.openNode("cacheSource", { type: "worksheet" });
-        xmlStream.leafNode("worksheetSource", {
-            ref: source.dimensions.shortRange,
-            sheet: source.name
-        });
+        // When source is a named Table, reference it by name (dynamic range tracking).
+        // Otherwise, reference by sheet + cell range (static).
+        const worksheetSourceAttrs = source.tableName
+            ? { name: source.tableName }
+            : { ref: source.dimensions.shortRange, sheet: source.name };
+        xmlStream.leafNode("worksheetSource", worksheetSourceAttrs);
         xmlStream.closeNode();
         xmlStream.openNode("cacheFields", { count: cacheFields.length });
         // Note: keeping this pretty-printed for now to ease debugging.
-        xmlStream.writeXml(cacheFields.map((cacheField) => new cache_field_1.CacheField(cacheField).render()).join("\n    "));
+        xmlStream.writeXml(PivotCacheDefinitionXform.renderCacheFieldsXml(cacheFields));
         xmlStream.closeNode();
         xmlStream.closeNode();
     }
@@ -76,42 +102,113 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
     renderLoaded(xmlStream, model) {
         const { cacheFields, sourceRef, sourceSheet, sourceTableName, recordCount } = model;
         xmlStream.openXml(xml_stream_1.XmlStream.StdDocAttributes);
-        xmlStream.openNode(this.tag, {
+        const rootAttrs = {
             ...PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES,
-            "r:id": model.rId || "rId1",
-            refreshOnLoad: model.refreshOnLoad || "1",
-            createdVersion: model.createdVersion || "8",
-            refreshedVersion: model.refreshedVersion || "8",
-            minRefreshableVersion: model.minRefreshableVersion || "3",
-            recordCount: recordCount || cacheFields.length + 1
-        });
-        xmlStream.openNode("cacheSource", { type: "worksheet" });
-        // worksheetSource supports two reference styles:
-        // 1. name: references a named Table
-        // 2. ref + sheet: references a cell range on a worksheet
-        const worksheetSourceAttrs = sourceTableName
-            ? { name: sourceTableName }
-            : { ref: sourceRef, sheet: sourceSheet };
-        xmlStream.leafNode("worksheetSource", worksheetSourceAttrs);
+            "r:id": model.rId ?? "rId1"
+        };
+        // Only emit refreshOnLoad when it was present in the original file.
+        // Forcing "1" causes Excel to recalculate the cache on every open.
+        // Placed before createdVersion to match Excel's attribute ordering.
+        if (model.refreshOnLoad) {
+            rootAttrs.refreshOnLoad = model.refreshOnLoad;
+        }
+        rootAttrs.createdVersion = model.createdVersion ?? "8";
+        rootAttrs.refreshedVersion = model.refreshedVersion ?? "8";
+        rootAttrs.minRefreshableVersion = model.minRefreshableVersion ?? "3";
+        // Only emit recordCount when it was present in the original file
+        if (recordCount !== undefined) {
+            rootAttrs.recordCount = recordCount;
+        }
+        // BUG-26: Preserve additional root attributes
+        if (model.backgroundQuery) {
+            rootAttrs.backgroundQuery = model.backgroundQuery;
+        }
+        if (model.supportSubquery) {
+            rootAttrs.supportSubquery = model.supportSubquery;
+        }
+        if (model.supportAdvancedDrill) {
+            rootAttrs.supportAdvancedDrill = model.supportAdvancedDrill;
+        }
+        // Extra unknown root attributes (roundtrip bag)
+        if (model.extraRootAttrs) {
+            for (const [k, v] of Object.entries(model.extraRootAttrs)) {
+                rootAttrs[k] = v;
+            }
+        }
+        xmlStream.openNode(this.tag, rootAttrs);
+        xmlStream.openNode("cacheSource", { type: model.cacheSourceType ?? "worksheet" });
+        // R8-B8/B14: Only emit <worksheetSource> when the source type is worksheet (or default)
+        // and at least one source attribute is defined. Non-worksheet types (e.g. "consolidation",
+        // "external") don't use <worksheetSource>.
+        const isWorksheetSource = !model.cacheSourceType || model.cacheSourceType === "worksheet";
+        if (isWorksheetSource) {
+            // worksheetSource supports two reference styles:
+            // 1. name: references a named Table
+            // 2. ref + sheet: references a cell range on a worksheet
+            const worksheetSourceAttrs = sourceTableName
+                ? { name: sourceTableName }
+                : { ref: sourceRef, sheet: sourceSheet };
+            // BUG-28: Preserve r:id for external connections
+            if (model.worksheetSourceRId) {
+                worksheetSourceAttrs["r:id"] = model.worksheetSourceRId;
+            }
+            // R8-B14: Only emit <worksheetSource> if we have at least one meaningful attribute
+            const hasAnyAttr = Object.values(worksheetSourceAttrs).some(v => v !== undefined);
+            if (hasAnyAttr) {
+                xmlStream.leafNode("worksheetSource", worksheetSourceAttrs);
+            }
+        }
+        // R8-B9: Emit preserved non-worksheet cacheSource children (e.g. <consolidation>)
+        if (model.cacheSourceXml) {
+            xmlStream.writeXml(model.cacheSourceXml);
+        }
         xmlStream.closeNode();
         xmlStream.openNode("cacheFields", { count: cacheFields.length });
-        xmlStream.writeXml(cacheFields
-            .map((cacheField) => new cache_field_1.CacheField(cacheField).render())
-            .join("\n    "));
+        xmlStream.writeXml(PivotCacheDefinitionXform.renderCacheFieldsXml(cacheFields));
         xmlStream.closeNode();
+        // R6-BugA: Preserved unknown child elements for roundtrip
+        if (model.unknownElementsXml) {
+            xmlStream.writeXml(model.unknownElementsXml);
+        }
+        // BUG-29: Preserve extLst from original file
+        if (model.extLstXml) {
+            xmlStream.writeXml(model.extLstXml);
+        }
         xmlStream.closeNode();
     }
     parseOpen(node) {
         const { name, attributes } = node;
+        // Collect extLst XML verbatim for roundtrip preservation
+        if (this.extLstCollector.active) {
+            this.extLstCollector.feedOpen(name, attributes);
+            return true;
+        }
+        // Collect unknown child element XML verbatim for roundtrip preservation
+        if (this.unknownCollector.active) {
+            this.unknownCollector.feedOpen(name, attributes);
+            return true;
+        }
+        // R8-B9: Collect non-worksheetSource children inside <cacheSource>
+        if (this.cacheSourceChildCollector.active) {
+            this.cacheSourceChildCollector.feedOpen(name, attributes);
+            return true;
+        }
         // Delegate to current cacheField parser if active
         if (this.currentCacheField) {
             this.currentCacheField.parseOpen(node);
             return true;
         }
         switch (name) {
-            case this.tag:
+            case this.tag: {
                 // pivotCacheDefinition root element
                 this.reset();
+                // Collect known attributes individually and put the rest in extraRootAttrs
+                const extraRootAttrs = {};
+                for (const [k, v] of Object.entries(attributes)) {
+                    if (!KNOWN_CACHE_DEF_ROOT_KEYS.has(k)) {
+                        extraRootAttrs[k] = String(v);
+                    }
+                }
                 this.model = {
                     cacheFields: [],
                     rId: attributes["r:id"],
@@ -120,17 +217,29 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
                     refreshedVersion: attributes.refreshedVersion,
                     minRefreshableVersion: attributes.minRefreshableVersion,
                     recordCount: attributes.recordCount ? parseInt(attributes.recordCount, 10) : undefined,
+                    backgroundQuery: attributes.backgroundQuery,
+                    supportSubquery: attributes.supportSubquery,
+                    supportAdvancedDrill: attributes.supportAdvancedDrill,
+                    extraRootAttrs: Object.keys(extraRootAttrs).length > 0 ? extraRootAttrs : undefined,
                     isLoaded: true
                 };
                 break;
+            }
             case "cacheSource":
                 this.inCacheSource = true;
+                if (this.model) {
+                    this.model.cacheSourceType = attributes.type;
+                }
                 break;
             case "worksheetSource":
                 if (this.inCacheSource && this.model) {
                     this.model.sourceRef = attributes.ref;
                     this.model.sourceSheet = attributes.sheet;
                     this.model.sourceTableName = attributes.name;
+                    // Preserve r:id for external connections (BUG-28)
+                    if (attributes["r:id"]) {
+                        this.model.worksheetSourceRId = attributes["r:id"];
+                    }
                 }
                 break;
             case "cacheFields":
@@ -142,15 +251,75 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
                     this.currentCacheField.parseOpen(node);
                 }
                 break;
+            case "extLst":
+                // Start collecting extLst XML for roundtrip preservation
+                if (this.model) {
+                    this.extLstCollector.start(attributes);
+                }
+                break;
+            default:
+                // R8-B9: Non-worksheetSource children inside <cacheSource> (e.g. <consolidation>)
+                // must be collected separately so they stay inside <cacheSource> on roundtrip.
+                if (this.inCacheSource && this.model) {
+                    this.cacheSourceChildCollector.startAs(name, attributes);
+                    break;
+                }
+                // Catch-all: collect any unhandled child element as raw XML
+                // This preserves elements like calculatedItems, cacheHierarchies, kpis,
+                // dimensions, measureGroups, maps, etc. that we don't individually model.
+                if (this.model) {
+                    this.unknownCollector.startAs(name, attributes);
+                }
+                break;
         }
         return true;
     }
     parseText(text) {
+        // Forward text to active collectors (B3 fix: text nodes in raw XML)
+        if (this.extLstCollector.active) {
+            this.extLstCollector.feedText(text);
+            return;
+        }
+        if (this.unknownCollector.active) {
+            this.unknownCollector.feedText(text);
+            return;
+        }
+        // R8-B9: Forward text to cacheSource child collector
+        if (this.cacheSourceChildCollector.active) {
+            this.cacheSourceChildCollector.feedText(text);
+            return;
+        }
         if (this.currentCacheField) {
             this.currentCacheField.parseText(text);
         }
     }
     parseClose(name) {
+        // Handle extLst collection — close tags
+        if (this.extLstCollector.active) {
+            if (this.extLstCollector.feedClose(name)) {
+                if (this.model) {
+                    this.model.extLstXml = this.extLstCollector.result;
+                }
+                this.extLstCollector.reset();
+            }
+            return true;
+        }
+        // Handle unknown element collection — close tags
+        if (this.unknownCollector.active) {
+            if (this.unknownCollector.feedClose(name)) {
+                this.unknownElementsXmlParts.push(this.unknownCollector.result);
+                this.unknownCollector.reset();
+            }
+            return true;
+        }
+        // R8-B9: Handle cacheSource child collection — close tags
+        if (this.cacheSourceChildCollector.active) {
+            if (this.cacheSourceChildCollector.feedClose(name)) {
+                this.cacheSourceXmlParts.push(this.cacheSourceChildCollector.result);
+                this.cacheSourceChildCollector.reset();
+            }
+            return true;
+        }
         // Delegate to current cacheField parser if active
         if (this.currentCacheField) {
             if (!this.currentCacheField.parseClose(name)) {
@@ -164,10 +333,17 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
         }
         switch (name) {
             case this.tag:
-                // End of pivotCacheDefinition
+                // End of pivotCacheDefinition — store any collected unknown elements
+                if (this.model && this.unknownElementsXmlParts.length > 0) {
+                    this.model.unknownElementsXml = this.unknownElementsXmlParts.join("");
+                }
                 return false;
             case "cacheSource":
                 this.inCacheSource = false;
+                // R8-B9: Store collected cacheSource children on model
+                if (this.model && this.cacheSourceXmlParts.length > 0) {
+                    this.model.cacheSourceXml = this.cacheSourceXmlParts.join("");
+                }
                 break;
             case "cacheFields":
                 this.inCacheFields = false;
@@ -175,8 +351,8 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
         }
         return true;
     }
-    reconcile(_model, _options) {
-        // No reconciliation needed
+    static renderCacheFieldsXml(cacheFields) {
+        return "\n    " + cacheFields.map(cf => (0, cache_field_1.renderCacheField)(cf)).join("\n    ");
     }
 }
 exports.PivotCacheDefinitionXform = PivotCacheDefinitionXform;

package/dist/cjs/modules/excel/xlsx/xform/pivot-table/pivot-cache-records-xform.js

@@ -4,16 +4,16 @@ exports.PivotCacheRecordsXform = void 0;
 const xml_stream_1 = require("../../../utils/xml-stream.js");
 const utils_1 = require("../../../../../utils/utils.js");
 const base_xform_1 = require("../base-xform.js");
+const cache_field_1 = require("./cache-field.js");
+const pivot_table_1 = require("../../../pivot-table.js");
+/** Attribute keys on <pivotCacheRecords> that are individually parsed (not collected into extraRootAttrs). */
+const KNOWN_CACHE_RECORDS_ROOT_KEYS = new Set(["xmlns", "xmlns:r", "count"]);
 class PivotCacheRecordsXform extends base_xform_1.BaseXform {
     constructor() {
         super();
-        this.map = {};
         this.model = null;
         this.currentRecord = null;
     }
-    prepare(_model) {
-        // No preparation needed
-    }
     get tag() {
         // http://www.datypic.com/sc/ooxml/e-ssml_pivotCacheRecords.html
         return "pivotCacheRecords";
@@ -28,7 +28,7 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
      */
     render(xmlStream, model) {
         // Check if this is a loaded model
-        const isLoaded = model.isLoaded || !("source" in model);
+        const isLoaded = ("isLoaded" in model && model.isLoaded) || !("source" in model);
         if (isLoaded) {
             this.renderLoaded(xmlStream, model);
         }
@@ -41,7 +41,8 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
      */
     renderNew(xmlStream, model) {
         const { source, cacheFields } = model;
-        const sourceBodyRows = source.getSheetValues().slice(2);
+        // R8-O2: Use Array.isArray for type safety — getSheetValues() returns a sparse array of row arrays
+        const sourceBodyRows = source.getSheetValues().slice(2).filter(Array.isArray);
         xmlStream.openXml(xml_stream_1.XmlStream.StdDocAttributes);
         xmlStream.openNode(this.tag, {
             ...PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES,
@@ -55,10 +56,27 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
      */
     renderLoaded(xmlStream, model) {
         xmlStream.openXml(xml_stream_1.XmlStream.StdDocAttributes);
-        xmlStream.openNode(this.tag, {
-            ...PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES,
-            count: model.count
-        });
+        // R8-B11: Use preserved root attributes instead of hardcoded MS namespaces.
+        // The base xmlns/xmlns:r are always needed; extra attributes (xmlns:mc, mc:Ignorable, etc.)
+        // come from the parsed original if available, otherwise fall back to the hardcoded defaults.
+        const rootAttrs = {
+            xmlns: PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES.xmlns,
+            "xmlns:r": PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES["xmlns:r"]
+        };
+        if (model.extraRootAttrs) {
+            for (const [k, v] of Object.entries(model.extraRootAttrs)) {
+                rootAttrs[k] = v;
+            }
+        }
+        else {
+            // No preserved attributes — use defaults for new-style rendering
+            rootAttrs["xmlns:mc"] = PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES["xmlns:mc"];
+            rootAttrs["mc:Ignorable"] =
+                PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES["mc:Ignorable"];
+            rootAttrs["xmlns:xr"] = PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES["xmlns:xr"];
+        }
+        rootAttrs.count = model.records.length;
+        xmlStream.openNode(this.tag, rootAttrs);
         // Render each record
         for (const record of model.records) {
             xmlStream.writeXml("\n  <r>");
@@ -78,19 +96,25 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
             case "x":
                 return `<x v="${value.value}" />`;
             case "n":
+                // Guard against NaN/Infinity — not valid in OOXML, render as missing
+                if (!Number.isFinite(value.value)) {
+                    return "<m />";
+                }
                 return `<n v="${value.value}" />`;
             case "s":
-                return `<s v="${(0, utils_1.xmlEncode)(String(value.value))}" />`;
+                return `<s v="${(0, utils_1.xmlEncode)(value.value)}" />`;
             case "b":
                 return `<b v="${value.value ? "1" : "0"}" />`;
             case "m":
                 return "<m />";
             case "d":
-                return `<d v="${value.value.toISOString()}" />`;
+                return `<d v="${(0, cache_field_1.formatDateForExcel)(value.value)}" />`;
             case "e":
-                return `<e v="${value.value}" />`;
-            default:
-                return "<m />";
+                return `<e v="${(0, utils_1.xmlEncode)(value.value)}" />`;
+            default: {
+                const _exhaustive = value;
+                throw new Error(`Unhandled record value type: ${_exhaustive.type}`);
+            }
         }
     }
     // Helper methods for rendering new records
@@ -99,28 +123,54 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
         for (const row of sourceBodyRows) {
             const realRow = row.slice(1);
             parts.push("\n  <r>");
-            for (let i = 0; i < realRow.length; i++) {
+            const fieldCount = Math.min(realRow.length, cacheFields.length);
+            for (let i = 0; i < fieldCount; i++) {
                 parts.push("\n    ");
                 parts.push(this.renderCellNew(realRow[i], cacheFields[i].sharedItems));
             }
+            // Pad missing columns with <m /> so every record has exactly one value per cacheField (OOXML requirement)
+            for (let i = fieldCount; i < cacheFields.length; i++) {
+                parts.push("\n    <m />");
+            }
             parts.push("\n  </r>");
         }
         return parts.join("");
     }
     renderCellNew(value, sharedItems) {
-        // Handle null/undefined values first
-        if (value === null || value === undefined) {
+        // Handle null/undefined/NaN values first — all treated as missing
+        if (value === null ||
+            value === undefined ||
+            (typeof value === "number" && !Number.isFinite(value))) {
+            // If no shared items, render as missing value directly
+            if (sharedItems === null) {
+                return "<m />";
+            }
+            // With shared items, look up null (undefined is treated as null)
+            const idx = sharedItems.indexOf(null);
+            if (idx >= 0) {
+                return `<x v="${idx}" />`;
+            }
+            // null not in sharedItems — render as missing
             return "<m />";
         }
-        // no shared items
+        // no shared items — render inline by type
         if (sharedItems === null) {
+            if (value instanceof pivot_table_1.PivotErrorValue) {
+                return `<e v="${(0, utils_1.xmlEncode)(value.code)}" />`;
+            }
+            if (typeof value === "boolean") {
+                return `<b v="${value ? "1" : "0"}" />`;
+            }
+            if (value instanceof Date) {
+                return `<d v="${(0, cache_field_1.formatDateForExcel)(value)}" />`;
+            }
             if (Number.isFinite(value)) {
                 return `<n v="${value}" />`;
             }
             return `<s v="${(0, utils_1.xmlEncode)(String(value))}" />`;
         }
-        // shared items - use indexOf for value lookup (works for both string and numeric)
-        const sharedItemsIndex = sharedItems.indexOf(value);
+        // shared items — look up index (type-aware for Date)
+        const sharedItemsIndex = findSharedItemIndex(sharedItems, value);
         if (sharedItemsIndex < 0) {
             throw new Error(`${JSON.stringify(value)} not in sharedItems ${JSON.stringify(sharedItems)}`);
         }
@@ -129,15 +179,24 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
     parseOpen(node) {
         const { name, attributes } = node;
         switch (name) {
-            case this.tag:
+            case this.tag: {
                 // pivotCacheRecords root element
                 this.reset();
+                // R8-B11: Collect unknown root attributes for roundtrip preservation
+                const extraRootAttrs = {};
+                for (const [k, v] of Object.entries(attributes)) {
+                    if (!KNOWN_CACHE_RECORDS_ROOT_KEYS.has(k)) {
+                        extraRootAttrs[k] = String(v);
+                    }
+                }
                 this.model = {
                     records: [],
-                    count: parseInt(attributes.count || "0", 10),
-                    isLoaded: true
+                    count: parseInt(attributes.count ?? "0", 10),
+                    isLoaded: true,
+                    extraRootAttrs: Object.keys(extraRootAttrs).length > 0 ? extraRootAttrs : undefined
                 };
                 break;
+            }
             case "r":
                 // Start of a new record
                 this.currentRecord = [];
@@ -147,17 +206,22 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
                 if (this.currentRecord) {
                     this.currentRecord.push({
                         type: "x",
-                        value: parseInt(attributes.v || "0", 10)
+                        value: parseInt(attributes.v ?? "0", 10)
                     });
                 }
                 break;
             case "n":
-                // Numeric value
+                // Numeric value — missing v → treat as missing to avoid fabricating 0
                 if (this.currentRecord) {
-                    this.currentRecord.push({
-                        type: "n",
-                        value: parseFloat(attributes.v || "0")
-                    });
+                    if (attributes.v === undefined || attributes.v === "") {
+                        this.currentRecord.push({ type: "m" });
+                    }
+                    else {
+                        this.currentRecord.push({
+                            type: "n",
+                            value: parseFloat(attributes.v)
+                        });
+                    }
                 }
                 break;
             case "s":
@@ -165,7 +229,7 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
                 if (this.currentRecord) {
                     this.currentRecord.push({
                         type: "s",
-                        value: (0, utils_1.xmlDecode)(attributes.v || "")
+                        value: attributes.v ?? ""
                     });
                 }
                 break;
@@ -185,12 +249,25 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
                 }
                 break;
             case "d":
-                // Date value
+                // Date value — force UTC parsing (OOXML dates lack "Z" suffix)
+                // Missing/empty v → treat as missing value to avoid Invalid Date
                 if (this.currentRecord) {
-                    this.currentRecord.push({
-                        type: "d",
-                        value: new Date(attributes.v || "")
-                    });
+                    if (!attributes.v) {
+                        this.currentRecord.push({ type: "m" });
+                    }
+                    else {
+                        // R8-B13: Guard against Invalid Date from malformed date strings
+                        const date = (0, utils_1.parseOoxmlDate)(attributes.v);
+                        if (isNaN(date.getTime())) {
+                            this.currentRecord.push({ type: "m" });
+                        }
+                        else {
+                            this.currentRecord.push({
+                                type: "d",
+                                value: date
+                            });
+                        }
+                    }
                 }
                 break;
             case "e":
@@ -198,7 +275,7 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
                 if (this.currentRecord) {
                     this.currentRecord.push({
                         type: "e",
-                        value: attributes.v || ""
+                        value: attributes.v ?? ""
                     });
                 }
                 break;
@@ -223,9 +300,6 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
         }
         return true;
     }
-    reconcile(_model, _options) {
-        // No reconciliation needed
-    }
 }
 exports.PivotCacheRecordsXform = PivotCacheRecordsXform;
 PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES = {
@@ -235,3 +309,31 @@ PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES = {
     "mc:Ignorable": "xr",
     "xmlns:xr": "http://schemas.microsoft.com/office/spreadsheetml/2014/revision"
 };
+/**
+ * Find the index of `value` in `sharedItems`, using type-aware comparison.
+ * - Date objects are compared by timestamp (getTime()) since === uses reference equality.
+ * - PivotErrorValue objects are compared by their code string.
+ * - All other types use strict equality (===) via indexOf.
+ */
+function findSharedItemIndex(sharedItems, value) {
+    if (value instanceof Date) {
+        const ts = value.getTime();
+        for (let i = 0; i < sharedItems.length; i++) {
+            const item = sharedItems[i];
+            if (item instanceof Date && item.getTime() === ts) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    if (value instanceof pivot_table_1.PivotErrorValue) {
+        for (let i = 0; i < sharedItems.length; i++) {
+            const item = sharedItems[i];
+            if (item instanceof pivot_table_1.PivotErrorValue && item.code === value.code) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    return sharedItems.indexOf(value);
+}