@niicojs/excel 0.3.4 → 0.3.5

package/src/workbook.ts

@@ -2,67 +2,70 @@ import { readFile, writeFile } from 'fs/promises';
 import type {
   SheetDefinition,
   Relationship,
-  PivotTableConfig,
   CellValue,
   SheetFromDataConfig,
   ColumnConfig,
   RichCellValue,
   DateHandling,
+  PivotTableConfig,
+  RangeAddress,
+  WorkbookReadOptions,
 } from './types';
 import { Worksheet } from './worksheet';
 import { SharedStrings } from './shared-strings';
 import { Styles } from './styles';
 import { PivotTable } from './pivot-table';
-import { PivotCache } from './pivot-cache';
-import { readZip, writeZip, readZipText, writeZipText, ZipFiles } from './utils/zip';
-import { parseAddress, parseRange, toAddress } from './utils/address';
+import { readZip, writeZip, readZipText, writeZipText, ZipStore, createZipStore } from './utils/zip';
+import { parseAddress, parseSheetAddress, parseSheetRange } from './utils/address';
 import { parseXml, findElement, getChildren, getAttr, XmlNode, stringifyXml, createElement } from './utils/xml';
 
 /**
  * Represents an Excel workbook (.xlsx file)
  */
 export class Workbook {
-  private _files: ZipFiles = new Map();
+  private _files: ZipStore = createZipStore();
   private _sheets: Map<string, Worksheet> = new Map();
   private _sheetDefs: SheetDefinition[] = [];
   private _relationships: Relationship[] = [];
-  private _sharedStrings: SharedStrings;
-  private _styles: Styles;
+  private _sharedStrings: SharedStrings | null = null;
+  private _styles: Styles | null = null;
+  private _sharedStringsXml: string | null = null;
+  private _stylesXml: string | null = null;
+  private _lazy = true;
   private _dirty = false;
 
-  // Pivot table support
-  private _pivotTables: PivotTable[] = [];
-  private _pivotCaches: PivotCache[] = [];
-  private _nextCacheId = 5;
-  private _nextCacheFileIndex = 1;
-
   // Table support
   private _nextTableId = 1;
 
+  // Pivot table support
+  private _pivotTables: PivotTable[] = [];
+  private _nextPivotTableId = 1;
+  private _nextPivotCacheId = 1;
+
   // Date serialization handling
   private _dateHandling: DateHandling = 'jsDate';
 
   private _locale = 'fr-FR';
 
   private constructor() {
-    this._sharedStrings = new SharedStrings();
-    this._styles = Styles.createDefault();
+    // Lazy init
   }
 
   /**
    * Load a workbook from a file path
    */
-  static async fromFile(path: string): Promise<Workbook> {
+  static async fromFile(path: string, options: WorkbookReadOptions = {}): Promise<Workbook> {
     const data = await readFile(path);
-    return Workbook.fromBuffer(new Uint8Array(data));
+    return Workbook.fromBuffer(new Uint8Array(data), options);
   }
 
   /**
    * Load a workbook from a buffer
    */
-  static async fromBuffer(data: Uint8Array): Promise<Workbook> {
+  static async fromBuffer(data: Uint8Array, options: WorkbookReadOptions = {}): Promise<Workbook> {
     const workbook = new Workbook();
-    workbook._files = await readZip(data);
+    workbook._lazy = options.lazy ?? true;
+    workbook._files = await readZip(data, { lazy: workbook._lazy });
 
     // Parse workbook.xml for sheet definitions
     const workbookXml = readZipText(workbook._files, 'xl/workbook.xml');
@@ -77,16 +80,9 @@ export class Workbook {
     }
 
     // Parse shared strings
-    const sharedStringsXml = readZipText(workbook._files, 'xl/sharedStrings.xml');
-    if (sharedStringsXml) {
-      workbook._sharedStrings = SharedStrings.parse(sharedStringsXml);
-    }
-
-    // Parse styles
-    const stylesXml = readZipText(workbook._files, 'xl/styles.xml');
-    if (stylesXml) {
-      workbook._styles = Styles.parse(stylesXml);
-    }
+    // Store shared strings/styles XML for lazy parse
+    workbook._sharedStringsXml = readZipText(workbook._files, 'xl/sharedStrings.xml') ?? null;
+    workbook._stylesXml = readZipText(workbook._files, 'xl/styles.xml') ?? null;
 
     return workbook;
   }
@@ -97,6 +93,9 @@ export class Workbook {
   static create(): Workbook {
     const workbook = new Workbook();
     workbook._dirty = true;
+    workbook._lazy = false;
+    workbook._sharedStrings = new SharedStrings();
+    workbook._styles = Styles.createDefault();
 
     return workbook;
   }
@@ -119,6 +118,13 @@ export class Workbook {
    * Get shared strings table
    */
   get sharedStrings(): SharedStrings {
+    if (!this._sharedStrings) {
+      if (this._sharedStringsXml) {
+        this._sharedStrings = SharedStrings.parse(this._sharedStringsXml);
+      } else {
+        this._sharedStrings = new SharedStrings();
+      }
+    }
     return this._sharedStrings;
   }
 
@@ -126,6 +132,13 @@ export class Workbook {
    * Get styles
    */
   get styles(): Styles {
+    if (!this._styles) {
+      if (this._stylesXml) {
+        this._styles = Styles.parse(this._stylesXml);
+      } else {
+        this._styles = Styles.createDefault();
+      }
+    }
     return this._styles;
   }
 
@@ -166,6 +179,102 @@ export class Workbook {
     return this._nextTableId++;
   }
 
+  /**
+   * Get all pivot tables in the workbook.
+   */
+  get pivotTables(): PivotTable[] {
+    return [...this._pivotTables];
+  }
+
+  /**
+   * Create a new pivot table.
+   */
+  createPivotTable(config: PivotTableConfig): PivotTable {
+    if (!config.name || config.name.trim().length === 0) {
+      throw new Error('Pivot table name is required');
+    }
+
+    if (this._pivotTables.some((pivot) => pivot.name === config.name)) {
+      throw new Error(`Pivot table name already exists: ${config.name}`);
+    }
+
+    const sourceRef = parseSheetRange(config.source);
+    const targetRef = parseSheetAddress(config.target);
+
+    const sourceSheet = this.sheet(sourceRef.sheet);
+    this.sheet(targetRef.sheet);
+
+    const sourceRange = this._normalizeRange(sourceRef.range);
+    if (sourceRange.start.row >= sourceRange.end.row) {
+      throw new Error('Pivot source range must include a header row and at least one data row');
+    }
+
+    const fields = this._extractPivotFields(sourceSheet, sourceRange);
+
+    const cacheId = this._nextPivotCacheId++;
+    const pivotId = this._nextPivotTableId++;
+    const cachePartIndex = this._pivotTables.length + 1;
+
+    const pivot = new PivotTable(
+      this,
+      config,
+      sourceRef.sheet,
+      sourceSheet,
+      sourceRange,
+      targetRef.sheet,
+      targetRef.address,
+      cacheId,
+      pivotId,
+      cachePartIndex,
+      fields,
+    );
+
+    this._pivotTables.push(pivot);
+    this._dirty = true;
+
+    return pivot;
+  }
+
+  private _extractPivotFields(
+    sourceSheet: Worksheet,
+    sourceRange: RangeAddress,
+  ): { name: string; sourceCol: number }[] {
+    const fields: { name: string; sourceCol: number }[] = [];
+    const seen = new Set<string>();
+
+    for (let col = sourceRange.start.col; col <= sourceRange.end.col; col++) {
+      const headerCell = sourceSheet.getCellIfExists(sourceRange.start.row, col);
+      const rawHeader = headerCell?.value;
+      const name = rawHeader == null ? `Column${col - sourceRange.start.col + 1}` : String(rawHeader).trim();
+
+      if (!name) {
+        throw new Error(`Pivot source header is empty at column ${col + 1}`);
+      }
+
+      if (seen.has(name)) {
+        throw new Error(`Duplicate pivot source header: ${name}`);
+      }
+
+      seen.add(name);
+      fields.push({ name, sourceCol: col });
+    }
+
+    return fields;
+  }
+
+  private _normalizeRange(range: RangeAddress): RangeAddress {
+    return {
+      start: {
+        row: Math.min(range.start.row, range.end.row),
+        col: Math.min(range.start.col, range.end.col),
+      },
+      end: {
+        row: Math.max(range.start.row, range.end.row),
+        col: Math.max(range.start.col, range.end.col),
+      },
+    };
+  }
+
   /**
    * Get a worksheet by name or index
    */
@@ -196,7 +305,7 @@ export class Workbook {
       const sheetPath = `xl/${rel.target}`;
       const sheetXml = readZipText(this._files, sheetPath);
       if (sheetXml) {
-        worksheet.parse(sheetXml);
+        worksheet.parse(sheetXml, { lazy: this._lazy });
       }
     }
 
@@ -559,123 +668,6 @@ export class Workbook {
     return String(value);
   }
 
-  /**
-   * Create a pivot table from source data.
-   *
-   * @param config - Pivot table configuration
-   * @returns PivotTable instance for fluent configuration
-   *
-   * @example
-   * ```typescript
-   * const pivot = wb.createPivotTable({
-   *   name: 'SalesPivot',
-   *   source: 'DataSheet!A1:D100',
-   *   target: 'PivotSheet!A3',
-   * });
-   *
-   * pivot
-   *   .addRowField('Region')
-   *   .addColumnField('Product')
-   *   .addValueField('Sales', 'sum', 'Total Sales');
-   * ```
-   */
-  createPivotTable(config: PivotTableConfig): PivotTable {
-    this._dirty = true;
-
-    // Parse source reference (Sheet!Range)
-    const { sheetName: sourceSheet, range: sourceRange } = this._parseSheetRef(config.source);
-
-    // Parse target reference
-    const { sheetName: targetSheet, range: targetCell } = this._parseSheetRef(config.target);
-
-    // Ensure target sheet exists
-    if (!this._sheetDefs.some((s) => s.name === targetSheet)) {
-      this.addSheet(targetSheet);
-    }
-
-    // Parse target cell address
-    const targetAddr = parseAddress(targetCell);
-
-    // Get source worksheet and extract data
-    const sourceWs = this.sheet(sourceSheet);
-    const { headers, data } = this._extractSourceData(sourceWs, sourceRange);
-
-    // Create pivot cache
-    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;
-    const pivotTable = new PivotTable(
-      config.name,
-      cache,
-      targetSheet,
-      targetCell,
-      targetAddr.row + 1, // Convert to 1-based
-      targetAddr.col,
-      pivotTableIndex,
-      cacheFileIndex,
-    );
-
-    // Set styles reference for number format resolution
-    pivotTable.setStyles(this._styles);
-
-    this._pivotTables.push(pivotTable);
-
-    return pivotTable;
-  }
-
-  /**
-   * Parse a sheet reference like "Sheet1!A1:D100" into sheet name and range
-   */
-  private _parseSheetRef(ref: string): { sheetName: string; range: string } {
-    const match = ref.match(/^(.+?)!(.+)$/);
-    if (!match) {
-      throw new Error(`Invalid reference format: ${ref}. Expected "SheetName!Range"`);
-    }
-    return { sheetName: match[1], range: match[2] };
-  }
-
-  /**
-   * Extract headers and data from a source range
-   */
-  private _extractSourceData(sheet: Worksheet, rangeStr: string): { headers: string[]; data: CellValue[][] } {
-    const range = parseRange(rangeStr);
-    const headers: string[] = [];
-    const data: CellValue[][] = [];
-
-    // First row is headers
-    for (let col = range.start.col; col <= range.end.col; col++) {
-      const cell = sheet.cell(toAddress(range.start.row, col));
-      headers.push(String(cell.value ?? `Column${col + 1}`));
-    }
-
-    // Remaining rows are data
-    for (let row = range.start.row + 1; row <= range.end.row; row++) {
-      const rowData: CellValue[] = [];
-      for (let col = range.start.col; col <= range.end.col; col++) {
-        const cell = sheet.cell(toAddress(row, col));
-        rowData.push(cell.value);
-      }
-      data.push(rowData);
-    }
-
-    return { headers, data };
-  }
-
-
   /**
    * Save the workbook to a file
    */
@@ -743,7 +735,7 @@ export class Workbook {
     const relationshipInfo = this._buildRelationshipInfo();
 
     // Update workbook.xml
-    this._updateWorkbookXml(relationshipInfo.pivotCacheRelIds);
+    this._updateWorkbookXml(relationshipInfo.pivotCacheRelByTarget);
 
     // Update relationships
     this._updateRelationshipsXml(relationshipInfo.relNodes);
@@ -752,16 +744,24 @@ export class Workbook {
     this._updateContentTypes();
 
     // Update shared strings if modified
-    if (this._sharedStrings.dirty || this._sharedStrings.count > 0) {
-      writeZipText(this._files, 'xl/sharedStrings.xml', this._sharedStrings.toXml());
+    if (this._sharedStrings) {
+      if (this._sharedStrings.dirty || this._sharedStrings.count > 0) {
+        writeZipText(this._files, 'xl/sharedStrings.xml', this._sharedStrings.toXml());
+      }
+    } else if (this._sharedStringsXml) {
+      writeZipText(this._files, 'xl/sharedStrings.xml', this._sharedStringsXml);
     }
 
     // Update styles if modified or if file doesn't exist yet
-    if (this._styles.dirty || this._dirty || !this._files.has('xl/styles.xml')) {
-      writeZipText(this._files, 'xl/styles.xml', this._styles.toXml());
+    if (this._styles) {
+      if (this._styles.dirty || this._dirty || !this._files.has('xl/styles.xml')) {
+        writeZipText(this._files, 'xl/styles.xml', this._styles.toXml());
+      }
+    } else if (this._stylesXml) {
+      writeZipText(this._files, 'xl/styles.xml', this._stylesXml);
     }
 
-    // Update worksheets (needed for pivot table targets)
+    // Update worksheets
     for (const [name, worksheet] of this._sheets) {
       if (worksheet.dirty || this._dirty || worksheet.tables.length > 0) {
         const def = this._sheetDefs.find((s) => s.name === name);
@@ -775,17 +775,15 @@ export class Workbook {
       }
     }
 
-    // Update pivot tables
-    if (this._pivotTables.length > 0) {
-      this._updatePivotTableFiles();
-    }
-
     // Update tables (sets table rel IDs for tableParts)
     this._updateTableFiles();
 
+    // Update pivot tables (sets pivot rel IDs for pivotTableParts)
+    this._updatePivotFiles();
+
     // Update worksheets to align tableParts with relationship IDs
     for (const [name, worksheet] of this._sheets) {
-      if (worksheet.dirty || this._dirty || worksheet.tables.length > 0) {
+      if (worksheet.dirty || this._dirty || worksheet.tables.length > 0 || this._pivotTables.length > 0) {
         const def = this._sheetDefs.find((s) => s.name === name);
         if (def) {
           const rel = this._relationships.find((r) => r.id === def.rId);
@@ -798,7 +796,7 @@ export class Workbook {
     }
   }
 
-  private _updateWorkbookXml(pivotCacheRelIds: Map<number, string>): void {
+  private _updateWorkbookXml(pivotCacheRelByTarget: Map<string, string>): void {
     const sheetNodes: XmlNode[] = this._sheetDefs.map((def) =>
       createElement('sheet', { name: def.name, sheetId: String(def.sheetId), 'r:id': def.rId }, []),
     );
@@ -807,16 +805,18 @@ export class Workbook {
 
     const children: XmlNode[] = [sheetsNode];
 
-    // Add pivot caches if any
-    if (this._pivotCaches.length > 0) {
-      const pivotCacheNodes: XmlNode[] = this._pivotCaches.map((cache) => {
-        const cacheRelId = pivotCacheRelIds.get(cache.cacheId);
-        if (!cacheRelId) {
-          throw new Error(`Missing pivot cache relationship ID for cache ${cache.cacheId}`);
-        }
-        return createElement('pivotCache', { cacheId: String(cache.cacheId), 'r:id': cacheRelId }, []);
-      });
-      children.push(createElement('pivotCaches', {}, pivotCacheNodes));
+    if (this._pivotTables.length > 0) {
+      const pivotCacheNodes: XmlNode[] = [];
+      for (const pivot of this._pivotTables) {
+        const target = `pivotCache/pivotCacheDefinition${pivot.cachePartIndex}.xml`;
+        const relId = pivotCacheRelByTarget.get(target);
+        if (!relId) continue;
+        pivotCacheNodes.push(createElement('pivotCache', { cacheId: String(pivot.cacheId), 'r:id': relId }, []));
+      }
+
+      if (pivotCacheNodes.length > 0) {
+        children.push(createElement('pivotCaches', {}, pivotCacheNodes));
+      }
     }
 
     const workbookNode = createElement(
@@ -843,10 +843,11 @@ export class Workbook {
     writeZipText(this._files, 'xl/_rels/workbook.xml.rels', xml);
   }
 
-  private _buildRelationshipInfo(): { relNodes: XmlNode[]; pivotCacheRelIds: Map<number, string> } {
+  private _buildRelationshipInfo(): { relNodes: XmlNode[]; pivotCacheRelByTarget: Map<string, string> } {
     const relNodes: XmlNode[] = this._relationships.map((rel) =>
       createElement('Relationship', { Id: rel.id, Type: rel.type, Target: rel.target }, []),
     );
+    const pivotCacheRelByTarget = new Map<string, string>();
 
     const reservedRelIds = new Set<string>(relNodes.map((node) => getAttr(node, 'Id') || '').filter(Boolean));
     let nextRelId = Math.max(0, ...this._relationships.map((r) => parseInt(r.id.replace('rId', ''), 10) || 0)) + 1;
@@ -862,7 +863,8 @@ export class Workbook {
     };
 
     // Add shared strings relationship if needed
-    if (this._sharedStrings.count > 0) {
+    const shouldIncludeSharedStrings = (this._sharedStrings?.count ?? 0) > 0 || this._sharedStringsXml !== null;
+    if (shouldIncludeSharedStrings) {
       const hasSharedStrings = this._relationships.some(
         (r) => r.type === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings',
       );
@@ -899,28 +901,48 @@ export class Workbook {
       );
     }
 
-    // Add pivot cache relationships
-    const pivotCacheRelIds = new Map<number, string>();
-    for (const cache of this._pivotCaches) {
-      const id = allocateRelId();
-      pivotCacheRelIds.set(cache.cacheId, id);
-      relNodes.push(
-        createElement(
-          'Relationship',
-          {
-            Id: id,
-            Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition',
-            Target: `pivotCache/pivotCacheDefinition${cache.fileIndex}.xml`,
-          },
-          [],
-        ),
+    for (const pivot of this._pivotTables) {
+      const target = `pivotCache/pivotCacheDefinition${pivot.cachePartIndex}.xml`;
+      const hasPivotCacheRel = relNodes.some(
+        (node) =>
+          getAttr(node, 'Type') ===
+            'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition' &&
+          getAttr(node, 'Target') === target,
       );
+
+      if (!hasPivotCacheRel) {
+        const id = allocateRelId();
+        pivotCacheRelByTarget.set(target, id);
+        relNodes.push(
+          createElement(
+            'Relationship',
+            {
+              Id: id,
+              Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition',
+              Target: target,
+            },
+            [],
+          ),
+        );
+      } else {
+        const existing = relNodes.find(
+          (node) =>
+            getAttr(node, 'Type') ===
+              'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition' &&
+            getAttr(node, 'Target') === target,
+        );
+        const existingId = existing ? getAttr(existing, 'Id') : undefined;
+        if (existingId) {
+          pivotCacheRelByTarget.set(target, existingId);
+        }
+      }
     }
 
-    return { relNodes, pivotCacheRelIds };
+    return { relNodes, pivotCacheRelByTarget };
   }
 
   private _updateContentTypes(): void {
+    const shouldIncludeSharedStrings = (this._sharedStrings?.count ?? 0) > 0 || this._sharedStringsXml !== null;
     const types: XmlNode[] = [
       createElement(
         'Default',
@@ -947,7 +969,7 @@ export class Workbook {
     ];
 
     // Add shared strings if present
-    if (this._sharedStrings.count > 0) {
+    if (shouldIncludeSharedStrings) {
       types.push(
         createElement(
           'Override',
@@ -977,37 +999,56 @@ export class Workbook {
       }
     }
 
-    // Add pivot cache definitions and records
-    for (const cache of this._pivotCaches) {
+    // Add tables
+    let tableIndex = 1;
+    for (const def of this._sheetDefs) {
+      const worksheet = this._sheets.get(def.name);
+      if (worksheet) {
+        for (let i = 0; i < worksheet.tables.length; i++) {
+          types.push(
+            createElement(
+              'Override',
+              {
+                PartName: `/xl/tables/table${tableIndex}.xml`,
+                ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml',
+              },
+              [],
+            ),
+          );
+          tableIndex++;
+        }
+      }
+    }
+
+    // Add pivot caches and pivot tables
+    for (const pivot of this._pivotTables) {
       types.push(
         createElement(
           'Override',
           {
-            PartName: `/xl/pivotCache/pivotCacheDefinition${cache.fileIndex}.xml`,
+            PartName: `/xl/pivotCache/pivotCacheDefinition${pivot.cachePartIndex}.xml`,
             ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml',
           },
           [],
         ),
       );
+
       types.push(
         createElement(
           'Override',
           {
-            PartName: `/xl/pivotCache/pivotCacheRecords${cache.fileIndex}.xml`,
+            PartName: `/xl/pivotCache/pivotCacheRecords${pivot.cachePartIndex}.xml`,
             ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml',
           },
           [],
         ),
       );
-    }
 
-    // Add pivot tables
-    for (const pivotTable of this._pivotTables) {
       types.push(
         createElement(
           'Override',
           {
-            PartName: `/xl/pivotTables/pivotTable${pivotTable.index}.xml`,
+            PartName: `/xl/pivotTables/pivotTable${pivot.pivotId}.xml`,
             ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml',
           },
           [],
@@ -1015,27 +1056,6 @@ export class Workbook {
       );
     }
 
-    // Add tables
-    let tableIndex = 1;
-    for (const def of this._sheetDefs) {
-      const worksheet = this._sheets.get(def.name);
-      if (worksheet) {
-        for (let i = 0; i < worksheet.tables.length; i++) {
-          types.push(
-            createElement(
-              'Override',
-              {
-                PartName: `/xl/tables/table${tableIndex}.xml`,
-                ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml',
-              },
-              [],
-            ),
-          );
-          tableIndex++;
-        }
-      }
-    }
-
     const existingTypesXml = readZipText(this._files, '[Content_Types].xml');
     const existingKeys = new Set(
       types
@@ -1110,92 +1130,38 @@ export class Workbook {
   }
 
   /**
-   * Generate all pivot table related files
+   * Generate all table related files
    */
-  private _updatePivotTableFiles(): void {
-    // Track which sheets have pivot tables for their .rels files
-    const sheetPivotTables: Map<string, PivotTable[]> = new Map();
-
-    for (const pivotTable of this._pivotTables) {
-      const sheetName = pivotTable.targetSheet;
-      if (!sheetPivotTables.has(sheetName)) {
-        sheetPivotTables.set(sheetName, []);
-      }
-      sheetPivotTables.get(sheetName)!.push(pivotTable);
-    }
-
-    // Generate pivot cache files
-    for (let i = 0; i < this._pivotCaches.length; i++) {
-      const cache = this._pivotCaches[i];
+  private _updateTableFiles(): void {
+    // Collect all tables with their global indices
+    let globalTableIndex = 1;
+    const sheetTables: Map<string, { table: import('./table').Table; globalIndex: number }[]> = new Map();
 
-      // Pivot cache definition
-      const definitionPath = `xl/pivotCache/pivotCacheDefinition${cache.fileIndex}.xml`;
-      writeZipText(this._files, definitionPath, cache.toDefinitionXml('rId1'));
+    for (const def of this._sheetDefs) {
+      const worksheet = this._sheets.get(def.name);
+      if (!worksheet) continue;
 
-      // Pivot cache records
-      const recordsPath = `xl/pivotCache/pivotCacheRecords${cache.fileIndex}.xml`;
-      writeZipText(this._files, recordsPath, cache.toRecordsXml());
+      const tables = worksheet.tables;
+      if (tables.length === 0) continue;
 
-      // Pivot cache definition relationships (link to records)
-      const cacheRelsPath = `xl/pivotCache/_rels/pivotCacheDefinition${cache.fileIndex}.xml.rels`;
-      const cacheRels = createElement(
-        'Relationships',
-        { xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships' },
-        [
-          createElement(
-            'Relationship',
-            {
-              Id: 'rId1',
-              Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheRecords',
-              Target: `pivotCacheRecords${cache.fileIndex}.xml`,
-            },
-            [],
-          ),
-        ],
-      );
-      writeZipText(
-        this._files,
-        cacheRelsPath,
-        `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([cacheRels])}`,
-      );
+      const tableInfos: { table: import('./table').Table; globalIndex: number }[] = [];
+      for (const table of tables) {
+        tableInfos.push({ table, globalIndex: globalTableIndex });
+        globalTableIndex++;
+      }
+      sheetTables.set(def.name, tableInfos);
     }
 
-    // Generate pivot table files
-    for (let i = 0; i < this._pivotTables.length; i++) {
-      const pivotTable = this._pivotTables[i];
-      const ptIdx = pivotTable.index;
-
-      // Pivot table definition
-      const ptPath = `xl/pivotTables/pivotTable${ptIdx}.xml`;
-      writeZipText(this._files, ptPath, pivotTable.toXml());
-
-      // Pivot table relationships (link to cache definition)
-      const cacheIdx = pivotTable.cacheFileIndex;
-      const ptRelsPath = `xl/pivotTables/_rels/pivotTable${ptIdx}.xml.rels`;
-      const ptRels = createElement(
-        'Relationships',
-        { xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships' },
-        [
-          createElement(
-            'Relationship',
-            {
-              Id: 'rId1',
-              Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition',
-              Target: `../pivotCache/pivotCacheDefinition${cacheIdx}.xml`,
-            },
-            [],
-          ),
-        ],
-      );
-      writeZipText(
-        this._files,
-        ptRelsPath,
-        `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([ptRels])}`,
-      );
+    // Generate table files
+    for (const [, tableInfos] of sheetTables) {
+      for (const { table, globalIndex } of tableInfos) {
+        const tablePath = `xl/tables/table${globalIndex}.xml`;
+        writeZipText(this._files, tablePath, table.toXml());
+      }
     }
 
-    // Generate worksheet relationships for pivot tables
-    for (const [sheetName, pivotTables] of sheetPivotTables) {
+    // Generate worksheet relationships for tables
+    for (const [sheetName, tableInfos] of sheetTables) {
       const def = this._sheetDefs.find((s) => s.name === sheetName);
       if (!def) continue;
 
@@ -1206,12 +1172,14 @@ export class Workbook {
       const sheetFileName = rel.target.split('/').pop();
       const sheetRelsPath = `xl/worksheets/_rels/${sheetFileName}.rels`;
 
+      // Check if there are already pivot table relationships for this sheet
       const existingRelsXml = readZipText(this._files, sheetRelsPath);
-      let relNodes: XmlNode[] = [];
       let nextRelId = 1;
+      const relNodes: XmlNode[] = [];
       const reservedRelIds = new Set<string>();
 
       if (existingRelsXml) {
+        // Parse existing rels and find max rId
         const parsed = parseXml(existingRelsXml);
         const relsElement = findElement(parsed, 'Relationships');
         if (relsElement) {
@@ -1242,21 +1210,33 @@ export class Workbook {
         return id;
       };
 
-      for (const pt of pivotTables) {
-        const target = `../pivotTables/pivotTable${pt.index}.xml`;
+      // Add table relationships
+      const tableRelIds: string[] = [];
+      for (const { globalIndex } of tableInfos) {
+        const target = `../tables/table${globalIndex}.xml`;
         const existing = relNodes.some(
           (node) =>
-            getAttr(node, 'Type') ===
-              'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable' &&
+            getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table' &&
             getAttr(node, 'Target') === target,
         );
-        if (existing) continue;
+        if (existing) {
+          const existingRel = relNodes.find(
+            (node) =>
+              getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table' &&
+              getAttr(node, 'Target') === target,
+          );
+          const existingId = existingRel ? getAttr(existingRel, 'Id') : undefined;
+          tableRelIds.push(existingId ?? allocateRelId());
+          continue;
+        }
+        const id = allocateRelId();
+        tableRelIds.push(id);
         relNodes.push(
           createElement(
             'Relationship',
             {
-              Id: allocateRelId(),
-              Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable',
+              Id: id,
+              Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table',
               Target: target,
             },
             [],
@@ -1264,6 +1244,11 @@ export class Workbook {
         );
       }
 
+      const worksheet = this._sheets.get(sheetName);
+      if (worksheet) {
+        worksheet.setTableRelIds(tableRelIds);
+      }
+
       const sheetRels = createElement(
         'Relationships',
         { xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships' },
@@ -1278,61 +1263,58 @@ export class Workbook {
   }
 
   /**
-   * Generate all table related files
+   * Generate pivot cache/table parts and worksheet relationships.
    */
-  private _updateTableFiles(): void {
-    // Collect all tables with their global indices
-    let globalTableIndex = 1;
-    const sheetTables: Map<string, { table: import('./table').Table; globalIndex: number }[]> = new Map();
+  private _updatePivotFiles(): void {
+    if (this._pivotTables.length === 0) {
+      return;
+    }
 
-    for (const def of this._sheetDefs) {
-      const worksheet = this._sheets.get(def.name);
-      if (!worksheet) continue;
+    for (const pivot of this._pivotTables) {
+      const pivotParts = pivot.buildPivotPartsXml();
 
-      const tables = worksheet.tables;
-      if (tables.length === 0) continue;
+      const pivotCachePath = `xl/pivotCache/pivotCacheDefinition${pivot.cachePartIndex}.xml`;
+      writeZipText(this._files, pivotCachePath, pivotParts.cacheDefinitionXml);
 
-      const tableInfos: { table: import('./table').Table; globalIndex: number }[] = [];
-      for (const table of tables) {
-        tableInfos.push({ table, globalIndex: globalTableIndex });
-        globalTableIndex++;
-      }
-      sheetTables.set(def.name, tableInfos);
+      const pivotCacheRecordsPath = `xl/pivotCache/pivotCacheRecords${pivot.cachePartIndex}.xml`;
+      writeZipText(this._files, pivotCacheRecordsPath, pivotParts.cacheRecordsXml);
+
+      const pivotCacheRelsPath = `xl/pivotCache/_rels/pivotCacheDefinition${pivot.cachePartIndex}.xml.rels`;
+      writeZipText(this._files, pivotCacheRelsPath, pivotParts.cacheRelsXml);
+
+      const pivotTablePath = `xl/pivotTables/pivotTable${pivot.pivotId}.xml`;
+      writeZipText(this._files, pivotTablePath, pivotParts.pivotTableXml);
     }
 
-    // Generate table files
-    for (const [, tableInfos] of sheetTables) {
-      for (const { table, globalIndex } of tableInfos) {
-        const tablePath = `xl/tables/table${globalIndex}.xml`;
-        writeZipText(this._files, tablePath, table.toXml());
-      }
+    const pivotsBySheet = new Map<string, PivotTable[]>();
+    for (const pivot of this._pivotTables) {
+      const existing = pivotsBySheet.get(pivot.targetSheetName) ?? [];
+      existing.push(pivot);
+      pivotsBySheet.set(pivot.targetSheetName, existing);
     }
 
-    // Generate worksheet relationships for tables
-    for (const [sheetName, tableInfos] of sheetTables) {
+    for (const [sheetName, pivots] of pivotsBySheet) {
       const def = this._sheetDefs.find((s) => s.name === sheetName);
       if (!def) continue;
 
       const rel = this._relationships.find((r) => r.id === def.rId);
       if (!rel) continue;
 
-      // Extract sheet file name from target path
       const sheetFileName = rel.target.split('/').pop();
-      const sheetRelsPath = `xl/worksheets/_rels/${sheetFileName}.rels`;
+      if (!sheetFileName) continue;
 
-      // Check if there are already pivot table relationships for this sheet
+      const sheetRelsPath = `xl/worksheets/_rels/${sheetFileName}.rels`;
       const existingRelsXml = readZipText(this._files, sheetRelsPath);
+
       let nextRelId = 1;
       const relNodes: XmlNode[] = [];
       const reservedRelIds = new Set<string>();
 
       if (existingRelsXml) {
-        // Parse existing rels and find max rId
         const parsed = parseXml(existingRelsXml);
         const relsElement = findElement(parsed, 'Relationships');
         if (relsElement) {
-          const existingRelNodes = getChildren(relsElement, 'Relationships');
-          for (const relNode of existingRelNodes) {
+          for (const relNode of getChildren(relsElement, 'Relationships')) {
             if ('Relationship' in relNode) {
               relNodes.push(relNode);
               const id = getAttr(relNode, 'Id');
@@ -1358,33 +1340,30 @@ export class Workbook {
         return id;
       };
 
-      // Add table relationships
-      const tableRelIds: string[] = [];
-      for (const { globalIndex } of tableInfos) {
-        const target = `../tables/table${globalIndex}.xml`;
-        const existing = relNodes.some(
+      const pivotRelIds: string[] = [];
+      for (const pivot of pivots) {
+        const target = `../pivotTables/pivotTable${pivot.pivotId}.xml`;
+        const existing = relNodes.find(
           (node) =>
-            getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table' &&
+            getAttr(node, 'Type') ===
+              'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable' &&
             getAttr(node, 'Target') === target,
         );
+
         if (existing) {
-          const existingRel = relNodes.find(
-            (node) =>
-              getAttr(node, 'Type') === 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table' &&
-              getAttr(node, 'Target') === target,
-          );
-          const existingId = existingRel ? getAttr(existingRel, 'Id') : undefined;
-          tableRelIds.push(existingId ?? allocateRelId());
+          const existingId = getAttr(existing, 'Id');
+          pivotRelIds.push(existingId ?? allocateRelId());
           continue;
         }
+
         const id = allocateRelId();
-        tableRelIds.push(id);
+        pivotRelIds.push(id);
         relNodes.push(
           createElement(
             'Relationship',
             {
               Id: id,
-              Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/table',
+              Type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable',
               Target: target,
             },
             [],
@@ -1394,7 +1373,7 @@ export class Workbook {
 
       const worksheet = this._sheets.get(sheetName);
       if (worksheet) {
-        worksheet.setTableRelIds(tableRelIds);
+        worksheet.setPivotTableRelIds(pivotRelIds);
       }
 
       const sheetRels = createElement(
@@ -1402,6 +1381,7 @@ export class Workbook {
         { xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships' },
         relNodes,
       );
+
       writeZipText(
         this._files,
         sheetRelsPath,