@cj-tech-master/excelts 5.0.6 → 5.1.0

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

@@ -1,16 +1,16 @@
 import { XmlStream } from "../../../utils/xml-stream.js";
-import { xmlEncode, xmlDecode } from "../../../../../utils/utils.browser.js";
+import { xmlEncode, parseOoxmlDate } from "../../../../../utils/utils.browser.js";
 import { BaseXform } from "../base-xform.js";
+import { formatDateForExcel } from "./cache-field.js";
+import { PivotErrorValue } from "../../../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 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";
@@ -25,7 +25,7 @@ class PivotCacheRecordsXform extends 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);
         }
@@ -38,7 +38,8 @@ class PivotCacheRecordsXform extends 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(XmlStream.StdDocAttributes);
         xmlStream.openNode(this.tag, {
             ...PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES,
@@ -52,10 +53,27 @@ class PivotCacheRecordsXform extends BaseXform {
      */
     renderLoaded(xmlStream, model) {
         xmlStream.openXml(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>");
@@ -75,19 +93,25 @@ class PivotCacheRecordsXform extends 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="${xmlEncode(String(value.value))}" />`;
+                return `<s v="${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="${formatDateForExcel(value.value)}" />`;
             case "e":
-                return `<e v="${value.value}" />`;
-            default:
-                return "<m />";
+                return `<e v="${xmlEncode(value.value)}" />`;
+            default: {
+                const _exhaustive = value;
+                throw new Error(`Unhandled record value type: ${_exhaustive.type}`);
+            }
         }
     }
     // Helper methods for rendering new records
@@ -96,28 +120,54 @@ class PivotCacheRecordsXform extends 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 PivotErrorValue) {
+                return `<e v="${xmlEncode(value.code)}" />`;
+            }
+            if (typeof value === "boolean") {
+                return `<b v="${value ? "1" : "0"}" />`;
+            }
+            if (value instanceof Date) {
+                return `<d v="${formatDateForExcel(value)}" />`;
+            }
             if (Number.isFinite(value)) {
                 return `<n v="${value}" />`;
             }
             return `<s v="${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)}`);
         }
@@ -126,15 +176,24 @@ class PivotCacheRecordsXform extends 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 = [];
@@ -144,17 +203,22 @@ class PivotCacheRecordsXform extends 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":
@@ -162,7 +226,7 @@ class PivotCacheRecordsXform extends BaseXform {
                 if (this.currentRecord) {
                     this.currentRecord.push({
                         type: "s",
-                        value: xmlDecode(attributes.v || "")
+                        value: attributes.v ?? ""
                     });
                 }
                 break;
@@ -182,12 +246,25 @@ class PivotCacheRecordsXform extends 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 = parseOoxmlDate(attributes.v);
+                        if (isNaN(date.getTime())) {
+                            this.currentRecord.push({ type: "m" });
+                        }
+                        else {
+                            this.currentRecord.push({
+                                type: "d",
+                                value: date
+                            });
+                        }
+                    }
                 }
                 break;
             case "e":
@@ -195,7 +272,7 @@ class PivotCacheRecordsXform extends BaseXform {
                 if (this.currentRecord) {
                     this.currentRecord.push({
                         type: "e",
-                        value: attributes.v || ""
+                        value: attributes.v ?? ""
                     });
                 }
                 break;
@@ -220,9 +297,6 @@ class PivotCacheRecordsXform extends BaseXform {
         }
         return true;
     }
