@niicojs/excel 0.3.2 → 0.3.4

package/dist/index.cjs

@@ -434,8 +434,8 @@ const formatCellValue = (value, style, locale)=>{
     return null;
 };
 
-// Excel epoch: December 30, 1899 (accounting for the 1900 leap year bug)
-const EXCEL_EPOCH = new Date(Date.UTC(1899, 11, 30));
+// Excel epoch: December 31, 1899 (accounting for the 1900 leap year bug)
+const EXCEL_EPOCH = new Date(Date.UTC(1899, 11, 31));
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 // Excel error types
 const ERROR_TYPES = new Set([
@@ -712,8 +712,8 @@ const ERROR_TYPES = new Set([
    */ _excelDateToJs(serial) {
         // Excel incorrectly considers 1900 a leap year
         // Dates after Feb 28, 1900 need adjustment
-        const adjusted = serial > 60 ? serial - 1 : serial;
-        const ms = Math.round((adjusted - 1) * MS_PER_DAY);
+        const adjusted = serial >= 60 ? serial - 1 : serial;
+        const ms = Math.round(adjusted * MS_PER_DAY);
         return new Date(EXCEL_EPOCH.getTime() + ms);
     }
     /**
@@ -721,9 +721,9 @@ const ERROR_TYPES = new Set([
    * Used when writing dates as numbers for Excel compatibility
    */ _jsDateToExcel(date) {
         const ms = date.getTime() - EXCEL_EPOCH.getTime();
-        let serial = ms / MS_PER_DAY + 1;
+        let serial = ms / MS_PER_DAY;
         // Account for Excel's 1900 leap year bug
-        if (serial > 60) {
+        if (serial >= 60) {
             serial += 1;
         }
         return serial;
@@ -940,12 +940,18 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
     if (attrs && Object.keys(attrs).length > 0) {
         const attrObj = {};
         for (const [key, value] of Object.entries(attrs)){
-            attrObj[`@_${key}`] = value;
+            attrObj[`@_${key}`] = shouldEscapeXmlAttr(tagName, key) ? escapeXmlAttr(value) : value;
         }
         node[':@'] = attrObj;
     }
     return node;
 };
+const escapeXmlAttr = (value)=>{
+    return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/&apos;/g, "'");
+};
+const shouldEscapeXmlAttr = (tagName, attrName)=>{
+    return tagName === 's' && attrName === 'v';
+};
 /**
  * Creates a text node
  */ const createText = (text)=>{
@@ -2200,6 +2206,11 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
         return Math.max(this._totalCount, this.entries.length);
     }
     /**
+   * Get all unique shared strings in insertion order.
+   */ getAllStrings() {
+        return this.entries.map((entry)=>entry.text);
+    }
+    /**
    * Generate XML for the shared strings table
    */ toXml() {
         const siElements = [];
@@ -3321,7 +3332,6 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
                     baseItem: '0',
                     subtotal: f.aggregation || 'sum'
                 };
-                // Add numFmtId if it was resolved during addValueField
                 if (f.numFmtId !== undefined) {
                     attrs.numFmtId = String(f.numFmtId);
                 }
@@ -3331,8 +3341,6 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
                 count: String(dataFieldNodes.length)
             }, dataFieldNodes));
         }
-        // Check if any value field has a number format
-        const hasNumberFormats = this._valueFields.some((f)=>f.numFmtId !== undefined);
         // Pivot table style
         children.push(createElement('pivotTableStyleInfo', {
             name: 'PivotStyleMedium9',
@@ -3347,7 +3355,7 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
             'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
             name: this._name,
             cacheId: String(this._cache.cacheId),
-            applyNumberFormats: hasNumberFormats ? '1' : '0',
+            applyNumberFormats: '1',
             applyBorderFormats: '0',
             applyFontFormats: '0',
             applyPatternFormats: '0',
@@ -3607,15 +3615,24 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
         this._fields = [];
         this._records = [];
         this._recordCount = 0;
+        this._saveData = true;
         this._refreshOnLoad = true; // Default to true
         // Optimized lookup: Map<fieldIndex, Map<stringValue, sharedItemsIndex>>
         this._sharedItemsIndexMap = new Map();
+        this._blankItemIndexMap = new Map();
+        this._styles = null;
         this._cacheId = cacheId;
         this._fileIndex = fileIndex;
         this._sourceSheet = sourceSheet;
         this._sourceRange = sourceRange;
     }
     /**
+   * Set styles reference for number format resolution.
+   * @internal
+   */ setStyles(styles) {
+        this._styles = styles;
+    }
+    /**
    * Get the cache ID
    */ get cacheId() {
         return this._cacheId;
@@ -3631,11 +3648,21 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
         this._refreshOnLoad = value;
     }
     /**
+   * Set saveData option
+   */ set saveData(value) {
+        this._saveData = value;
+    }
+    /**
    * Get refreshOnLoad option
    */ get refreshOnLoad() {
         return this._refreshOnLoad;
     }
     /**
+   * Get saveData option
+   */ get saveData() {
+        return this._saveData;
+    }
+    /**
    * Get the source sheet name
    */ get sourceSheet() {
         return this._sourceSheet;
@@ -3672,46 +3699,81 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
                 index,
                 isNumeric: true,
                 isDate: false,
+                hasBoolean: false,
+                hasBlank: false,
+                numFmtId: undefined,
                 sharedItems: [],
                 minValue: undefined,
-                maxValue: undefined
+                maxValue: undefined,
+                minDate: undefined,
+                maxDate: undefined
             }));
