@niicojs/excel 0.3.4 → 0.3.6

package/src/pivot-table.ts

@@ -1,396 +1,480 @@
-import type { AggregationType, PivotFieldAxis, PivotFieldFilter, PivotSortOrder, PivotValueConfig } from './types';
-import type { Styles } from './styles';
-import { PivotCache } from './pivot-cache';
+import type {
+  PivotAggregationType,
+  PivotFieldFilter,
+  PivotSortOrder,
+  PivotTableConfig,
+  PivotValueConfig,
+  RangeAddress,
+  CellValue,
+} from './types';
+import type { Workbook } from './workbook';
+import type { Worksheet } from './worksheet';
 import { createElement, stringifyXml, XmlNode } from './utils/xml';
+import { toAddress, toRange } from './utils/address';
+
+const AGGREGATION_TO_XML: Record<PivotAggregationType, string> = {
+  sum: 'sum',
+  count: 'count',
+  average: 'average',
+  min: 'min',
+  max: 'max',
+};
+
+const SORT_TO_XML: Record<PivotSortOrder, 'ascending' | 'descending'> = {
+  asc: 'ascending',
+  desc: 'descending',
+};
+
+interface PivotValueField {
+  field: string;
+  aggregation: PivotAggregationType;
+  name: string;
+  numberFormat?: string;
+}
 
