"arrowParens": "avoid",

"singleQuote": true,

<li>

Merged <a href="https://github.com/exceljs/exceljs/pull/TK">Add pivot table with limitations #TK</a>.

Many thanks to Protobi and <a href="https://github.com/mikez">Michael</a> for this contribution.

</li>

<li><a href="#pivot-tables">Pivot Tables</a></li>

Add a pivot table to a Workbook without existing pivot tables.

worksheet.addPivotTable(configuration);

**Note:** Pivot table support is in its early stages with certain limitations, including:

- No support for reading xlsx documents with existing pivot tables (writing is supported).

- Pivot table configurations must consist of 2 rows, 1 column, 1 value, and use the sum metric. The source data can have any number of columns and rows.

- Only one pivot table can be added.

const workbook = new Excel.Workbook();

const worksheet1 = workbook.addWorksheet('Sheet1');

worksheet1.addRows([

['A', 'B', 'C', 'D', 'E'],

['a1', 'b1', 'c1', 4, 5],

['a1', 'b2', 'c1', 4, 5],

['a2', 'b1', 'c2', 14, 24],

['a2', 'b2', 'c2', 24, 35],

['a3', 'b1', 'c3', 34, 45],

['a3', 'b2', 'c3', 44, 45],

]);

const worksheet2 = workbook.addWorksheet('Sheet2');

worksheet2.addPivotTable({

// Source data: entire sheet range

sourceSheet: worksheet1,

// Pivot table fields: via header row in `worksheet1`

rows: ['A', 'B'], // Exactly 2 fields

columns: ['C'], // Exactly 1 field

values: ['E'], // Exactly 1 field

metric: 'sum', // Metric: 'sum' only

});

this.pivotTables = [];

pivotTables: this.pivotTables,

this.pivotTables = value.pivotTables || [];

const {objectFromProps} = require('../utils/utils');

this.pivotTables = [];

// =========================================================================

// Pivot Tables

addPivotTable(model) {

// Example `model`:

// {

// // Source of data: the entire sheet range is taken,

// // akin to `worksheet1.getSheetValues()`.

// sourceSheet: worksheet1,

//

// // Pivot table fields: values indicate field names;

// // they come from the first row in `worksheet1`.

// rows: ['A', 'B'], // only 2 items possible for now

// columns: ['C'], // only 1 item possible for now

// values: ['E'], // only 1 item possible for now

// metric: 'sum', // only 'sum' possible for now

// }

// Validate

// --------------------------------------------------

if (this.workbook.pivotTables.length === 1) {

throw new Error(

'A pivot table was already added. At this time, ExcelJS supports at most one pivot table per file.'

);

}

if (model.metric && model.metric !== 'sum') {

throw new Error('Only the "sum" metric is supported at this time.');

}

const headerNames = model.sourceSheet.getRow(1).values.slice(1);

const isInHeaderNames = objectFromProps(headerNames, true);

for (const name of [...model.rows, ...model.columns, ...model.values]) {

if (!isInHeaderNames[name]) {

throw new Error(`The header name "${name}" was not found in ${model.sourceSheet.name}.`);

}

}

if (model.rows.length !== 2) {

throw new Error('Exactly 2 rows need to be specified at this time.');

}

if (model.columns.length !== 1) {

throw new Error('Exactly 1 column needs to be specified at this time.');

}

if (model.values.length !== 1) {

throw new Error('Exactly 1 value needs to be specified at this time.');

}

// Translate

// --------------------------------------------------

const {sourceSheet} = model;

let {rows, columns, values} = model;

const cacheFields = sourceSheet._makeCacheFields([...rows, ...columns]);

// let {rows, columns, values} use indices instead of names;

// names can then be accessed via `pivotTable.cacheFields[index].name`.

// *Note*: Using `reduce` as `Object.fromEntries` requires Node 12+;

// ExcelJs is >=8.3.0 (as of 2023-10-08).

const nameToIndex = cacheFields.reduce((result, cacheField, index) => {

result[cacheField.name] = index;

return result;

}, {});

rows = rows.map(row => nameToIndex[row]);

columns = columns.map(column => nameToIndex[column]);

values = values.map(value => nameToIndex[value]);

// form pivot table object

const pivotTable = {

sourceSheet,

rows,

columns,

values,

metric: 'sum',

cacheFields,

// defined in <pivotTableDefinition> of xl/pivotTables/pivotTable1.xml;

// also used in xl/workbook.xml

cacheId: '10',

};

this.pivotTables.push(pivotTable);

this.workbook.pivotTables.push(pivotTable);

return pivotTable;

}