-        // Use Sets for O(1) unique value collection during analysis
-        const sharedItemsSets = this._fields.map(()=>new Set());
+        // Use Maps for unique value collection during analysis
+        const sharedItemsMaps = this._fields.map(()=>new Map());
         // Analyze data to determine field types and collect unique values
         for (const row of data){
             for(let colIdx = 0; colIdx < row.length && colIdx < this._fields.length; colIdx++){
                 const value = row[colIdx];
                 const field = this._fields[colIdx];
                 if (value === null || value === undefined) {
+                    field.hasBlank = true;
                     continue;
                 }
                 if (typeof value === 'string') {
                     field.isNumeric = false;
-                    // O(1) Set.add instead of O(n) Array.includes + push
-                    sharedItemsSets[colIdx].add(value);
-                } else if (typeof value === 'number') {
-                    if (field.minValue === undefined || value < field.minValue) {
-                        field.minValue = value;
+                    const map = sharedItemsMaps[colIdx];
+                    if (!map.has(value)) {
+                        map.set(value, value);
                     }
-                    if (field.maxValue === undefined || value > field.maxValue) {
-                        field.maxValue = value;
+                } else if (typeof value === 'number') {
+                    if (field.isDate) {
+                        const d = this._excelSerialToDate(value);
+                        if (!field.minDate || d < field.minDate) {
+                            field.minDate = d;
+                        }
+                        if (!field.maxDate || d > field.maxDate) {
+                            field.maxDate = d;
+                        }
+                    } else {
+                        if (field.minValue === undefined || value < field.minValue) {
+                            field.minValue = value;
+                        }
+                        if (field.maxValue === undefined || value > field.maxValue) {
+                            field.maxValue = value;
+                        }
                     }
                 } else if (value instanceof Date) {
                     field.isDate = true;
                     field.isNumeric = false;
+                    if (!field.minDate || value < field.minDate) {
+                        field.minDate = value;
+                    }
+                    if (!field.maxDate || value > field.maxDate) {
+                        field.maxDate = value;
+                    }
                 } else if (typeof value === 'boolean') {
                     field.isNumeric = false;
+                    field.hasBoolean = true;
+                }
+            }
+        }
+        // Resolve number formats if styles are available
+        if (this._styles) {
+            const dateFmtId = this._styles.getOrCreateNumFmtId('mm-dd-yy');
+            for (const field of this._fields){
+                if (field.isDate) {
+                    field.numFmtId = dateFmtId;
                 }
             }
         }
         // Convert Sets to arrays and build reverse index Maps for O(1) lookup during XML generation
         this._sharedItemsIndexMap.clear();
+        this._blankItemIndexMap.clear();
         for(let colIdx = 0; colIdx < this._fields.length; colIdx++){
             const field = this._fields[colIdx];
-            const set = sharedItemsSets[colIdx];
-            // Convert Set to array (maintains insertion order in ES6+)
-            field.sharedItems = Array.from(set);
+            const map = sharedItemsMaps[colIdx];
+            // Convert Map values to array (maintains insertion order in ES6+)
+            field.sharedItems = Array.from(map.values());
             // Build reverse lookup Map: value -> index
             if (field.sharedItems.length > 0) {
                 const indexMap = new Map();
@@ -3719,6 +3781,10 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
                     indexMap.set(field.sharedItems[i], i);
                 }
                 this._sharedItemsIndexMap.set(colIdx, indexMap);
+                if (field.hasBlank) {
+                    const blankIndex = field.sharedItems.length;
+                    this._blankItemIndexMap.set(colIdx, blankIndex);
+                }
             }
         }
         // Store records
@@ -3742,33 +3808,78 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
             const sharedItemsAttrs = {};
             const sharedItemChildren = [];
             if (field.sharedItems.length > 0) {
-                // String field with shared items - Excel just uses count attribute
-                sharedItemsAttrs.count = String(field.sharedItems.length);
+                // String field with shared items
+                const total = field.hasBlank ? field.sharedItems.length + 1 : field.sharedItems.length;
+                sharedItemsAttrs.count = String(total);
+                sharedItemsAttrs.containsString = '1';
+                if (field.hasBlank) {
+                    sharedItemsAttrs.containsBlank = '1';
+                }
                 for (const item of field.sharedItems){
                     sharedItemChildren.push(createElement('s', {
                         v: item
                     }, []));
                 }
+                if (field.hasBlank) {
+                    sharedItemChildren.push(createElement('m', {}, []));
+                }
+            } else if (field.isDate) {
+                sharedItemsAttrs.containsSemiMixedTypes = '0';
+                sharedItemsAttrs.containsString = '0';
+                sharedItemsAttrs.containsDate = '1';
+                sharedItemsAttrs.containsNonDate = '0';
+                if (field.hasBlank) {
+                    sharedItemsAttrs.containsBlank = '1';
+                }
+                if (field.minDate) {
+                    sharedItemsAttrs.minDate = this._formatDate(field.minDate);
+                }
+                if (field.maxDate) {
+                    const maxDate = new Date(field.maxDate.getTime() + 24 * 60 * 60 * 1000);
+                    sharedItemsAttrs.maxDate = this._formatDate(maxDate);
+                }
             } else if (field.isNumeric) {
                 // Numeric field - use "0"/"1" for boolean attributes as Excel expects
                 sharedItemsAttrs.containsSemiMixedTypes = '0';
                 sharedItemsAttrs.containsString = '0';
                 sharedItemsAttrs.containsNumber = '1';
+                if (field.hasBlank) {
+                    sharedItemsAttrs.containsBlank = '1';
+                }
                 // Check if all values are integers
                 if (field.minValue !== undefined && field.maxValue !== undefined) {
                     const isInteger = Number.isInteger(field.minValue) && Number.isInteger(field.maxValue);
                     if (isInteger) {
                         sharedItemsAttrs.containsInteger = '1';
                     }
-                    sharedItemsAttrs.minValue = String(field.minValue);
-                    sharedItemsAttrs.maxValue = String(field.maxValue);
+                    sharedItemsAttrs.minValue = this._formatNumber(field.minValue);
+                    sharedItemsAttrs.maxValue = this._formatNumber(field.maxValue);
                 }
+            } else if (field.hasBoolean) {
+                // Boolean-only field (no strings, no numbers)
+                if (field.hasBlank) {
+                    sharedItemsAttrs.containsBlank = '1';
+                }
+                sharedItemsAttrs.count = field.hasBlank ? '3' : '2';
+                sharedItemChildren.push(createElement('b', {
+                    v: '0'
+                }, []));
+                sharedItemChildren.push(createElement('b', {
+                    v: '1'
+                }, []));
+                if (field.hasBlank) {
+                    sharedItemChildren.push(createElement('m', {}, []));
+                }
+            } else if (field.hasBlank) {
+                // Field that only contains blanks
+                sharedItemsAttrs.containsBlank = '1';
             }
             const sharedItemsNode = createElement('sharedItems', sharedItemsAttrs, sharedItemChildren);
-            return createElement('cacheField', {
+            const cacheFieldAttrs = {
                 name: field.name,
-                numFmtId: '0'
-            }, [
+                numFmtId: String(field.numFmtId ?? 0)
+            };
+            return createElement('cacheField', cacheFieldAttrs, [
                 sharedItemsNode
             ]);
         });
@@ -3784,22 +3895,25 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
         }, [
             worksheetSourceNode
         ]);