-/**
- * Internal structure for tracking field assignments
- */
-interface FieldAssignment {
-  fieldName: string;
-  fieldIndex: number;
-  axis: PivotFieldAxis;
-  aggregation?: AggregationType;
-  displayName?: string;
-  numFmtId?: number;
-  sortOrder?: PivotSortOrder;
-  filter?: PivotFieldFilter;
+interface PivotFieldMeta {
+  name: string;
+  sourceCol: number;
+}
+
+interface PivotNumericInfo {
+  nonNullCount: number;
+  numericCount: number;
+  min: number;
+  max: number;
+  hasNumeric: boolean;
+  allIntegers: boolean;
+}
+
+interface PivotCacheData {
+  rowCount: number;
+  recordNodes: XmlNode[];
+  sharedItemIndexByField: Array<Map<string, number> | null>;
+  sharedItemsByField: Array<XmlNode[] | null>;
+  distinctItemsByField: Array<Exclude<CellValue, null>[] | null>;
+  numericInfoByField: PivotNumericInfo[];
+  isAxisFieldByIndex: boolean[];
+  isValueFieldByIndex: boolean[];
 }
 
 /**
- * Represents an Excel pivot table with a fluent API for configuration.
+ * Represents an Excel PivotTable with a fluent configuration API.
  */
 export class PivotTable {
+  private _workbook: Workbook;
   private _name: string;
-  private _cache: PivotCache;
-  private _targetSheet: string;
-  private _targetCell: string;
-  private _targetRow: number;
-  private _targetCol: number;
-
-  private _rowFields: FieldAssignment[] = [];
-  private _columnFields: FieldAssignment[] = [];
-  private _valueFields: FieldAssignment[] = [];
-  private _filterFields: FieldAssignment[] = [];
-  private _fieldAssignments: Map<number, FieldAssignment> = new Map();
-
-  private _pivotTableIndex: number;
-  private _cacheFileIndex: number;
-  private _styles: Styles | null = null;
+  private _sourceSheetName: string;
+  private _sourceSheet: Worksheet;
+  private _sourceRange: RangeAddress;
+  private _targetSheetName: string;
+  private _targetCell: { row: number; col: number };
+  private _refreshOnLoad: boolean;
+  private _cacheId: number;
+  private _pivotId: number;
+  private _cachePartIndex: number;
+  private _fields: PivotFieldMeta[];
+
+  private _rowFields: string[] = [];
+  private _columnFields: string[] = [];
+  private _filterFields: string[] = [];
+  private _valueFields: PivotValueField[] = [];
+  private _sortOrders: Map<string, PivotSortOrder> = new Map();
+  private _filters: Map<string, PivotFieldFilter> = new Map();
 
   constructor(
-    name: string,
-    cache: PivotCache,
-    targetSheet: string,
-    targetCell: string,
-    targetRow: number,
-    targetCol: number,
-    pivotTableIndex: number,
-    cacheFileIndex: number,
+    workbook: Workbook,
+    config: PivotTableConfig,
+    sourceSheetName: string,
+    sourceSheet: Worksheet,
+    sourceRange: RangeAddress,
+    targetSheetName: string,
+    targetCell: { row: number; col: number },
+    cacheId: number,
+    pivotId: number,
+    cachePartIndex: number,
+    fields: PivotFieldMeta[],
   ) {
-    this._name = name;
-    this._cache = cache;
-    this._targetSheet = targetSheet;
+    this._workbook = workbook;
+    this._name = config.name;
+    this._sourceSheetName = sourceSheetName;
+    this._sourceSheet = sourceSheet;
+    this._sourceRange = sourceRange;
+    this._targetSheetName = targetSheetName;
     this._targetCell = targetCell;
-    this._targetRow = targetRow;
-    this._targetCol = targetCol;
-    this._pivotTableIndex = pivotTableIndex;
-    this._cacheFileIndex = cacheFileIndex;
+    this._refreshOnLoad = config.refreshOnLoad !== false;
+    this._cacheId = cacheId;
+    this._pivotId = pivotId;
+    this._cachePartIndex = cachePartIndex;
+    this._fields = fields;
   }
 
-  /**
-   * Get the pivot table name
-   */
   get name(): string {
     return this._name;
   }
 
-  /**
-   * Get the target sheet name
-   */
-  get targetSheet(): string {
-    return this._targetSheet;
+  get sourceSheetName(): string {
+    return this._sourceSheetName;
   }
 
-  /**
-   * Get the target cell address
-   */
-  get targetCell(): string {
-    return this._targetCell;
+  get sourceRange(): RangeAddress {
+    return { start: { ...this._sourceRange.start }, end: { ...this._sourceRange.end } };
   }
 
-  /**
-   * Get the pivot cache
-   */
-  get cache(): PivotCache {
-    return this._cache;
+  get targetSheetName(): string {
+    return this._targetSheetName;
   }
 
-  /**
-   * Get the pivot table index (for file naming)
-   */
-  get index(): number {
-    return this._pivotTableIndex;
+  get targetCell(): { row: number; col: number } {
+    return { ...this._targetCell };
   }
 
-  /**
-   * Get the pivot cache file index used for rels.
-   * @internal
-   */
-  get cacheFileIndex(): number {
-    return this._cacheFileIndex;
+  get refreshOnLoad(): boolean {
+    return this._refreshOnLoad;
   }
 
-  /**
-   * Set the styles reference for number format resolution
-   * @internal
-   */
-  setStyles(styles: Styles): this {
-    this._styles = styles;
-    return this;
+  get cacheId(): number {
+    return this._cacheId;
   }
 
-  /**
-   * Add a field to the row area
-   * @param fieldName - Name of the source field (column header)
-   */
-  addRowField(fieldName: string): this {
-    const fieldIndex = this._cache.getFieldIndex(fieldName);
-    if (fieldIndex < 0) {
-      throw new Error(`Field not found in source data: ${fieldName}`);
-    }
+  get pivotId(): number {
+    return this._pivotId;
+  }
 
-    const assignment: FieldAssignment = {
-      fieldName,
-      fieldIndex,
-      axis: 'row',
-    };
-    this._rowFields.push(assignment);
-    this._fieldAssignments.set(fieldIndex, assignment);
+  get cachePartIndex(): number {
+    return this._cachePartIndex;
+  }
 
+  addRowField(fieldName: string): this {
+    this._assertFieldExists(fieldName);
+    if (!this._rowFields.includes(fieldName)) {
+      this._rowFields.push(fieldName);
+    }
     return this;
   }
 
-  /**
-   * Add a field to the column area
-   * @param fieldName - Name of the source field (column header)
-   */
   addColumnField(fieldName: string): this {
-    const fieldIndex = this._cache.getFieldIndex(fieldName);
-    if (fieldIndex < 0) {
-      throw new Error(`Field not found in source data: ${fieldName}`);
+    this._assertFieldExists(fieldName);
+    if (!this._columnFields.includes(fieldName)) {
+      this._columnFields.push(fieldName);
     }
+    return this;
+  }
 
-    const assignment: FieldAssignment = {
-      fieldName,
-      fieldIndex,
-      axis: 'column',
-    };
-    this._columnFields.push(assignment);
-    this._fieldAssignments.set(fieldIndex, assignment);
-
+  addFilterField(fieldName: string): this {
+    this._assertFieldExists(fieldName);
+    if (!this._filterFields.includes(fieldName)) {
+      this._filterFields.push(fieldName);
+    }
     return this;
   }
 
-  /**
-   * Add a field to the values area with aggregation.
-   *
-   * Supports two call signatures:
-   * - Positional: `addValueField(fieldName, aggregation?, displayName?, numberFormat?)`
-   * - Object: `addValueField({ field, aggregation?, name?, numberFormat? })`
-   *
-   * @example
-   * // Positional arguments
-   * pivot.addValueField('Sales', 'sum', 'Total Sales', '$#,##0.00');
-   *
-   * // Object form
-   * pivot.addValueField({ field: 'Sales', aggregation: 'sum', name: 'Total Sales', numberFormat: '$#,##0.00' });
-   */
+  addValueField(
+    fieldName: string,
+    aggregation?: PivotAggregationType,
+    displayName?: string,
+    numberFormat?: string,
+  ): this;
   addValueField(config: PivotValueConfig): this;
-  addValueField(fieldName: string, aggregation?: AggregationType, displayName?: string, numberFormat?: string): this;
   addValueField(
     fieldNameOrConfig: string | PivotValueConfig,
-    aggregation: AggregationType = 'sum',
+    aggregation: PivotAggregationType = 'sum',
     displayName?: string,
     numberFormat?: string,
   ): this {
-    // Normalize arguments to a common form
-    let fieldName: string;
-    let agg: AggregationType;
-    let name: string | undefined;
-    let format: string | undefined;
-
-    if (typeof fieldNameOrConfig === 'object') {
-      fieldName = fieldNameOrConfig.field;
-      agg = fieldNameOrConfig.aggregation ?? 'sum';
-      name = fieldNameOrConfig.name;
-      format = fieldNameOrConfig.numberFormat;
+    let config: PivotValueConfig;
+
+    if (typeof fieldNameOrConfig === 'string') {
+      config = {
+        field: fieldNameOrConfig,
+        aggregation,
+        name: displayName,
+        numberFormat,
+      };
     } else {
-      fieldName = fieldNameOrConfig;
-      agg = aggregation;
-      name = displayName;
-      format = numberFormat;
-    }
-
-    const fieldIndex = this._cache.getFieldIndex(fieldName);
-    if (fieldIndex < 0) {
-      throw new Error(`Field not found in source data: ${fieldName}`);
+      config = fieldNameOrConfig;
     }
 
-    const defaultName = `${agg.charAt(0).toUpperCase() + agg.slice(1)} of ${fieldName}`;
+    this._assertFieldExists(config.field);
 
-    // Resolve numFmtId immediately if format is provided and styles are available
-    let numFmtId: number | undefined;
-    if (format && this._styles) {
-      numFmtId = this._styles.getOrCreateNumFmtId(format);
-    }
+    const resolvedAggregation = config.aggregation ?? 'sum';
+    const resolvedName = config.name ?? `${this._aggregationLabel(resolvedAggregation)} of ${config.field}`;
 
-    const assignment: FieldAssignment = {
-      fieldName,
-      fieldIndex,
-      axis: 'value',
-      aggregation: agg,
-      displayName: name || defaultName,
-      numFmtId,
-    };
-    this._valueFields.push(assignment);
-    this._fieldAssignments.set(fieldIndex, assignment);
+    this._valueFields.push({
+      field: config.field,
+      aggregation: resolvedAggregation,
+      name: resolvedName,
+      numberFormat: config.numberFormat,
+    });
 
     return this;
   }
 
-  /**
-   * Add a field to the filter (page) area
-   * @param fieldName - Name of the source field (column header)
-   */
-  addFilterField(fieldName: string): this {
-    const fieldIndex = this._cache.getFieldIndex(fieldName);
-    if (fieldIndex < 0) {
-      throw new Error(`Field not found in source data: ${fieldName}`);
+  sortField(fieldName: string, order: PivotSortOrder): this {
+    this._assertFieldExists(fieldName);
+    if (!this._rowFields.includes(fieldName) && !this._columnFields.includes(fieldName)) {
+      throw new Error(`Cannot sort field "${fieldName}": only row or column fields can be sorted`);
     }
-
-    const assignment: FieldAssignment = {
-      fieldName,
-      fieldIndex,
-      axis: 'filter',
-    };
-    this._filterFields.push(assignment);
-    this._fieldAssignments.set(fieldIndex, assignment);
-
+    this._sortOrders.set(fieldName, order);
     return this;
   }
 
-  /**
-   * Set a sort order for a row or column field
-   * @param fieldName - Name of the field to sort
-   * @param order - Sort order ('asc' or 'desc')
-   */
-  sortField(fieldName: string, order: PivotSortOrder): this {
-    const fieldIndex = this._cache.getFieldIndex(fieldName);
-    if (fieldIndex < 0) {
-      throw new Error(`Field not found in source data: ${fieldName}`);
-    }
+  filterField(fieldName: string, filter: PivotFieldFilter): this {
+    this._assertFieldExists(fieldName);
 
-    const assignment = this._fieldAssignments.get(fieldIndex);
-    if (!assignment) {
-      throw new Error(`Field is not assigned to pivot table: ${fieldName}`);
+    const hasInclude = 'include' in filter;
+    const hasExclude = 'exclude' in filter;
+    if ((hasInclude && hasExclude) || (!hasInclude && !hasExclude)) {
+      throw new Error('Pivot filter must contain either include or exclude');
     }
-    if (assignment.axis !== 'row' && assignment.axis !== 'column') {
-      throw new Error(`Sort is only supported for row or column fields: ${fieldName}`);
+
+    const values = hasInclude ? filter.include : filter.exclude;
+    if (!values || values.length === 0) {
+      throw new Error('Pivot filter values cannot be empty');
     }
 
-    assignment.sortOrder = order;
+    this._filters.set(fieldName, filter);
     return this;
   }
 
-  /**
-   * Filter items for a row, column, or filter field
-   * @param fieldName - Name of the field to filter
-   * @param filter - Filter configuration with include or exclude list
-   */
-  filterField(fieldName: string, filter: PivotFieldFilter): this {
-    const fieldIndex = this._cache.getFieldIndex(fieldName);
-    if (fieldIndex < 0) {
-      throw new Error(`Field not found in source data: ${fieldName}`);
-    }
+  toPivotCacheDefinitionXml(): string {
+    const cacheData = this._buildPivotCacheData();
+    return this._buildPivotCacheDefinitionXml(cacheData);
+  }
 
-    const assignment = this._fieldAssignments.get(fieldIndex);
-    if (!assignment) {
-      throw new Error(`Field is not assigned to pivot table: ${fieldName}`);
-    }
+  toPivotCacheRecordsXml(): string {
+    const cacheData = this._buildPivotCacheData();
+    return this._buildPivotCacheRecordsXml(cacheData);
+  }
 
-    if (filter.include && filter.exclude) {
-      throw new Error('Cannot use both include and exclude in the same filter');
-    }
+  toPivotCacheDefinitionRelsXml(): string {
+    const relsRoot = 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${this._cachePartIndex}.xml`,
+          },
+          [],
+        ),
+      ],
+    );
 
-    assignment.filter = filter;
-    return this;
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([relsRoot])}`;
   }
 
   /**
-   * Generate the pivotTableDefinition XML
+   * @internal
    */
-  toXml(): string {
-    const children: XmlNode[] = [];
+  buildPivotPartsXml(): {
+    cacheDefinitionXml: string;
+    cacheRecordsXml: string;
+    cacheRelsXml: string;
+    pivotTableXml: string;
+  } {
+    const cacheData = this._buildPivotCacheData();
+    return {
+      cacheDefinitionXml: this._buildPivotCacheDefinitionXml(cacheData),
+      cacheRecordsXml: this._buildPivotCacheRecordsXml(cacheData),
+      cacheRelsXml: this.toPivotCacheDefinitionRelsXml(),
+      pivotTableXml: this._buildPivotTableDefinitionXml(cacheData),
+    };
+  }
+
+  toPivotTableDefinitionXml(): string {
+    const cacheData = this._buildPivotCacheData();
+    return this._buildPivotTableDefinitionXml(cacheData);
+  }
+
+  private _buildPivotCacheDefinitionXml(cacheData: PivotCacheData): string {
+    const cacheFieldNodes = this._fields.map((field, index) => this._buildCacheFieldNode(field, index, cacheData));
+
+    const attrs: Record<string, string> = {
+      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',
+      'r:id': 'rId1',
+      createdVersion: '8',
+      minRefreshableVersion: '3',
+      refreshedVersion: '8',
+      refreshOnLoad: this._refreshOnLoad ? '1' : '0',
+      recordCount: String(cacheData.rowCount),
+    };
+
+    const cacheSourceNode = createElement('cacheSource', { type: 'worksheet' }, [
+      createElement('worksheetSource', { sheet: this._sourceSheetName, ref: toRange(this._sourceRange) }, []),
+    ]);
 
-    // Calculate location (estimate based on fields)
-    const locationRef = this._calculateLocationRef();
+    const cacheFieldsNode = createElement('cacheFields', { count: String(cacheFieldNodes.length) }, cacheFieldNodes);
 
-    // Calculate first data row/col offsets (1-based, relative to pivot table)
-    // firstHeaderRow: row offset of column headers (usually 1)
-    // firstDataRow: row offset where data starts (after filters and column headers)
-    // firstDataCol: column offset where data starts (after row labels)
-    const filterRowCount = this._filterFields.length > 0 ? this._filterFields.length + 1 : 0;
-    const headerRows = this._columnFields.length > 0 ? 1 : 0;
-    const firstDataRow = filterRowCount + headerRows + 1;
-    const firstDataCol = this._rowFields.length > 0 ? this._rowFields.length : 1;
+    const extLstNode = createElement('extLst', {}, [
+      createElement(
+        'ext',
+        {
+          uri: '{725AE2AE-9491-48be-B2B4-4EB974FC3084}',
+          'xmlns:x14': 'http://schemas.microsoft.com/office/spreadsheetml/2009/9/main',
+        },
+        [createElement('x14:pivotCacheDefinition', {}, [])],
+      ),
+    ]);
+
+    const root = createElement('pivotCacheDefinition', attrs, [cacheSourceNode, cacheFieldsNode, extLstNode]);
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([root])}`;
+  }
 
-    const locationNode = createElement(
-      'location',
+  private _buildPivotCacheRecordsXml(cacheData: PivotCacheData): string {
+    const recordNodes = cacheData.recordNodes;
+    const root = createElement(
+      'pivotCacheRecords',
       {
-        ref: locationRef,
-        firstHeaderRow: String(filterRowCount + 1),
-        firstDataRow: String(firstDataRow),
-        firstDataCol: String(firstDataCol),
+        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',
+        count: String(recordNodes.length),
       },
-      [],
+      recordNodes,
+    );
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([root])}`;
+  }
+
+  private _buildPivotTableDefinitionXml(cacheData: PivotCacheData): string {
+    const effectiveValueFields = this._valueFields.length > 0 ? [this._valueFields[0]] : [];
+    const sourceFieldCount = this._fields.length;
+    const pivotFields: XmlNode[] = [];
+    const effectiveRowFieldName = this._rowFields[0];
+    const rowFieldIndexes = effectiveRowFieldName ? [this._fieldIndex(effectiveRowFieldName)] : [];
+    const colFieldIndexes = this._columnFields.length > 0 ? [this._fieldIndex(this._columnFields[0])] : [];
+    const valueFieldIndexes = new Set<number>(
+      effectiveValueFields.map((valueField) => this._fieldIndex(valueField.field)),
     );
-    children.push(locationNode);
 
-    // Build pivotFields (one per source field)
-    const pivotFieldNodes: XmlNode[] = [];
-    for (const cacheField of this._cache.fields) {
-      const fieldNode = this._buildPivotFieldNode(cacheField.index);
-      pivotFieldNodes.push(fieldNode);
+    for (let index = 0; index < this._fields.length; index++) {
+      const field = this._fields[index];
+      const attrs: Record<string, string> = { showAll: '0' };
+
+      if (rowFieldIndexes.includes(index)) {
+        attrs.axis = 'axisRow';
+      } else if (colFieldIndexes.includes(index)) {
+        attrs.axis = 'axisCol';
+      }
+
+      if (valueFieldIndexes.has(index)) {
+        attrs.dataField = '1';
+      }
+
+      const sortOrder = this._sortOrders.get(field.name);
+      if (sortOrder) {
+        attrs.sortType = SORT_TO_XML[sortOrder];
+      }
+
+      const children: XmlNode[] = [];
+      if (rowFieldIndexes.includes(index) || colFieldIndexes.includes(index)) {
+        const distinctItems = cacheData.distinctItemsByField[index] ?? [];
+        const itemNodes: XmlNode[] = distinctItems.map((_item, itemIndex) =>
+          createElement('item', { x: String(itemIndex) }, []),
+        );
+        itemNodes.push(createElement('item', { t: 'default' }, []));
+        children.push(createElement('items', { count: String(itemNodes.length) }, itemNodes));
+      }
+
+      pivotFields.push(createElement('pivotField', attrs, children));
     }
-    children.push(createElement('pivotFields', { count: String(pivotFieldNodes.length) }, pivotFieldNodes));
 
-    // Row fields
-    if (this._rowFields.length > 0) {
-      const rowFieldNodes = this._rowFields.map((f) => createElement('field', { x: String(f.fieldIndex) }, []));
-      children.push(createElement('rowFields', { count: String(rowFieldNodes.length) }, rowFieldNodes));
+    const children: XmlNode[] = [];
+
+    const locationRef = this._buildTargetAreaRef(cacheData);
+    children.push(
+      createElement(
+        'location',
+        {
+          ref: locationRef,
+          firstHeaderRow: '1',
+          firstDataRow: '1',
+          firstDataCol: String(Math.max(1, this._rowFields.length + 1)),
+        },
+        [],
+      ),
+    );
+
+    children.push(createElement('pivotFields', { count: String(sourceFieldCount) }, pivotFields));
 
-      // Row items
-      const rowItemNodes = this._buildRowItems();
+    if (rowFieldIndexes.length > 0) {
+      children.push(
+        createElement(
+          'rowFields',
+          { count: String(rowFieldIndexes.length) },
+          rowFieldIndexes.map((fieldIndex) => createElement('field', { x: String(fieldIndex) }, [])),
+        ),
+      );
+
+      const distinctRowItems = cacheData.distinctItemsByField[rowFieldIndexes[0]] ?? [];
+      const rowItemNodes: XmlNode[] = [];
+      if (distinctRowItems.length > 0) {
+        rowItemNodes.push(createElement('i', {}, [createElement('x', {}, [])]));
+        for (let itemIndex = 1; itemIndex < distinctRowItems.length; itemIndex++) {
+          rowItemNodes.push(createElement('i', {}, [createElement('x', { v: String(itemIndex) }, [])]));
+        }
+      }
+      rowItemNodes.push(createElement('i', { t: 'grand' }, [createElement('x', {}, [])]));
       children.push(createElement('rowItems', { count: String(rowItemNodes.length) }, rowItemNodes));
     }
 
-    // Column fields
-    if (this._columnFields.length > 0) {
-      const colFieldNodes = this._columnFields.map((f) => createElement('field', { x: String(f.fieldIndex) }, []));
-      // If we have multiple value fields, add -2 to indicate where "Values" header goes
-      if (this._valueFields.length > 1) {
-        colFieldNodes.push(createElement('field', { x: '-2' }, []));
-      }
-      children.push(createElement('colFields', { count: String(colFieldNodes.length) }, colFieldNodes));
-
-      // Column items - need to account for multiple value fields
-      const colItemNodes = this._buildColItems();
-      children.push(createElement('colItems', { count: String(colItemNodes.length) }, colItemNodes));
-    } else if (this._valueFields.length > 1) {
-      // If no column fields but we have multiple values, need colFields with -2 (data field indicator)
-      children.push(createElement('colFields', { count: '1' }, [createElement('field', { x: '-2' }, [])]));
-
-      // Column items for each value field
-      const colItemNodes: XmlNode[] = [];
-      for (let i = 0; i < this._valueFields.length; i++) {
-        colItemNodes.push(createElement('i', {}, [createElement('x', i === 0 ? {} : { v: String(i) }, [])]));
-      }
-      children.push(createElement('colItems', { count: String(colItemNodes.length) }, colItemNodes));
-    } else if (this._valueFields.length === 1) {
-      // Single value field - just add a single column item
-      children.push(createElement('colItems', { count: '1' }, [createElement('i', {}, [])]));
+    if (colFieldIndexes.length > 0) {
+      children.push(
+        createElement(
+          'colFields',
+          { count: String(colFieldIndexes.length) },
+          colFieldIndexes.map((fieldIndex) => createElement('field', { x: String(fieldIndex) }, [])),
+        ),
+      );
     }
 
-    // Page (filter) fields
+    // Excel expects colItems even when no explicit column fields are configured.
+    children.push(createElement('colItems', { count: '1' }, [createElement('i', {}, [])]));
+
     if (this._filterFields.length > 0) {
-      const pageFieldNodes = this._filterFields.map((f) =>
-        createElement('pageField', { fld: String(f.fieldIndex), hier: '-1' }, []),
+      children.push(
+        createElement(
+          'pageFields',
+          { count: String(this._filterFields.length) },
+          this._filterFields.map((field, index) =>
+            createElement('pageField', { fld: String(this._fieldIndex(field)), hier: '-1', item: String(index) }, []),
+          ),
+        ),
       );
-      children.push(createElement('pageFields', { count: String(pageFieldNodes.length) }, pageFieldNodes));
-    }
-
-    // Data fields (values)
-    if (this._valueFields.length > 0) {
-      const dataFieldNodes = this._valueFields.map((f) => {
-        const attrs: Record<string, string> = {
-          name: f.displayName || f.fieldName,
-          fld: String(f.fieldIndex),
-          baseField: '0',
-          baseItem: '0',
-          subtotal: f.aggregation || 'sum',
-        };
-
-        if (f.numFmtId !== undefined) {
-          attrs.numFmtId = String(f.numFmtId);
-        }
+    }
 
-        return createElement('dataField', attrs, []);
-      });
-      children.push(createElement('dataFields', { count: String(dataFieldNodes.length) }, dataFieldNodes));
+    if (effectiveValueFields.length > 0) {
+      children.push(
+        createElement(
+          'dataFields',
+          { count: String(effectiveValueFields.length) },
+          effectiveValueFields.map((valueField) => {
+            const attrs: Record<string, string> = {
+              name: valueField.name,
+              fld: String(this._fieldIndex(valueField.field)),
+              baseField: '0',
+              baseItem: '0',
+              subtotal: AGGREGATION_TO_XML[valueField.aggregation],
+            };
+
+            if (valueField.numberFormat) {
+              attrs.numFmtId = String(this._workbook.styles.getOrCreateNumFmtId(valueField.numberFormat));
+            }
+
+            return createElement('dataField', attrs, []);
+          }),
+        ),
+      );
     }
 
-    // Pivot table style
     children.push(
       createElement(
         'pivotTableStyleInfo',
@@ -406,275 +490,286 @@ export class PivotTable {
       ),
     );
 
-    const pivotTableNode = createElement(
-      'pivotTableDefinition',
-      {
-        xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
-        'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
-        name: this._name,
-        cacheId: String(this._cache.cacheId),
-        applyNumberFormats: '1',
-        applyBorderFormats: '0',
-        applyFontFormats: '0',
-        applyPatternFormats: '0',
-        applyAlignmentFormats: '0',
-        applyWidthHeightFormats: '1',
-        dataCaption: 'Values',
-        updatedVersion: '8',
-        minRefreshableVersion: '3',
-        useAutoFormatting: '1',
-        rowGrandTotals: '1',
-        colGrandTotals: '1',
-        itemPrintTitles: '1',
-        createdVersion: '8',
-        indent: '0',
-        outline: '1',
-        outlineData: '1',
-        multipleFieldFilters: '0',
-      },
-      children,
-    );
+    const attrs: Record<string, string> = {
+      xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+      'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+      name: this._name,
+      cacheId: String(this._cacheId),
+      dataCaption: 'Values',
+      applyNumberFormats: '1',
+      applyBorderFormats: '0',
+      applyFontFormats: '0',
+      applyPatternFormats: '0',
+      applyAlignmentFormats: '0',
+      applyWidthHeightFormats: '1',
+      updatedVersion: '8',
+      minRefreshableVersion: '3',
+      createdVersion: '8',
+      useAutoFormatting: '1',
+      rowGrandTotals: '1',
+      colGrandTotals: '1',
+      itemPrintTitles: '1',
+      indent: '0',
+      multipleFieldFilters: this._filters.size > 0 ? '1' : '0',
+      outline: '1',
+      outlineData: '1',
+    };
 
-    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([pivotTableNode])}`;
+    const root = createElement('pivotTableDefinition', attrs, children);
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n${stringifyXml([root])}`;
   }
 
-  /**
-   * Build a pivotField node for a given field index
-   */
-  private _buildPivotFieldNode(fieldIndex: number): XmlNode {
-    const attrs: Record<string, string> = {};
-    const children: XmlNode[] = [];
+  private _buildCacheFieldNode(field: PivotFieldMeta, fieldIndex: number, cacheData: PivotCacheData): XmlNode {
+    const info = cacheData.numericInfoByField[fieldIndex];
+    const isAxisField = cacheData.isAxisFieldByIndex[fieldIndex];
+    const isValueField = cacheData.isValueFieldByIndex[fieldIndex];
+    const allNonNullAreNumbers = info.nonNullCount > 0 && info.numericCount === info.nonNullCount;
+
+    if (isValueField || (!isAxisField && allNonNullAreNumbers)) {
+      const minValue = info.hasNumeric ? info.min : 0;
+      const maxValue = info.hasNumeric ? info.max : 0;
+      const hasInteger = info.hasNumeric ? info.allIntegers : true;
+
+      const attrs: Record<string, string> = {
+        containsSemiMixedTypes: '0',
+        containsString: '0',
+        containsNumber: '1',
+        minValue: String(minValue),
+        maxValue: String(maxValue),
+      };
+      if (hasInteger) {
+        attrs.containsInteger = '1';
+      }
 
-    // Check if this field is assigned to an axis
-    const rowField = this._rowFields.find((f) => f.fieldIndex === fieldIndex);
-    const colField = this._columnFields.find((f) => f.fieldIndex === fieldIndex);
-    const filterField = this._filterFields.find((f) => f.fieldIndex === fieldIndex);
-    const valueField = this._valueFields.find((f) => f.fieldIndex === fieldIndex);
+      return createElement('cacheField', { name: field.name, numFmtId: '0' }, [
+        createElement('sharedItems', attrs, []),
+      ]);
+    }
 
-    // Get the assignment to check for sort/filter options
-    const assignment = rowField || colField || filterField;
+    if (!isAxisField) {
+      return createElement('cacheField', { name: field.name, numFmtId: '0' }, [createElement('sharedItems', {}, [])]);
+    }
 
-    if (rowField) {
-      attrs.axis = 'axisRow';
-      attrs.showAll = '0';
+    const sharedItems = cacheData.sharedItemsByField[fieldIndex] ?? [];
+    return createElement('cacheField', { name: field.name, numFmtId: '0' }, [
+      createElement('sharedItems', { count: String(sharedItems.length) }, sharedItems),
+    ]);
+  }
 
-      // Add sort order if specified
-      if (rowField.sortOrder) {
-        attrs.sortType = rowField.sortOrder === 'asc' ? 'ascending' : 'descending';
-      }
+  private _buildTargetAreaRef(cacheData: PivotCacheData): string {
+    const start = this._targetCell;
+    const estimatedRows = Math.max(3, this._estimateOutputRows(cacheData));
+    const estimatedCols = Math.max(1, this._rowFields.length + Math.max(1, this._valueFields.length));
 
-      // Add items for shared values
-      const cacheField = this._cache.fields[fieldIndex];
-      if (cacheField && cacheField.sharedItems.length > 0) {
-        const itemNodes = this._buildItemNodes(cacheField.sharedItems, assignment?.filter);
-        children.push(createElement('items', { count: String(itemNodes.length) }, itemNodes));
-      }
-    } else if (colField) {
-      attrs.axis = 'axisCol';
-      attrs.showAll = '0';
+    const endRow = start.row + estimatedRows - 1;
+    const endCol = start.col + estimatedCols - 1;
 
-      // Add sort order if specified
-      if (colField.sortOrder) {
-        attrs.sortType = colField.sortOrder === 'asc' ? 'ascending' : 'descending';
-      }
+    return `${toAddress(start.row, start.col)}:${toAddress(endRow, endCol)}`;
+  }
 
-      const cacheField = this._cache.fields[fieldIndex];
-      if (cacheField && cacheField.sharedItems.length > 0) {
-        const itemNodes = this._buildItemNodes(cacheField.sharedItems, assignment?.filter);
-        children.push(createElement('items', { count: String(itemNodes.length) }, itemNodes));
-      }
-    } else if (filterField) {
-      attrs.axis = 'axisPage';
-      attrs.showAll = '0';
-      const cacheField = this._cache.fields[fieldIndex];
-      if (cacheField && cacheField.sharedItems.length > 0) {
-        const itemNodes = this._buildItemNodes(cacheField.sharedItems, assignment?.filter);
-        children.push(createElement('items', { count: String(itemNodes.length) }, itemNodes));
-      }
-    } else if (valueField) {
-      attrs.dataField = '1';
-      attrs.showAll = '0';
-    } else {
-      attrs.showAll = '0';
+  private _estimateOutputRows(cacheData: PivotCacheData): number {
+    if (this._rowFields.length === 0) {
+      return 3;
     }
 
-    return createElement('pivotField', attrs, children);
+    const rowFieldIndex = this._fieldIndex(this._rowFields[0]);
+    const distinctItems = cacheData.distinctItemsByField[rowFieldIndex] ?? [];
+    return Math.max(3, distinctItems.length + 2);
   }
 
-  /**
-   * Build item nodes for a pivot field, with optional filtering
-   */
-  private _buildItemNodes(sharedItems: string[], filter?: PivotFieldFilter): XmlNode[] {
-    const itemNodes: XmlNode[] = [];
-
-    for (let i = 0; i < sharedItems.length; i++) {
-      const itemValue = sharedItems[i];
-      const itemAttrs: Record<string, string> = { x: String(i) };
-
-      // Check if this item should be hidden
-      if (filter) {
-        let hidden = false;
-        if (filter.exclude && filter.exclude.includes(itemValue)) {
-          hidden = true;
-        } else if (filter.include && !filter.include.includes(itemValue)) {
-          hidden = true;
-        }
-        if (hidden) {
-          itemAttrs.h = '1';
-        }
+  private _buildPivotCacheData(): PivotCacheData {
+    const rowCount = Math.max(0, this._sourceRange.end.row - this._sourceRange.start.row);
+    const fieldCount = this._fields.length;
+    const recordNodes: XmlNode[] = new Array(rowCount);
+    const sharedItemIndexByField: Array<Map<string, number> | null> = new Array(fieldCount).fill(null);
+    const sharedItemsByField: Array<XmlNode[] | null> = new Array(fieldCount).fill(null);
+    const distinctItemsByField: Array<Exclude<CellValue, null>[] | null> = new Array(fieldCount).fill(null);
+    const numericInfoByField: PivotNumericInfo[] = new Array(fieldCount);
+    const isAxisFieldByIndex: boolean[] = new Array(fieldCount);
+    const isValueFieldByIndex: boolean[] = new Array(fieldCount);
+
+    const effectiveRowField = this._rowFields[0] ?? null;
+    const effectiveColumnField = this._columnFields[0] ?? null;
+    const filterFields = new Set(this._filterFields);
+    const valueFields = new Set(this._valueFields.map((valueField) => valueField.field));
+
+    for (let fieldIndex = 0; fieldIndex < fieldCount; fieldIndex++) {
+      const fieldName = this._fields[fieldIndex].name;
+      const isAxisField =
+        fieldName === effectiveRowField || fieldName === effectiveColumnField || filterFields.has(fieldName);
+      const isValueField = valueFields.has(fieldName);
+
+      isAxisFieldByIndex[fieldIndex] = isAxisField;
+      isValueFieldByIndex[fieldIndex] = isValueField;
+
+      if (isAxisField) {
+        sharedItemIndexByField[fieldIndex] = new Map<string, number>();
+        sharedItemsByField[fieldIndex] = [];
+        distinctItemsByField[fieldIndex] = [];
       }
 
-      itemNodes.push(createElement('item', itemAttrs, []));
+      numericInfoByField[fieldIndex] = {
+        nonNullCount: 0,
+        numericCount: 0,
+        min: 0,
+        max: 0,
+        hasNumeric: false,
+        allIntegers: true,
+      };
     }
 
-    // Add default subtotal item
-    itemNodes.push(createElement('item', { t: 'default' }, []));
+    for (let rowOffset = 0; rowOffset < rowCount; rowOffset++) {
+      const row = this._sourceRange.start.row + 1 + rowOffset;
+      const valueNodes: XmlNode[] = [];
+
+      for (let fieldIndex = 0; fieldIndex < fieldCount; fieldIndex++) {
+        const field = this._fields[fieldIndex];
+        const cellValue = this._sourceSheet.getCellIfExists(row, field.sourceCol)?.value ?? null;
+
+        if (cellValue !== null) {
+          const numericInfo = numericInfoByField[fieldIndex];
+          numericInfo.nonNullCount++;
+
+          if (typeof cellValue === 'number' && Number.isFinite(cellValue)) {
+            numericInfo.numericCount++;
+            if (!numericInfo.hasNumeric) {
+              numericInfo.min = cellValue;
+              numericInfo.max = cellValue;
+              numericInfo.hasNumeric = true;
+            } else {
+              if (cellValue < numericInfo.min) numericInfo.min = cellValue;
+              if (cellValue > numericInfo.max) numericInfo.max = cellValue;
+            }
+            if (!Number.isInteger(cellValue)) {
+              numericInfo.allIntegers = false;
+            }
+          }
 
-    return itemNodes;
-  }
+          if (isAxisFieldByIndex[fieldIndex]) {
+            const distinctMap = sharedItemIndexByField[fieldIndex]!;
+            const key = this._distinctKey(cellValue as Exclude<CellValue, null>);
+            let index = distinctMap.get(key);
+            if (index === undefined) {
+              index = distinctMap.size;
+              distinctMap.set(key, index);
+              distinctItemsByField[fieldIndex]!.push(cellValue as Exclude<CellValue, null>);
+              const sharedNode = this._buildSharedItemNode(cellValue as Exclude<CellValue, null>);
+              if (sharedNode) {
+                sharedItemsByField[fieldIndex]!.push(sharedNode);
+              }
+            }
+            valueNodes.push(createElement('x', { v: String(index) }, []));
+            continue;
+          }
+        }
 
-  /**
-   * Build row items based on unique values in row fields
-   */
-  private _buildRowItems(): XmlNode[] {
-    const items: XmlNode[] = [];
+        valueNodes.push(this._buildRawCacheValueNode(cellValue));
+      }
 
-    if (this._rowFields.length === 0) return items;
+      recordNodes[rowOffset] = createElement('r', {}, valueNodes);
+    }
 
-    // Get unique values from first row field
-    const firstRowField = this._rowFields[0];
-    const cacheField = this._cache.fields[firstRowField.fieldIndex];
+    return {
+      rowCount,
+      recordNodes,
+      sharedItemIndexByField,
+      sharedItemsByField,
+      distinctItemsByField,
+      numericInfoByField,
+      isAxisFieldByIndex,
+      isValueFieldByIndex,
+    };
+  }
 
-    if (cacheField && cacheField.sharedItems.length > 0) {
-      for (let i = 0; i < cacheField.sharedItems.length; i++) {
-        items.push(createElement('i', {}, [createElement('x', i === 0 ? {} : { v: String(i) }, [])]));
-      }
+  private _buildSharedItemNode(value: Exclude<CellValue, null>): XmlNode | null {
+    if (typeof value === 'string') {
+      return { s: [], ':@': { '@_v': value } } as XmlNode;
     }
 
-    // Add grand total row
-    items.push(createElement('i', { t: 'grand' }, [createElement('x', {}, [])]));
-
-    return items;
-  }
+    if (typeof value === 'number') {
+      return createElement('n', { v: String(value) }, []);
+    }
 
-  /**
-   * Build column items based on unique values in column fields
-   */
-  private _buildColItems(): XmlNode[] {
-    const items: XmlNode[] = [];
-
-    if (this._columnFields.length === 0) return items;
-
-    // Get unique values from first column field
-    const firstColField = this._columnFields[0];
-    const cacheField = this._cache.fields[firstColField.fieldIndex];
-
-    if (cacheField && cacheField.sharedItems.length > 0) {
-      if (this._valueFields.length > 1) {
-        // Multiple value fields - need nested items for each column value + value field combination
-        for (let colIdx = 0; colIdx < cacheField.sharedItems.length; colIdx++) {
-          for (let valIdx = 0; valIdx < this._valueFields.length; valIdx++) {
-            const xNodes: XmlNode[] = [
-              createElement('x', colIdx === 0 ? {} : { v: String(colIdx) }, []),
-              createElement('x', valIdx === 0 ? {} : { v: String(valIdx) }, []),
-            ];
-            items.push(createElement('i', {}, xNodes));
-          }
-        }
-      } else {
-        // Single value field - simple column items
-        for (let i = 0; i < cacheField.sharedItems.length; i++) {
-          items.push(createElement('i', {}, [createElement('x', i === 0 ? {} : { v: String(i) }, [])]));
-        }
-      }
+    if (typeof value === 'boolean') {
+      return createElement('b', { v: value ? '1' : '0' }, []);
     }
 
-    // Add grand total column(s)
-    if (this._valueFields.length > 1) {
-      // Grand total for each value field
-      for (let valIdx = 0; valIdx < this._valueFields.length; valIdx++) {
-        const xNodes: XmlNode[] = [
-          createElement('x', {}, []),
-          createElement('x', valIdx === 0 ? {} : { v: String(valIdx) }, []),
-        ];
-        items.push(createElement('i', { t: 'grand' }, xNodes));
-      }
-    } else {
-      items.push(createElement('i', { t: 'grand' }, [createElement('x', {}, [])]));
+    if (value instanceof Date) {
+      return createElement('d', { v: value.toISOString() }, []);
     }
 
-    return items;
+    return null;
   }
 
-  /**
-   * Calculate the location reference for the pivot table output
-   */
-  private _calculateLocationRef(): string {
-    // Estimate output size based on fields
-    const numRows = this._estimateRowCount();
-    const numCols = this._estimateColCount();
-
-    const startRow = this._targetRow;
-    const startCol = this._targetCol;
-    const endRow = startRow + numRows - 1;
-    const endCol = startCol + numCols - 1;
+  private _buildRawCacheValueNode(value: CellValue): XmlNode {
+    if (value === null) {
+      return createElement('m', {}, []);
+    }
 
-    return `${this._colToLetter(startCol)}${startRow}:${this._colToLetter(endCol)}${endRow}`;
-  }
+    if (typeof value === 'string') {
+      return { s: [], ':@': { '@_v': value } } as XmlNode;
+    }
 
-  /**
-   * Estimate number of rows in pivot table output
-   */
-  private _estimateRowCount(): number {
-    let count = 1; // Header row
+    if (typeof value === 'number') {
+      return createElement('n', { v: String(value) }, []);
+    }
 
-    // Add filter area rows
-    count += this._filterFields.length;
+    if (typeof value === 'boolean') {
+      return createElement('b', { v: value ? '1' : '0' }, []);
+    }
 
-    // Add row labels (unique values in row fields)
-    if (this._rowFields.length > 0) {
-      const firstRowField = this._rowFields[0];
-      const cacheField = this._cache.fields[firstRowField.fieldIndex];
-      count += (cacheField?.sharedItems.length || 1) + 1; // +1 for grand total
-    } else {
-      count += 1; // At least one data row
+    if (value instanceof Date) {
+      return createElement('d', { v: value.toISOString() }, []);
     }
 
-    return Math.max(count, 3);
+    return createElement('m', {}, []);
   }
 
-  /**
-   * Estimate number of columns in pivot table output
-   */
-  private _estimateColCount(): number {
-    let count = 0;
-
-    // Row label columns
-    count += Math.max(this._rowFields.length, 1);
+  private _assertFieldExists(fieldName: string): void {
+    if (!this._fields.some((field) => field.name === fieldName)) {
+      throw new Error(`Pivot field not found: ${fieldName}`);
+    }
+  }
 
-    // Column labels (unique values in column fields)
-    if (this._columnFields.length > 0) {
-      const firstColField = this._columnFields[0];
-      const cacheField = this._cache.fields[firstColField.fieldIndex];
-      count += (cacheField?.sharedItems.length || 1) + 1; // +1 for grand total
-    } else {
-      // Value columns
-      count += Math.max(this._valueFields.length, 1);
+  private _fieldIndex(fieldName: string): number {
+    const index = this._fields.findIndex((field) => field.name === fieldName);
+    if (index < 0) {
+      throw new Error(`Pivot field not found: ${fieldName}`);
     }
+    return index;
+  }
 
-    return Math.max(count, 2);
+  private _aggregationLabel(aggregation: PivotAggregationType): string {
+    switch (aggregation) {
+      case 'sum':
+        return 'Sum';
+      case 'count':
+        return 'Count';
+      case 'average':
+        return 'Average';
+      case 'min':
+        return 'Min';
+      case 'max':
+        return 'Max';
+    }
   }
 
-  /**
-   * Convert 0-based column index to letter (A, B, ..., Z, AA, etc.)
-   */
-  private _colToLetter(col: number): string {
-    let result = '';
-    let n = col;
-    while (n >= 0) {
-      result = String.fromCharCode((n % 26) + 65) + result;
-      n = Math.floor(n / 26) - 1;
-    }
-    return result;
+  private _distinctKey(value: Exclude<CellValue, null>): string {
+    if (value instanceof Date) {
+      return `d:${value.toISOString()}`;
+    }
+    if (typeof value === 'string') {
+      return `s:${value}`;
+    }
+    if (typeof value === 'number') {
+      return `n:${value}`;
+    }
+    if (typeof value === 'boolean') {
+      return `b:${value ? 1 : 0}`;
+    }
+    if (typeof value === 'object' && value && 'error' in value) {
+      return `e:${value.error}`;
+    }
+    return 'u:';
   }
 }