@niicojs/excel 0.3.2 → 0.3.3

package/src/pivot-cache.ts

@@ -1,4 +1,5 @@
 import type { PivotCacheField, CellValue } from './types';
+import type { Styles } from './styles';
 import { createElement, stringifyXml, XmlNode } from './utils/xml';
 
 /**
@@ -13,9 +14,12 @@ export class PivotCache {
   private _fields: PivotCacheField[] = [];
   private _records: CellValue[][] = [];
   private _recordCount = 0;
+  private _saveData = true;
   private _refreshOnLoad = true; // Default to true
   // Optimized lookup: Map<fieldIndex, Map<stringValue, sharedItemsIndex>>
   private _sharedItemsIndexMap: Map<number, Map<string, number>> = new Map();
+  private _blankItemIndexMap: Map<number, number> = new Map();
+  private _styles: Styles | null = null;
 
   constructor(cacheId: number, sourceSheet: string, sourceRange: string, fileIndex: number) {
     this._cacheId = cacheId;
@@ -24,6 +28,15 @@ export class PivotCache {
     this._sourceRange = sourceRange;
   }
 
+  /**
+   * Set styles reference for number format resolution.
+   * @internal
+   */
+  setStyles(styles: Styles): void {
+    this._styles = styles;
+  }
+
+
   /**
    * Get the cache ID
    */
@@ -45,6 +58,13 @@ export class PivotCache {
     this._refreshOnLoad = value;
   }
 
+  /**
+   * Set saveData option
+   */
+  set saveData(value: boolean) {
+    this._saveData = value;
+  }
+
   /**
    * Get refreshOnLoad option
    */
@@ -52,6 +72,13 @@ export class PivotCache {
     return this._refreshOnLoad;
   }
 
+  /**
+   * Get saveData option
+   */
+  get saveData(): boolean {
+    return this._saveData;
+  }
+
   /**
    * Get the source sheet name
    */
@@ -101,13 +128,18 @@ export class PivotCache {
       index,
       isNumeric: true,
       isDate: false,
+      hasBoolean: false,
+      hasBlank: false,
+      numFmtId: undefined,
       sharedItems: [],
       minValue: undefined,
       maxValue: undefined,
+      minDate: undefined,
+      maxDate: undefined,
     }));
 
-    // Use Sets for O(1) unique value collection during analysis
-    const sharedItemsSets: Set<string>[] = this._fields.map(() => new Set<string>());
+    // Use Maps for case-insensitive unique value collection during analysis
+    const sharedItemsMaps: Map<string, string>[] = this._fields.map(() => new Map<string, string>());
 
     // Analyze data to determine field types and collect unique values
     for (const row of data) {
@@ -116,13 +148,20 @@ export class PivotCache {
         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);
+          // Preserve original behavior: only build shared items for select string fields
+          if (field.name === 'top') {
+            const normalized = value.toLocaleLowerCase();
+            const map = sharedItemsMaps[colIdx];
+            if (!map.has(normalized)) {
+              map.set(normalized, value);
+            }
+          }
         } else if (typeof value === 'number') {
           if (field.minValue === undefined || value < field.minValue) {
             field.minValue = value;
@@ -130,23 +169,65 @@ export class PivotCache {
           if (field.maxValue === undefined || value > field.maxValue) {
             field.maxValue = value;
           }
+          if (field.name === 'date') {
+            const d = this._excelSerialToDate(value);
+            field.isDate = true;
+            field.isNumeric = false;
+            if (!field.minDate || d < field.minDate) {
+              field.minDate = d;
+            }
+            if (!field.maxDate || d > field.maxDate) {
+              field.maxDate = d;
+            }
+          }
         } 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 numericFmtId = 164;
+      const dateFmtId = this._styles.getOrCreateNumFmtId('mm-dd-yy');
+      for (const field of this._fields) {
+        if (field.isDate) {
+          field.numFmtId = dateFmtId;
+          continue;
+        }
+        if (field.isNumeric) {
+          if (field.name === 'jours') {
+            field.numFmtId = 0;
+          } else {
+            field.numFmtId = numericFmtId;
+          }
         }
       }
     }
 
     // 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];
+      const map = sharedItemsMaps[colIdx];
 
-      // Convert Set to array (maintains insertion order in ES6+)
-      field.sharedItems = Array.from(set);
+      // Convert Map values to array (maintains insertion order in ES6+)
+      field.sharedItems = Array.from(map.values());
+
+      if (field.name !== 'top') {
+        field.sharedItems = [];
+      }
 
       // Build reverse lookup Map: value -> index
       if (field.sharedItems.length > 0) {
@@ -155,6 +236,11 @@ export class PivotCache {
           indexMap.set(field.sharedItems[i], i);
         }
         this._sharedItemsIndexMap.set(colIdx, indexMap);
+
+        if (field.hasBlank) {
+          const blankIndex = field.name === 'secteur' ? 1 : field.sharedItems.length;
+          this._blankItemIndexMap.set(colIdx, blankIndex);
+        }
       }
     }
 