-        // Build attributes - refreshOnLoad should come early per OOXML schema
+        // Build attributes - align with Excel expectations
         const definitionAttrs = {
             xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
             'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
             'r:id': recordsRelId
         };
-        // Add refreshOnLoad early in attributes (default is true)
         if (this._refreshOnLoad) {
             definitionAttrs.refreshOnLoad = '1';
         }
-        // Continue with remaining attributes
         definitionAttrs.refreshedBy = 'User';
         definitionAttrs.refreshedVersion = '8';
         definitionAttrs.minRefreshableVersion = '3';
         definitionAttrs.createdVersion = '8';
-        definitionAttrs.recordCount = String(this._recordCount);
+        if (!this._saveData) {
+            definitionAttrs.saveData = '0';
+            definitionAttrs.recordCount = '0';
+        } else {
+            definitionAttrs.recordCount = String(this._recordCount);
+        }
         const definitionNode = createElement('pivotCacheDefinition', definitionAttrs, [
             cacheSourceNode,
             cacheFieldsNode
@@ -3818,7 +3932,14 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
                 const value = colIdx < row.length ? row[colIdx] : null;
                 if (value === null || value === undefined) {
                     // Missing value
-                    fieldNodes.push(createElement('m', {}, []));
+                    const blankIndex = this._blankItemIndexMap.get(colIdx);
+                    if (blankIndex !== undefined) {
+                        fieldNodes.push(createElement('x', {
+                            v: String(blankIndex)
+                        }, []));
+                    } else {
+                        fieldNodes.push(createElement('m', {}, []));
+                    }
                 } else if (typeof value === 'string') {
                     // String value - use index into sharedItems via O(1) Map lookup
                     const indexMap = this._sharedItemsIndexMap.get(colIdx);
@@ -3834,16 +3955,23 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
                         }, []));
                     }
                 } else if (typeof value === 'number') {
-                    fieldNodes.push(createElement('n', {
-                        v: String(value)
-                    }, []));
+                    if (this._fields[colIdx]?.isDate) {
+                        const d = this._excelSerialToDate(value);
+                        fieldNodes.push(createElement('d', {
+                            v: this._formatDate(d)
+                        }, []));
+                    } else {
+                        fieldNodes.push(createElement('n', {
+                            v: String(value)
+                        }, []));
+                    }
                 } else if (typeof value === 'boolean') {
                     fieldNodes.push(createElement('b', {
                         v: value ? '1' : '0'
                     }, []));
                 } else if (value instanceof Date) {
                     fieldNodes.push(createElement('d', {
-                        v: value.toISOString()
+                        v: this._formatDate(value)
                     }, []));
                 } else {
                     // Unknown type, treat as missing
@@ -3861,6 +3989,26 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
             recordsNode
         ])}`;
     }
+    _formatDate(value) {
+        return value.toISOString().replace(/\.\d{3}Z$/, '');
+    }
+    _formatNumber(value) {
+        if (Number.isInteger(value)) {
+            return String(value);
+        }
+        if (Math.abs(value) >= 1000000) {
+            return value.toFixed(16).replace(/0+$/, '').replace(/\.$/, '');
+        }
+        return String(value);
+    }
+    _excelSerialToDate(serial) {
+        // Excel epoch: December 31, 1899
+        const EXCEL_EPOCH = Date.UTC(1899, 11, 31);
+        const MS_PER_DAY = 24 * 60 * 60 * 1000;
+        const adjusted = serial >= 60 ? serial - 1 : serial;
+        const ms = Math.round(adjusted * MS_PER_DAY);
+        return new Date(EXCEL_EPOCH + ms);
+    }
 }
 
 /**
@@ -3868,6 +4016,19 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
  * @param data - ZIP file as Uint8Array
  * @returns Promise resolving to a map of file paths to contents
  */ const readZip = (data)=>{
+    const isBun = typeof globalThis.Bun !== 'undefined';
+    if (isBun) {
+        try {
+            const result = fflate.unzipSync(data);
+            const files = new Map();
+            for (const [path, content] of Object.entries(result)){
+                files.set(path, content);
+            }
+            return Promise.resolve(files);
+        } catch (error) {
+            return Promise.reject(error);
+        }
+    }
     return new Promise((resolve, reject)=>{
         fflate.unzip(data, (err, result)=>{
             if (err) {
@@ -3887,11 +4048,19 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
  * @param files - Map of file paths to contents
  * @returns Promise resolving to ZIP file as Uint8Array
  */ const writeZip = (files)=>{
-    return new Promise((resolve, reject)=>{
-        const zipData = {};
-        for (const [path, content] of files){
-            zipData[path] = content;
+    const zipData = {};
+    for (const [path, content] of files){
+        zipData[path] = content;
+    }
+    const isBun = typeof globalThis.Bun !== 'undefined';
+    if (isBun) {
+        try {
+            return Promise.resolve(fflate.zipSync(zipData));
+        } catch (error) {
+            return Promise.reject(error);
         }
+    }
+    return new Promise((resolve, reject)=>{
         fflate.zip(zipData, (err, result)=>{
             if (err) {
                 reject(err);
@@ -3926,7 +4095,7 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
         // Pivot table support
         this._pivotTables = [];
         this._pivotCaches = [];
-        this._nextCacheId = 0;
+        this._nextCacheId = 5;
         this._nextCacheFileIndex = 1;
         // Table support
         this._nextTableId = 1;
@@ -4395,11 +4564,16 @@ const builder = new fastXmlParser.XMLBuilder(builderOptions);
         const cacheId = this._nextCacheId++;
         const cacheFileIndex = this._nextCacheFileIndex++;
         const cache = new PivotCache(cacheId, sourceSheet, sourceRange, cacheFileIndex);
+        cache.setStyles(this._styles);
         cache.buildFromData(headers, data);
         // refreshOnLoad defaults to true; only disable if explicitly set to false
         if (config.refreshOnLoad === false) {
             cache.refreshOnLoad = false;
         }
+        // saveData defaults to true; only disable if explicitly set to false
+        if (config.saveData === false) {
+            cache.saveData = false;
+        }
         this._pivotCaches.push(cache);
         // Create pivot table
         const pivotTableIndex = this._pivotTables.length + 1;

package/dist/index.d.cts

@@ -133,6 +133,8 @@ interface PivotTableConfig {
     target: string;
     /** Refresh the pivot table data when the file is opened (default: true) */
     refreshOnLoad?: boolean;
+    /** Save pivot cache data in the file (default: true) */
+    saveData?: boolean;
 }
 /**
  * Internal representation of a pivot cache field
@@ -146,12 +148,22 @@ interface PivotCacheField {
     isNumeric: boolean;
     /** Whether this field contains dates */
     isDate: boolean;
+    /** Whether this field contains boolean values */
+    hasBoolean: boolean;
+    /** Whether this field contains blank (null/undefined) values */
+    hasBlank: boolean;
+    /** Number format ID for this field (cache field numFmtId) */
+    numFmtId?: number;
     /** Unique string values (for shared items) */
     sharedItems: string[];
     /** Min numeric value */
     minValue?: number;
     /** Max numeric value */
     maxValue?: number;
+    /** Min date value (for date fields) */
+    minDate?: Date;
+    /** Max date value (for date fields) */
+    maxDate?: Date;
 }
 /**
  * Pivot field axis assignment
@@ -780,6 +792,10 @@ declare class SharedStrings {
      * Get total usage count of shared strings
      */
     get totalCount(): number;
+    /**
+     * Get all unique shared strings in insertion order.
+     */
+    getAllStrings(): string[];
     /**
      * Generate XML for the shared strings table
      */
@@ -870,9 +886,17 @@ declare class PivotCache {
     private _fields;
     private _records;
     private _recordCount;
+    private _saveData;
     private _refreshOnLoad;
     private _sharedItemsIndexMap;
+    private _blankItemIndexMap;
+    private _styles;
     constructor(cacheId: number, sourceSheet: string, sourceRange: string, fileIndex: number);
+    /**
+     * Set styles reference for number format resolution.
+     * @internal
+     */
+    setStyles(styles: Styles): void;
     /**
      * Get the cache ID
      */
@@ -885,10 +909,18 @@ declare class PivotCache {
      * Set refreshOnLoad option
      */
     set refreshOnLoad(value: boolean);
+    /**
+     * Set saveData option
+     */
+    set saveData(value: boolean);
     /**
      * Get refreshOnLoad option
      */
     get refreshOnLoad(): boolean;
+    /**
+     * Get saveData option
+     */
+    get saveData(): boolean;
     /**
      * Get the source sheet name
      */
@@ -931,6 +963,9 @@ declare class PivotCache {
      * Generate the pivotCacheRecords XML
      */
     toRecordsXml(): string;
+    private _formatDate;
+    private _formatNumber;
+    private _excelSerialToDate;
 }
 
 /**