-    reconcile(_model, _options) {
-        // No reconciliation needed
-    }
 }
 PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES = {
     xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
@@ -232,3 +306,31 @@ PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES = {
     "xmlns:xr": "http://schemas.microsoft.com/office/spreadsheetml/2014/revision"
 };
 export { PivotCacheRecordsXform };
+/**
+ * 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 PivotErrorValue) {
+        for (let i = 0; i < sharedItems.length; i++) {
+            const item = sharedItems[i];
+            if (item instanceof PivotErrorValue && item.code === value.code) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    return sharedItems.indexOf(value);
+}

package/dist/browser/modules/excel/xlsx/xform/pivot-table/pivot-table-xform.d.ts

@@ -1,37 +1,72 @@
+import { XmlStream } from "@excel/utils/xml-stream";
 import { BaseXform } from "@excel/xlsx/xform/base-xform";
+import type { CacheField, DataField, PivotTableSubtotal } from "@excel/pivot-table";
 /**
  * Model for generating pivot table (with live source)
  */
-interface PivotTableModel {
+interface PivotTableRenderModel {
     rows: number[];
     columns: number[];
     values: number[];
-    metric: "sum" | "count";
-    cacheFields: any[];
-    cacheId: number;
+    pages?: number[];
+    metric: PivotTableSubtotal;
+    /** Per-value metric overrides (parallel to `values` array). Falls back to `metric`. */
+    valueMetrics: PivotTableSubtotal[];
+    cacheFields: CacheField[];
+    cacheId: string | number;
+    tableNumber: number;
     applyWidthHeightFormats: "0" | "1";
 }
+/**
+ * A single <item> element inside a pivotField's <items> collection.
+ * Items can reference a shared item index (x attribute) or indicate a subtotal type (t attribute).
+ */
+interface PivotFieldItem {
+    /** Shared item index (maps to cacheField sharedItems) */
+    x?: number;
+    /** Item type: "default" for subtotals, "sum", "count", "avg", "max", "min", "grand", etc. */
+    t?: string;
+    /** Hidden flag — "1" means item is filtered out */
+    h?: string;
+    /** Show details (hide details when "0") */
+    sd?: string;
+    /** Calculated item flag */
+    f?: string;
+    /** Missing flag */
+    m?: string;
+    /** Child items flag */
+    c?: string;
+    /** Drill across flag */
+    d?: string;
+}
 /**
  * Parsed pivot field
  */
 interface ParsedPivotField {
     axis?: "axisRow" | "axisCol" | "axisPage" | "axisValues";
     dataField?: boolean;
-    items?: number[];
+    items?: PivotFieldItem[];
     compact?: boolean;
     outline?: boolean;
     showAll?: boolean;
     defaultSubtotal?: boolean;
+    numFmtId?: number;
+    sortType?: string;
+    autoSortScopeXml?: string;
+    subtotalTop?: boolean;
+    insertBlankRow?: boolean;
+    multipleItemSelectionAllowed?: boolean;
+    /** Bag of additional attributes not individually modeled (for roundtrip preservation) */
+    extraAttrs?: Record<string, string>;
 }
 /**
- * Parsed data field
+ * Parsed page field (report filter)
  */
-interface ParsedDataField {
-    name: string;
+interface ParsedPageField {
     fld: number;
-    baseField?: number;
-    baseItem?: number;
-    subtotal?: "sum" | "count" | "average" | "max" | "min" | "product" | "countNums" | "stdDev" | "stdDevP" | "var" | "varP";
+    item?: number;
+    hier?: number;
+    name?: string;
 }
 /**
  * Parsed pivot table model (loaded from file)
@@ -45,11 +80,14 @@ interface ParsedPivotTableModel {
         firstHeaderRow?: number;
         firstDataRow?: number;
         firstDataCol?: number;
+        rowPageCount?: number;
+        colPageCount?: number;
     };
     pivotFields: ParsedPivotField[];
     rowFields: number[];
     colFields: number[];
-    dataFields: ParsedDataField[];
+    pageFields: ParsedPageField[];
+    dataFields: DataField[];
     applyNumberFormats?: string;
     applyBorderFormats?: string;
     applyFontFormats?: string;
@@ -58,30 +96,54 @@ interface ParsedPivotTableModel {
     applyWidthHeightFormats?: string;
     dataCaption?: string;
     styleName?: string;
+    /** Full pivotTableStyleInfo attributes (preserved on roundtrip) */
+    styleInfo?: {
+        name?: string;
+        showRowHeaders?: string;
+        showColHeaders?: string;
+        showRowStripes?: string;
+        showColStripes?: string;
+        showLastColumn?: string;
+    };
     updatedVersion?: string;
     minRefreshableVersion?: string;
     createdVersion?: string;
-    useAutoFormatting?: boolean;
-    itemPrintTitles?: boolean;
+    useAutoFormatting?: string;
+    itemPrintTitles?: string;
     indent?: number;
     compact?: boolean;
     compactData?: boolean;
-    multipleFieldFilters?: boolean;
+    multipleFieldFilters?: string;
     outline?: boolean;
     outlineData?: boolean;
     chartFormat?: number;
+    colGrandTotals?: string;
+    rowGrandTotals?: string;
+    showError?: string;
+    errorCaption?: string;
+    showMissing?: string;
+    missingCaption?: string;
+    grandTotalCaption?: string;
     rowItems?: RowColItem[];
     colItems?: RowColItem[];
     hasColFields?: boolean;
+    hasRowItems?: boolean;
+    hasColItems?: boolean;
     chartFormats?: ChartFormatItem[];
+    extLstXml?: string;
+    formatsXml?: string;
+    conditionalFormatsXml?: string;
+    filtersXml?: string;
+    unknownElementsXml?: string;
     isLoaded?: boolean;
-    extensions?: any[];
 }
 /**
  * Row or column item in pivot table
  */
 interface RowColItem {
     t?: string;
+    r?: number;
+    i?: number;
     x: Array<{
         v: number;
     }>;
@@ -95,27 +157,28 @@ interface ChartFormatItem {
     series?: boolean;
     pivotAreaXml?: string;
 }
-declare class PivotTableXform extends BaseXform {
-    map: {
-        [key: string]: any;
-    };
-    model: ParsedPivotTableModel | null;
+declare class PivotTableXform extends BaseXform<ParsedPivotTableModel | null> {
     private state;
     private currentPivotField;
     private currentRowItem;
     private currentColItem;
     private currentChartFormat;
     private pivotAreaXmlBuffer;
-    private pivotAreaDepth;
+    private autoSortScopeXmlBuffer;
+    private extLstCollector;
+    private formatsCollector;
+    private conditionalFormatsCollector;
+    private filtersCollector;
+    private unknownCollector;
+    private unknownElementsXmlParts;
     constructor();
-    prepare(_model: any): void;
     get tag(): string;
     reset(): void;
     /**
      * Render pivot table XML.
      * Supports both newly created models and loaded models.
      */
-    render(xmlStream: any, model: PivotTableModel | ParsedPivotTableModel): void;
+    render(xmlStream: XmlStream, model: PivotTableRenderModel | ParsedPivotTableModel): void;
     /**
      * Render newly created pivot table
      */
@@ -124,6 +187,15 @@ declare class PivotTableXform extends BaseXform {
      * Render loaded pivot table (preserving original structure)
      */
     private renderLoaded;
+    /**
+     * Build the root `<pivotTableDefinition>` attributes for a loaded (roundtrip) model.
+     * Extracted from renderLoaded to keep the render method focused on element structure.
+     */
+    private buildLoadedRootAttributes;
+    /**
+     * Render `<chartFormats>` with preserved pivotArea XML for pivot chart roundtrip.
+     */
+    private renderChartFormats;
     /**
      * Render a row or column item element
      */
@@ -133,11 +205,13 @@ declare class PivotTableXform extends BaseXform {
      */
     private renderPivotFieldLoaded;
     parseOpen(node: any): boolean;
-    parseText(_text: string): void;
+    parseText(text: string): void;
+    /** Feed a close-tag to a collector; if it completes, store the result on the model. */
+    private tryCloseCollector;
     parseClose(name: string): boolean;
-    reconcile(_model: any, _options: any): void;
-    static PIVOT_TABLE_ATTRIBUTES: {
+    static readonly PIVOT_TABLE_ATTRIBUTES: {
         xmlns: string;
     };
+    static readonly EXTLST_XML: string;
 }
 export { PivotTableXform, type ParsedPivotTableModel };