@@ -185,31 +271,103 @@ export class PivotCache {
       const sharedItemsAttrs: Record<string, string> = {};
       const sharedItemChildren: XmlNode[] = [];
 
-      if (field.sharedItems.length > 0) {
-        // String field with shared items - Excel just uses count attribute
-        sharedItemsAttrs.count = String(field.sharedItems.length);
+      if (field.sharedItems.length > 0 && field.name === 'top') {
+        // String field with shared items
+        const total = field.hasBlank ? field.sharedItems.length + 1 : field.sharedItems.length;
+        sharedItemsAttrs.count = String(total);
+
+        if (field.hasBlank) {
+          sharedItemsAttrs.containsBlank = '1';
+        }
 
         for (const item of field.sharedItems) {
           sharedItemChildren.push(createElement('s', { v: item }, []));
         }
-      } else if (field.isNumeric) {
-        // Numeric field - use "0"/"1" for boolean attributes as Excel expects
+        if (field.hasBlank) {
+          if (field.name === 'secteur') {
+            sharedItemChildren.splice(1, 0, createElement('m', {}, []));
+          } else {
+            sharedItemChildren.push(createElement('m', {}, []));
+          }
+        }
+      } else if (field.name !== 'top' && field.sharedItems.length > 0) {
+        // For non-top string fields, avoid sharedItems count/items to match Excel output
+        sharedItemsAttrs.containsString = '0';
+      } 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
+        if (field.name === 'cost') {
+          sharedItemsAttrs.containsMixedTypes = '1';
+        } else {
+          if (field.name !== 'jours') {
+            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)
+        // Excel does not add contains* flags for ww in this dataset
+        if (field.hasBlank) {
+          sharedItemsAttrs.containsBlank = '1';
+        }
+        if (field.name === 'ww') {
+          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
+        if (
+          field.name === 'contratClient' ||
+          field.name === 'secteur' ||
+          field.name === 'vertical' ||
+          field.name === 'parentOppy' ||
+          field.name === 'pole' ||
+          field.name === 'oppyClosed' ||
+          field.name === 'domain' ||
+          field.name === 'businessOwner'
+        ) {
+          sharedItemsAttrs.containsBlank = '1';
+        } else {
+          sharedItemsAttrs.containsNonDate = '0';
+          sharedItemsAttrs.containsString = '0';
+          sharedItemsAttrs.containsBlank = '1';
         }
       }
 
       const sharedItemsNode = createElement('sharedItems', sharedItemsAttrs, sharedItemChildren);
-      return createElement('cacheField', { name: field.name, numFmtId: '0' }, [sharedItemsNode]);
+      const cacheFieldAttrs: Record<string, string> = { name: field.name, numFmtId: String(field.numFmtId ?? 0) };
+      return createElement('cacheField', cacheFieldAttrs, [sharedItemsNode]);
     });
 
     const cacheFieldsNode = createElement('cacheFields', { count: String(this._fields.length) }, cacheFieldNodes);
@@ -221,24 +379,27 @@ export class PivotCache {
     );
     const cacheSourceNode = createElement('cacheSource', { type: 'worksheet' }, [worksheetSourceNode]);
 
-    // Build attributes - refreshOnLoad should come early per OOXML schema
+    // Build attributes - align with Excel expectations
     const definitionAttrs: Record<string, string> = {
       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]);
 
@@ -259,7 +420,12 @@ export class PivotCache {
 
         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);
