@cj-tech-master/excelts 2.0.1 → 3.0.0-canary.20251228183403.d3eb98d

package/dist/cjs/doc/pivot-table.js

@@ -37,8 +37,11 @@ function createTableSourceAdapter(table) {
     const endRow = startRow + tableModel.rows.length; // header row + data rows
     const endCol = startCol + columnNames.length - 1;
     const shortRange = col_cache_1.colCache.encode(startRow, startCol, endRow, endCol);
+    // Use the worksheet name (not table name) for pivotCacheDefinition's worksheetSource
+    // The sheet attribute in worksheetSource must reference the actual worksheet name
+    const worksheetName = table.worksheet.name;
     return {
-        name: tableModel.name,
+        name: worksheetName,
         getRow(rowNumber) {
             if (rowNumber === 1) {
                 return { values: headerRow };
@@ -111,7 +114,7 @@ function makePivotTable(worksheet, model) {
     validate(worksheet, model, source);
     const { rows, values } = model;
     const columns = model.columns ?? [];
-    const cacheFields = makeCacheFields(source, [...rows, ...columns]);
+    const cacheFields = makeCacheFields(source, [...rows, ...columns], values);
     const nameToIndex = cacheFields.reduce((result, cacheField, index) => {
         result[cacheField.name] = index;
         return result;
@@ -168,13 +171,15 @@ function validate(_worksheet, model, source) {
         throw new Error("It is currently not possible to have multiple values when columns are specified. Please either supply an empty array for columns or a single value.");
     }
 }
-function makeCacheFields(source, fieldNamesWithSharedItems) {
+function makeCacheFields(source, fieldNamesWithSharedItems, valueFieldNames) {
     // Cache fields are used in pivot tables to reference source data.
     // Fields in fieldNamesWithSharedItems get their unique values extracted as sharedItems.
-    // Other fields (typically numeric) have sharedItems = null.
+    // Fields in valueFieldNames (but not in fieldNamesWithSharedItems) get min/max calculated.
+    // Other fields are unused and get empty sharedItems.
     const names = source.getRow(1).values;
     // Use Set for O(1) lookup instead of object
     const sharedItemsFields = new Set(fieldNamesWithSharedItems);
+    const valueFields = new Set(valueFieldNames);
     const aggregate = (columnIndex) => {
         const columnValues = source.getColumn(columnIndex).values;
         // Build unique values set directly, skipping header (index 0,1) and null/undefined
@@ -187,12 +192,48 @@ function makeCacheFields(source, fieldNamesWithSharedItems) {
         }
         return (0, utils_1.toSortedArray)(uniqueValues);
     };
+    // Calculate min/max for numeric fields
+    const getMinMax = (columnIndex) => {
+        const columnValues = source.getColumn(columnIndex).values;
+        let min = Infinity;
+        let max = -Infinity;
+        let hasNumeric = false;
+        for (let i = 2; i < columnValues.length; i++) {
+            const v = columnValues[i];
+            if (typeof v === "number" && !isNaN(v)) {
+                hasNumeric = true;
+                if (v < min) {
+                    min = v;
+                }
+                if (v > max) {
+                    max = v;
+                }
+            }
+        }
+        return hasNumeric ? { minValue: min, maxValue: max } : null;
+    };
     // Build result array
     const result = [];
     for (const columnIndex of (0, utils_1.range)(1, names.length)) {
         const name = names[columnIndex];
-        const sharedItems = sharedItemsFields.has(name) ? aggregate(columnIndex) : null;
-        result.push({ name, sharedItems });
+        if (sharedItemsFields.has(name)) {
+            // Field used for rows/columns - extract unique values as sharedItems
+            result.push({ name, sharedItems: aggregate(columnIndex) });
+        }
+        else if (valueFields.has(name)) {
+            // Field used only for values (aggregation) - calculate min/max
+            const minMax = getMinMax(columnIndex);
+            result.push({
+                name,
+                sharedItems: null,
+                minValue: minMax?.minValue,
+                maxValue: minMax?.maxValue
+            });
+        }
+        else {
+            // Unused field - just empty sharedItems (like Excel does)
+            result.push({ name, sharedItems: null });
+        }
     }
     return result;
 }

package/dist/cjs/doc/worksheet.js

@@ -43,7 +43,6 @@ class Worksheet {
         // for tabColor, default row height, outline levels, etc
         this.properties = Object.assign({}, {
             defaultRowHeight: 15,
-            dyDescent: 55,
             outlineLevelCol: 0,
             outlineLevelRow: 0
         }, options.properties);

package/dist/cjs/stream/xlsx/worksheet-writer.js

@@ -98,7 +98,6 @@ class WorksheetWriter {
         // for default row height, outline levels, etc
         this.properties = Object.assign({}, {
             defaultRowHeight: 15,
-            dyDescent: 55,
             outlineLevelCol: 0,
             outlineLevelRow: 0
         }, options.properties);

package/dist/cjs/xlsx/xform/book/sheet-xform.js

@@ -6,9 +6,10 @@ const base_xform_1 = require("../base-xform");
 class WorksheetXform extends base_xform_1.BaseXform {
     render(xmlStream, model) {
         xmlStream.leafNode("sheet", {
-            sheetId: model.id,
             name: model.name,
-            state: model.state,
+            sheetId: model.id,
+            // Excel doesn't output state when it's 'visible' (default)
+            state: model.state === "visible" ? undefined : model.state,
             "r:id": model.rId
         });
     }

package/dist/cjs/xlsx/xform/book/workbook-properties-xform.js

@@ -6,7 +6,7 @@ class WorkbookPropertiesXform extends base_xform_1.BaseXform {
     render(xmlStream, model) {
         xmlStream.leafNode("workbookPr", {
             date1904: model.date1904 ? 1 : undefined,
-            defaultThemeVersion: 164011,
+            // Excel doesn't output defaultThemeVersion
             filterPrivacy: 1
         });
     }

package/dist/cjs/xlsx/xform/core/content-types-xform.js

@@ -41,7 +41,7 @@ class ContentTypesXform extends base_xform_1.BaseXform {
             });
         });
         if ((model.pivotTables || []).length) {
-            // Add content types for each pivot table
+            // Add content types for pivot cache (definition and records)
             (model.pivotTables || []).forEach((pivotTable) => {
                 const n = pivotTable.tableNumber;
                 xmlStream.leafNode("Override", {
@@ -52,10 +52,6 @@ class ContentTypesXform extends base_xform_1.BaseXform {
                     PartName: `/xl/pivotCache/pivotCacheRecords${n}.xml`,
                     ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"
                 });
-                xmlStream.leafNode("Override", {
-                    PartName: `/xl/pivotTables/pivotTable${n}.xml`,
-                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"
-                });
             });
         }
         xmlStream.leafNode("Override", {
@@ -81,6 +77,16 @@ class ContentTypesXform extends base_xform_1.BaseXform {
                 });
             });
         }
+        // Add pivot table overrides after tables (matches Excel order)
+        if ((model.pivotTables || []).length) {
+            (model.pivotTables || []).forEach((pivotTable) => {
+                const n = pivotTable.tableNumber;
+                xmlStream.leafNode("Override", {
+                    PartName: `/xl/pivotTables/pivotTable${n}.xml`,
+                    ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"
+                });
+            });
+        }
         if (model.drawings) {
             model.drawings.forEach((drawing) => {
                 xmlStream.leafNode("Override", {
@@ -89,7 +95,7 @@ class ContentTypesXform extends base_xform_1.BaseXform {
                 });
             });
         }
-        if (model.commentRefs) {
+        if (model.commentRefs && model.commentRefs.length) {
             xmlStream.leafNode("Default", {
                 Extension: "vml",
                 ContentType: "application/vnd.openxmlformats-officedocument.vmlDrawing"

package/dist/cjs/xlsx/xform/pivot-table/cache-field-xform.js

@@ -47,28 +47,24 @@ class CacheFieldXform extends base_xform_1.BaseXform {
                 break;
             case "sharedItems":
                 this.inSharedItems = true;
-                // Check if this is a numeric field (no string items)
-                if (attributes.containsNumber === "1" || attributes.containsInteger === "1") {
-                    if (this.model) {
-                        this.model.containsNumber = attributes.containsNumber === "1";
-                        this.model.containsInteger = attributes.containsInteger === "1";
-                        if (attributes.minValue !== undefined) {
-                            this.model.minValue = parseFloat(attributes.minValue);
-                        }
-                        if (attributes.maxValue !== undefined) {
-                            this.model.maxValue = parseFloat(attributes.maxValue);
-                        }
-                        // Numeric fields have sharedItems = null
-                        this.model.sharedItems = null;
+                // Store numeric field metadata
+                if (this.model) {
+                    this.model.containsNumber = attributes.containsNumber === "1";
+                    this.model.containsInteger = attributes.containsInteger === "1";
+                    if (attributes.minValue !== undefined) {
+                        this.model.minValue = parseFloat(attributes.minValue);
                     }
-                }
-                else {
-                    // String field - initialize sharedItems array if count > 0
-                    if (this.model) {
-                        const count = parseInt(attributes.count || "0", 10);
-                        if (count > 0) {
-                            this.model.sharedItems = [];
-                        }
+                    if (attributes.maxValue !== undefined) {
+                        this.model.maxValue = parseFloat(attributes.maxValue);
+                    }
+                    // Initialize sharedItems array if count > 0 (for both string and numeric fields)
+                    const count = parseInt(attributes.count || "0", 10);
+                    if (count > 0) {
+                        this.model.sharedItems = [];
+                    }
+                    else {
+                        // No count means no individual items (pure numeric field)
+                        this.model.sharedItems = null;
                     }
                 }
                 break;

package/dist/cjs/xlsx/xform/pivot-table/cache-field.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheField = void 0;
 const utils_1 = require("../../../utils/utils");
 class CacheField {
-    constructor({ name, sharedItems }) {
+    constructor({ name, sharedItems, minValue, maxValue }) {
         // string type
         //
         // {
@@ -13,28 +13,64 @@ class CacheField {
         //
         // or
         //
-        // integer type
+        // integer type (no sharedItems)
         //
         // {
         //   'name': 'D',
-        //   'sharedItems': null
+        //   'sharedItems': null,
+        //   'minValue': 5,
+        //   'maxValue': 45
+        // }
+        //
+        // or
+        //
+        // numeric type with shared items (used as both row/column and value field)
+        //
+        // {
+        //   'name': 'C',
+        //   'sharedItems': [5, 24, 35, 45]
         // }
         this.name = name;
         this.sharedItems = sharedItems;
+        this.minValue = minValue;
+        this.maxValue = maxValue;
     }
     render() {
         // PivotCache Field: http://www.datypic.com/sc/ooxml/e-ssml_cacheField-1.html
         // Shared Items: http://www.datypic.com/sc/ooxml/e-ssml_sharedItems-1.html
         // Escape XML special characters in name attribute
         const escapedName = (0, utils_1.xmlEncode)(this.name);
-        // integer types
+        // No shared items - field not used for rows/columns
         if (this.sharedItems === null) {
-            // TK(2023-07-18): left out attributes... minValue="5" maxValue="45"
+            // If no minValue/maxValue, this is an unused field - use empty sharedItems like Excel does
+            if (this.minValue === undefined || this.maxValue === undefined) {
+                return `<cacheField name="${escapedName}" numFmtId="0">
+      <sharedItems />
+    </cacheField>`;
+            }
+            // Numeric field used only for values (not rows/columns) - include min/max
             return `<cacheField name="${escapedName}" numFmtId="0">
-      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="1" />
+      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="1" minValue="${this.minValue}" maxValue="${this.maxValue}" />
+    </cacheField>`;
+        }
+        // Shared items exist - check if all values are numeric
+        // Note: empty array returns true for every(), so check length first
+        const allNumeric = this.sharedItems.length > 0 &&
+            this.sharedItems.every(item => typeof item === "number" && Number.isFinite(item));
+        const allInteger = allNumeric && this.sharedItems.every(item => Number.isInteger(item));
+        if (allNumeric) {
+            // Numeric shared items - used when field is both a row/column field AND a value field
+            // This allows Excel to both group by unique values AND perform aggregation
+            const minValue = Math.min(...this.sharedItems);
+            const maxValue = Math.max(...this.sharedItems);
+            const integerAttr = allInteger ? ' containsInteger="1"' : "";
+            return `<cacheField name="${escapedName}" numFmtId="0">
+      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1"${integerAttr} minValue="${minValue}" maxValue="${maxValue}" count="${this.sharedItems.length}">
+        ${this.sharedItems.map(item => `<n v="${item}" />`).join("")}
+      </sharedItems>
     </cacheField>`;
         }
-        // string types - escape XML special characters in each shared item value
+        // String shared items - escape XML special characters in each value
         return `<cacheField name="${escapedName}" numFmtId="0">
       <sharedItems count="${this.sharedItems.length}">
         ${this.sharedItems.map(item => `<s v="${(0, utils_1.xmlEncode)(String(item))}" />`).join("")}

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

@@ -53,8 +53,6 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
             ...PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES,
             "r:id": "rId1",
             refreshOnLoad: "1", // important for our implementation to work
-            refreshedBy: "Author",
-            refreshedDate: "45125.026046874998",
             createdVersion: "8",
             refreshedVersion: "8",
             minRefreshableVersion: "3",
@@ -82,8 +80,6 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
             ...PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES,
             "r:id": model.rId || "rId1",
             refreshOnLoad: model.refreshOnLoad || "1",
-            refreshedBy: model.refreshedBy || "Author",
-            refreshedDate: model.refreshedDate || "45125.026046874998",
             createdVersion: model.createdVersion || "8",
             refreshedVersion: model.refreshedVersion || "8",
             minRefreshableVersion: model.minRefreshableVersion || "3",
@@ -117,8 +113,6 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
                     cacheFields: [],
                     rId: attributes["r:id"],
                     refreshOnLoad: attributes.refreshOnLoad,
-                    refreshedBy: attributes.refreshedBy,
-                    refreshedDate: attributes.refreshedDate,
                     createdVersion: attributes.createdVersion,
                     refreshedVersion: attributes.refreshedVersion,
                     minRefreshableVersion: attributes.minRefreshableVersion,
@@ -184,8 +178,5 @@ class PivotCacheDefinitionXform extends base_xform_1.BaseXform {
 exports.PivotCacheDefinitionXform = PivotCacheDefinitionXform;
 PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES = {
     xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
-    "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
-    "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
-    "mc:Ignorable": "xr",
-    "xmlns:xr": "http://schemas.microsoft.com/office/spreadsheetml/2014/revision"
+    "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
 };

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

@@ -119,7 +119,7 @@ class PivotCacheRecordsXform extends base_xform_1.BaseXform {
             }
             return `<s v="${(0, utils_1.xmlEncode)(String(value))}" />`;
         }
-        // shared items
+        // shared items - use indexOf for value lookup (works for both string and numeric)
         const sharedItemsIndex = sharedItems.indexOf(value);
         if (sharedItemsIndex < 0) {
             throw new Error(`${JSON.stringify(value)} not in sharedItems ${JSON.stringify(sharedItems)}`);

package/dist/cjs/xlsx/xform/pivot-table/pivot-table-xform.js

@@ -58,8 +58,6 @@ class PivotTableXform extends base_xform_1.BaseXform {
      */
     renderNew(xmlStream, model) {
         const { rows, columns, values, cacheFields, cacheId, applyWidthHeightFormats } = model;
-        // Generate unique UID for each pivot table to prevent Excel treating them as identical
-        const uniqueUid = `{${crypto.randomUUID().toUpperCase()}}`;
         // Build rowItems - need one <i> for each unique value in row fields, plus grand total
         const rowItems = buildRowItems(rows, cacheFields);
         // Build colItems - need one <i> for each unique value in col fields, plus grand total
@@ -71,15 +69,20 @@ class PivotTableXform extends base_xform_1.BaseXform {
         // - firstHeaderRow: 1 (column headers are in first row of pivot table)
         // - firstDataRow: 2 (data starts in second row)
         // - firstDataCol: 1 (data starts in second column, after row labels)
-        // Calculate ref based on actual data size
-        const endRow = 3 + rowFieldItemCount + 1; // start row + data rows + grand total
+        // Calculate ref based on actual data size:
+        // - Start row: 3
+        // - Header rows: 2 (column label row + subheader row)
+        // - Data rows: rowFieldItemCount
+        // - Grand total row: 1
+        // endRow = 3 + 2 + rowFieldItemCount + 1 - 1 = 5 + rowFieldItemCount
+        // Or simplified: startRow (3) + 1 (column labels) + rowFieldItemCount (data) + 1 (grand total)
+        const endRow = 3 + 1 + rowFieldItemCount + 1; // = 5 + rowFieldItemCount
         const endCol = 1 + colFieldItemCount + 1; // start col + data cols + grand total
         const endColLetter = String.fromCharCode(64 + endCol);
         const locationRef = `A3:${endColLetter}${endRow}`;
         xmlStream.openXml(xml_stream_1.XmlStream.StdDocAttributes);
         xmlStream.openNode(this.tag, {
             ...PivotTableXform.PIVOT_TABLE_ATTRIBUTES,
-            "xr:uid": uniqueUid,
             name: "PivotTable2",
             cacheId,
             applyNumberFormats: "0",
@@ -156,11 +159,9 @@ class PivotTableXform extends base_xform_1.BaseXform {
      * Render loaded pivot table (preserving original structure)
      */
     renderLoaded(xmlStream, model) {
-        const uniqueUid = model.uid || `{${crypto.randomUUID().toUpperCase()}}`;
         xmlStream.openXml(xml_stream_1.XmlStream.StdDocAttributes);
         xmlStream.openNode(this.tag, {
             ...PivotTableXform.PIVOT_TABLE_ATTRIBUTES,
-            "xr:uid": uniqueUid,
             name: model.name || "PivotTable1",
             cacheId: model.cacheId,
             applyNumberFormats: model.applyNumberFormats || "0",
@@ -474,17 +475,15 @@ class PivotTableXform extends base_xform_1.BaseXform {
 }
 exports.PivotTableXform = PivotTableXform;
 PivotTableXform.PIVOT_TABLE_ATTRIBUTES = {
-    xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
-    "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
-    "mc:Ignorable": "xr",
-    "xmlns:xr": "http://schemas.microsoft.com/office/spreadsheetml/2014/revision"
+    xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
 };
 // Helpers
 /**
  * Build rowItems XML - one item for each unique value in row fields, plus grand total.
  * Each <i> represents a row in the pivot table.
- * - Regular items: <i><x v="index"/></i> where index is the position in sharedItems
+ * - Regular items: <i><x/></i> for index 0, <i><x v="index"/></i> for index > 0
  * - Grand total: <i t="grand"><x/></i>
+ * Note: When v=0, the v attribute should be omitted (Excel convention)
  */
 function buildRowItems(rows, cacheFields) {
     if (rows.length === 0) {
@@ -498,8 +497,14 @@ function buildRowItems(rows, cacheFields) {
     // Build items: one for each unique value + grand total
     const items = [];
     // Regular items - reference each unique value by index
+    // Note: v="0" should be omitted (Excel uses <x/> instead of <x v="0"/>)
     for (let i = 0; i < itemCount; i++) {
-        items.push(`<i><x v="${i}" /></i>`);
+        if (i === 0) {
+            items.push("<i><x /></i>");
+        }
+        else {
+            items.push(`<i><x v="${i}" /></i>`);
+        }
     }
     // Grand total row
     items.push('<i t="grand"><x /></i>');
@@ -511,6 +516,7 @@ function buildRowItems(rows, cacheFields) {
 /**
  * Build colItems XML - one item for each unique value in column fields, plus grand total.
  * When there are multiple data fields (values), each column value may have sub-columns.
+ * Note: When v=0, the v attribute should be omitted (Excel convention)
  */
 function buildColItems(columns, cacheFields, valueCount) {
     if (columns.length === 0) {
@@ -519,7 +525,12 @@ function buildColItems(columns, cacheFields, valueCount) {
             // Multiple values: one column per value + grand total
             const items = [];
             for (let i = 0; i < valueCount; i++) {
-                items.push(`<i><x v="${i}" /></i>`);
+                if (i === 0) {
+                    items.push("<i><x /></i>");
+                }
+                else {
+                    items.push(`<i><x v="${i}" /></i>`);
+                }
             }
             items.push('<i t="grand"><x /></i>');
             return { count: items.length, xml: items.join("\n        ") };
@@ -534,8 +545,14 @@ function buildColItems(columns, cacheFields, valueCount) {
     // Build items: one for each unique value + grand total
     const items = [];
     // Regular items - reference each unique value by index
+    // Note: v="0" should be omitted (Excel uses <x/> instead of <x v="0"/>)
     for (let i = 0; i < itemCount; i++) {
-        items.push(`<i><x v="${i}" /></i>`);
+        if (i === 0) {
+            items.push("<i><x /></i>");
+        }
+        else {
+            items.push(`<i><x v="${i}" /></i>`);
+        }
     }
     // Grand total column
     items.push('<i t="grand"><x /></i>');
@@ -568,38 +585,42 @@ function renderPivotFields(pivotTable) {
     const valueSet = new Set(pivotTable.values);
     return pivotTable.cacheFields
         .map((cacheField, fieldIndex) => {
-        const fieldType = rowSet.has(fieldIndex)
-            ? "row"
-            : colSet.has(fieldIndex)
-                ? "column"
-                : valueSet.has(fieldIndex)
-                    ? "value"
-                    : null;
-        return renderPivotField(fieldType, cacheField.sharedItems);
+        const isRow = rowSet.has(fieldIndex);
+        const isCol = colSet.has(fieldIndex);
+        const isValue = valueSet.has(fieldIndex);
+        return renderPivotField(isRow, isCol, isValue, cacheField.sharedItems);
     })
         .join("");
 }
-function renderPivotField(fieldType, sharedItems) {
-    // fieldType: 'row', 'column', 'value', null
-    const defaultAttributes = 'compact="0" outline="0" showAll="0" defaultSubtotal="0"';
-    if (fieldType === "row" || fieldType === "column") {
-        const axis = fieldType === "row" ? "axisRow" : "axisCol";
+function renderPivotField(isRow, isCol, isValue, sharedItems) {
+    // A field can be both a row/column field AND a value field (issue #15)
+    // In this case, it needs both axis attribute AND dataField="1"
+    if (isRow || isCol) {
+        const axis = isRow ? "axisRow" : "axisCol";
+        // Row and column fields should NOT have defaultSubtotal="0"
+        let axisAttributes = 'compact="0" outline="0" showAll="0"';
+        // If also a value field, add dataField="1"
+        if (isValue) {
+            axisAttributes = `dataField="1" ${axisAttributes}`;
+        }
         // items = one for each shared item + one default item
         const itemsXml = [
             ...sharedItems.map((_item, index) => `<item x="${index}" />`),
             '<item t="default" />' // Required default item for subtotals/grand totals
         ].join("\n              ");
         return `
-      <pivotField axis="${axis}" ${defaultAttributes}>
+      <pivotField axis="${axis}" ${axisAttributes}>
         <items count="${sharedItems.length + 1}">
           ${itemsXml}
         </items>
       </pivotField>
     `;
     }
+    // Value fields and non-axis fields should have defaultSubtotal="0"
+    const defaultAttributes = 'compact="0" outline="0" showAll="0" defaultSubtotal="0"';
     return `
     <pivotField
-      ${fieldType === "value" ? 'dataField="1"' : ""}
+      ${isValue ? 'dataField="1"' : ""}
       ${defaultAttributes}
     />
   `;

package/dist/cjs/xlsx/xform/sheet/page-setup-xform.js

@@ -51,9 +51,10 @@ class PageSetupXform extends base_xform_1.BaseXform {
                 draft: booleanToXml(model.draft),
                 cellComments: cellCommentsToXml(model.cellComments),
                 errors: errorsToXml(model.errors),
-                scale: model.scale,
-                fitToWidth: model.fitToWidth,
-                fitToHeight: model.fitToHeight,
+                // Only output non-default values (matches Excel behavior)
+                scale: model.scale !== 100 ? model.scale : undefined,
+                fitToWidth: model.fitToWidth !== 1 ? model.fitToWidth : undefined,
+                fitToHeight: model.fitToHeight !== 1 ? model.fitToHeight : undefined,
                 firstPageNumber: model.firstPageNumber,
                 useFirstPageNumber: booleanToXml(!!model.firstPageNumber),
                 usePrinterDefaults: booleanToXml(model.usePrinterDefaults),

package/dist/cjs/xlsx/xform/sheet/row-xform.js

@@ -51,7 +51,7 @@ class RowXform extends base_xform_1.BaseXform {
             xmlStream.addAttribute("s", model.styleId);
             xmlStream.addAttribute("customFormat", "1");
         }
-        xmlStream.addAttribute("x14ac:dyDescent", "0.25");
+        // Note: dyDescent is MS extension, not output by default (Excel auto-calculates)
         if (model.outlineLevel) {
             xmlStream.addAttribute("outlineLevel", model.outlineLevel);
         }

package/dist/cjs/xlsx/xform/sheet/sheet-format-properties-xform.js

@@ -10,10 +10,13 @@ class SheetFormatPropertiesXform extends base_xform_1.BaseXform {
         if (model) {
             const attributes = {
                 defaultRowHeight: model.defaultRowHeight,
-                outlineLevelRow: model.outlineLevelRow,
-                outlineLevelCol: model.outlineLevelCol,
-                "x14ac:dyDescent": model.dyDescent
+                // Only output outlineLevelRow/Col when non-zero (matches Excel behavior)
+                outlineLevelRow: model.outlineLevelRow || undefined,
+                outlineLevelCol: model.outlineLevelCol || undefined,
+                // Only output dyDescent if explicitly set (MS extension, not ECMA-376 standard)
+                "x14ac:dyDescent": model.dyDescent || undefined
             };
+            // Only output defaultColWidth if explicitly set
             if (model.defaultColWidth) {
                 attributes.defaultColWidth = model.defaultColWidth;
             }

package/dist/cjs/xlsx/xform/sheet/sheet-view-xform.js

@@ -23,16 +23,20 @@ class SheetViewXform extends base_xform_1.BaseXform {
         }
     }
     render(xmlStream, model) {
-        xmlStream.openNode("sheetView", {
-            workbookViewId: model.workbookViewId || 0
-        });
+        // Build initial attributes with correct order to match Excel output
+        const initialAttrs = {};
+        if (model.tabSelected) {
+            initialAttrs.tabSelected = "1";
+        }
+        initialAttrs.workbookViewId = model.workbookViewId || 0;
+        xmlStream.openNode("sheetView", initialAttrs);
         const add = function (name, value, included) {
             if (included) {
                 xmlStream.addAttribute(name, value);
             }
         };
         add("rightToLeft", "1", model.rightToLeft === true);
-        add("tabSelected", "1", model.tabSelected);
+        // tabSelected is now in initialAttrs
         add("showRuler", "0", model.showRuler === false);
         add("showRowColHeaders", "0", model.showRowColHeaders === false);
         add("showGridLines", "0", model.showGridLines === false);

package/dist/cjs/xlsx/xform/sheet/worksheet-xform.js

@@ -515,6 +515,6 @@ WorkSheetXform.WORKSHEET_ATTRIBUTES = {
     xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
     "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
     "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
-    "mc:Ignorable": "x14ac",
-    "xmlns:x14ac": "http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac"
+    "xmlns:x14ac": "http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac",
+    "mc:Ignorable": "x14ac"
 };