_makeCacheFields(fieldNamesWithSharedItems) {

// Cache fields are used in pivot tables to reference source data.

//

// Example

// -------

// Turn

//

// `this` sheet values [

// ['A', 'B', 'C', 'D', 'E'],

// ['a1', 'b1', 'c1', 4, 5],

// ['a1', 'b2', 'c1', 4, 5],

// ['a2', 'b1', 'c2', 14, 24],

// ['a2', 'b2', 'c2', 24, 35],

// ['a3', 'b1', 'c3', 34, 45],

// ['a3', 'b2', 'c3', 44, 45],

// ];

// fieldNamesWithSharedItems = ['A', 'B', 'C'];

//

// into

//

// [

// { name: 'A', sharedItems: ['a1', 'a2', 'a3'] },

// { name: 'B', sharedItems: ['b1', 'b2'] },

// { name: 'C', sharedItems: ['c1', 'c2', 'c3'] },

// { name: 'D', sharedItems: null },

// { name: 'E', sharedItems: null },

//

const {range, toSortedArray} = require('../utils/utils');

const names = this.getRow(1).values;

const nameToHasSharedItems = objectFromProps(fieldNamesWithSharedItems, true);

const aggregate = columnIndex => {

const columnValues = this.getColumn(columnIndex).values.splice(2);

const columnValuesAsSet = new Set(columnValues);

return toSortedArray(columnValuesAsSet);

};

// make result

const result = [];

for (const columnIndex of range(1, names.length)) {

const name = names[columnIndex];

const sharedItems = nameToHasSharedItems[name] ? aggregate(columnIndex) : null;

result.push({name, sharedItems});

}

return result;

}

pivotTables: this.pivotTables,

this.pivotTables = value.pivotTables;

// eslint-disable-next-line no-mixed-operators

return 25569 + d.getTime() / (24 * 3600 * 1000) - (date1904 ? 1462 : 0);

// eslint-disable-next-line no-mixed-operators

*range(start, stop, step = 1) {

const compareOrder = step > 0 ? (a, b) => a < b : (a, b) => a > b;

for (let value = start; compareOrder(value, stop); value += step) {

yield value;

}

},

toSortedArray(values) {

const result = Array.from(values);

// Note: per default, `Array.prototype.sort()` converts values

// to strings when comparing. Here, if we have numbers, we use

// numeric sort.

if (result.every(item => Number.isFinite(item))) {

const compareNumbers = (a, b) => a - b;

return result.sort(compareNumbers);

}

return result.sort();

},

objectFromProps(props, value = null) {

// *Note*: Using `reduce` as `Object.fromEntries` requires Node 12+;

// ExcelJs is >=8.3.0 (as of 2023-10-08).

// return Object.fromEntries(props.map(property => [property, value]));

return props.reduce((result, property) => {

result[property] = value;

return result;

}, {});

},

OfficeDocument: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument',

SharedStrings: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings',

CoreProperties: 'http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties',

ExtenderProperties: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties',

PivotCacheDefinition: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition',

PivotCacheRecords: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheRecords',

PivotTable: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable',

const BaseXform = require('../base-xform');

class WorkbookPivotCacheXform extends BaseXform {

render(xmlStream, model) {

xmlStream.leafNode('pivotCache', {

cacheId: model.cacheId,

'r:id': model.rId,

});

}

parseOpen(node) {

if (node.name === 'pivotCache') {

this.model = {

cacheId: node.attributes.cacheId,

rId: node.attributes['r:id'],

};

return true;

}

return false;

}

parseText() {}

parseClose() {

return false;

}

module.exports = WorkbookPivotCacheXform;