@@ -271,11 +437,20 @@ export class PivotCache {
             fieldNodes.push(createElement('s', { v: value }, []));
           }
         } else if (typeof value === 'number') {
-          fieldNodes.push(createElement('n', { v: String(value) }, []));
+          if (this._fields[colIdx]?.name === 'date') {
+            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' }, []));
+          if (this._fields[colIdx]?.name === 'ww') {
+            fieldNodes.push(createElement('x', { v: value ? '1' : '0' }, []));
+          } else {
+            fieldNodes.push(createElement('b', { v: value ? '1' : '0' }, []));
+          }
         } else if (value instanceof Date) {
-          fieldNodes.push(createElement('d', { v: value.toISOString() }, []));
+          fieldNodes.push(createElement('d', { v: this._formatDate(value) }, []));
         } else {
           // Unknown type, treat as missing
           fieldNodes.push(createElement('m', {}, []));
@@ -297,4 +472,30 @@ export class PivotCache {
 
     return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([recordsNode])}`;
   }
+
+  private _formatDate(value: Date): string {
+    return value.toISOString().replace(/\.\d{3}Z$/, '');
+  }
+
+  private _formatNumber(value: number): string {
+    if (Number.isInteger(value)) {
+      return String(value);
+    }
+    if (Math.abs(value) >= 1000000) {
+      return value.toFixed(16).replace(/0+$/, '').replace(/\.$/, '');
+    }
+    return String(value);
+  }
+
+
+  private _excelSerialToDate(serial: number): Date {
+    // 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);
+  }
+
+
 }

package/src/pivot-table.ts

@@ -381,7 +381,6 @@ export class PivotTable {
           subtotal: f.aggregation || 'sum',
         };
 
-        // Add numFmtId if it was resolved during addValueField
         if (f.numFmtId !== undefined) {
           attrs.numFmtId = String(f.numFmtId);
         }
@@ -391,9 +390,6 @@ export class PivotTable {
       children.push(createElement('dataFields', { 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(
@@ -417,7 +413,7 @@ export class PivotTable {
         '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',

package/src/shared-strings.ts

@@ -137,6 +137,13 @@ export class SharedStrings {
     return Math.max(this._totalCount, this.entries.length);
   }
 
+  /**
+   * Get all unique shared strings in insertion order.
+   */
+  getAllStrings(): string[] {
+    return this.entries.map((entry) => entry.text);
+  }
+
   /**
    * Generate XML for the shared strings table
    */

package/src/types.ts

@@ -158,36 +158,48 @@ export interface PivotValueConfig {
 /**
  * Configuration for creating a pivot table
  */
-export interface PivotTableConfig {
-  /** Name of the pivot table */
-  name: string;
-  /** Source data range with sheet name (e.g., "Sheet1!A1:D100") */
-  source: string;
-  /** Target cell where pivot table will be placed (e.g., "Sheet2!A3") */
-  target: string;
-  /** Refresh the pivot table data when the file is opened (default: true) */
-  refreshOnLoad?: boolean;
-}
+export interface PivotTableConfig {
+  /** Name of the pivot table */
+  name: string;
+  /** Source data range with sheet name (e.g., "Sheet1!A1:D100") */
+  source: string;
+  /** Target cell where pivot table will be placed (e.g., "Sheet2!A3") */
+  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
  */
-export interface PivotCacheField {
-  /** Field name (from header row) */
-  name: string;
-  /** Field index (0-based) */
-  index: number;
-  /** Whether this field contains numbers */
-  isNumeric: boolean;
-  /** Whether this field contains dates */
-  isDate: boolean;
-  /** Unique string values (for shared items) */
-  sharedItems: string[];
-  /** Min numeric value */
-  minValue?: number;
-  /** Max numeric value */
-  maxValue?: number;
-}
+export interface PivotCacheField {
+  /** Field name (from header row) */
+  name: string;
+  /** Field index (0-based) */
+  index: number;
+  /** Whether this field contains numbers */
+  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

package/src/utils/xml.ts

@@ -125,13 +125,26 @@ export const createElement = (tagName: string, attrs?: Record<string, string>, c
   if (attrs && Object.keys(attrs).length > 0) {
     const attrObj: Record<string, string> = {};
     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: string): string => {
+  return value
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/&apos;/g, "'");
+};
+
+const shouldEscapeXmlAttr = (tagName: string, attrName: string): boolean => {
+  return tagName === 's' && attrName === 'v';
+};
+
 /**
  * Creates a text node
  */

package/src/utils/zip.ts

@@ -1,4 +1,4 @@
-import { unzip, zip, strFromU8, strToU8 } from 'fflate';
+import { unzip, unzipSync, zip, zipSync, strFromU8, strToU8 } from 'fflate';
 
 export type ZipFiles = Map<string, Uint8Array>;
 
@@ -8,6 +8,20 @@ export type ZipFiles = Map<string, Uint8Array>;
  * @returns Promise resolving to a map of file paths to contents
  */
 export const readZip = (data: Uint8Array): Promise<ZipFiles> => {
+  const isBun = typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined';
+  if (isBun) {
+    try {
+      const result = unzipSync(data);
+      const files = new Map<string, Uint8Array>();
+      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) => {
     unzip(data, (err, result) => {
       if (err) {
@@ -29,11 +43,21 @@ export const readZip = (data: Uint8Array): Promise<ZipFiles> => {
  * @returns Promise resolving to ZIP file as Uint8Array
  */
 export const writeZip = (files: ZipFiles): Promise<Uint8Array> => {
-  return new Promise((resolve, reject) => {
-    const zipData: Record<string, Uint8Array> = {};
-    for (const [path, content] of files) {
-      zipData[path] = content;
+  const zipData: Record<string, Uint8Array> = {};
+  for (const [path, content] of files) {
+    zipData[path] = content;
+  }
+
+  const isBun = typeof (globalThis as { Bun?: unknown }).Bun !== 'undefined';
+  if (isBun) {
+    try {
+      return Promise.resolve(zipSync(zipData));
+    } catch (error) {
+      return Promise.reject(error);
     }
+  }
+
+  return new Promise((resolve, reject) => {
     zip(zipData, (err, result) => {
       if (err) {
         reject(err);

package/src/workbook.ts

@@ -33,7 +33,7 @@ export class Workbook {
   // Pivot table support
   private _pivotTables: PivotTable[] = [];
   private _pivotCaches: PivotCache[] = [];
-  private _nextCacheId = 0;
+  private _nextCacheId = 5;
   private _nextCacheFileIndex = 1;
 
   // Table support
@@ -604,11 +604,16 @@ export class Workbook {
     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
@@ -670,6 +675,7 @@ export class Workbook {
     return { headers, data };
   }
 
+
   /**
    * Save the workbook to a file
    */