@lyit/exceljs 4.4.1

package/lib/xlsx/xform/drawing/two-cell-anchor-xform.js

@@ -0,0 +1,62 @@
+const BaseCellAnchorXform = require('./base-cell-anchor-xform');
+const StaticXform = require('../static-xform');
+
+const CellPositionXform = require('./cell-position-xform');
+const PicXform = require('./pic-xform');
+
+class TwoCellAnchorXform extends BaseCellAnchorXform {
+  constructor() {
+    super();
+
+    this.map = {
+      'xdr:from': new CellPositionXform({tag: 'xdr:from'}),
+      'xdr:to': new CellPositionXform({tag: 'xdr:to'}),
+      'xdr:pic': new PicXform(),
+      'xdr:clientData': new StaticXform({tag: 'xdr:clientData'}),
+    };
+  }
+
+  get tag() {
+    return 'xdr:twoCellAnchor';
+  }
+
+  prepare(model, options) {
+    this.map['xdr:pic'].prepare(model.picture, options);
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag, {editAs: model.range.editAs || 'oneCell'});
+
+    this.map['xdr:from'].render(xmlStream, model.range.tl);
+    this.map['xdr:to'].render(xmlStream, model.range.br);
+    this.map['xdr:pic'].render(xmlStream, model.picture);
+    this.map['xdr:clientData'].render(xmlStream, {});
+
+    xmlStream.closeNode();
+  }
+
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.parser = undefined;
+      }
+      return true;
+    }
+    switch (name) {
+      case this.tag:
+        this.model.range.tl = this.map['xdr:from'].model;
+        this.model.range.br = this.map['xdr:to'].model;
+        this.model.picture = this.map['xdr:pic'].model;
+        return false;
+      default:
+        // could be some unrecognised tags
+        return true;
+    }
+  }
+
+  reconcile(model, options) {
+    model.medium = this.reconcilePicture(model.picture, options);
+  }
+}
+
+module.exports = TwoCellAnchorXform;

package/lib/xlsx/xform/list-xform.js

@@ -0,0 +1,95 @@
+const BaseXform = require('./base-xform');
+
+class ListXform extends BaseXform {
+  constructor(options) {
+    super();
+
+    this.tag = options.tag;
+    this.always = !!options.always;
+    this.count = options.count;
+    this.empty = options.empty;
+    this.$count = options.$count || 'count';
+    this.$ = options.$;
+    this.childXform = options.childXform;
+    this.maxItems = options.maxItems;
+  }
+
+  prepare(model, options) {
+    const {childXform} = this;
+    if (model) {
+      model.forEach((childModel, index) => {
+        options.index = index;
+        childXform.prepare(childModel, options);
+      });
+    }
+  }
+
+  render(xmlStream, model) {
+    if (this.always || (model && model.length)) {
+      xmlStream.openNode(this.tag, this.$);
+      if (this.count) {
+        xmlStream.addAttribute(this.$count, (model && model.length) || 0);
+      }
+
+      const {childXform} = this;
+      (model || []).forEach((childModel, index) => {
+        childXform.render(xmlStream, childModel, index);
+      });
+
+      xmlStream.closeNode();
+    } else if (this.empty) {
+      xmlStream.leafNode(this.tag);
+    }
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.tag:
+        this.model = [];
+        return true;
+      default:
+        if (this.childXform.parseOpen(node)) {
+          this.parser = this.childXform;
+          return true;
+        }
+        return false;
+    }
+  }
+
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.model.push(this.parser.model);
+        this.parser = undefined;
+
+        if (this.maxItems && this.model.length > this.maxItems) {
+          throw new Error(`Max ${this.childXform.tag} count (${this.maxItems}) exceeded`);
+        }
+      }
+      return true;
+    }
+
+    return false;
+  }
+
+  reconcile(model, options) {
+    if (model) {
+      const {childXform} = this;
+      model.forEach(childModel => {
+        childXform.reconcile(childModel, options);
+      });
+    }
+  }
+}
+
+module.exports = ListXform;

package/lib/xlsx/xform/pivot-table/cache-field.js

@@ -0,0 +1,74 @@
+class CacheField {
+  constructor({name, sharedItems}) {
+    // string type
+    //
+    // {
+    //   'name': 'A',
+    //   'sharedItems': ['a1', 'a2', 'a3']
+    // }
+    //
+    // or
+    //
+    // integer type
+    //
+    // {
+    //   'name': 'D',
+    //   'sharedItems': null
+    // }
+    this.name = name;
+    this.sharedItems = sharedItems;
+  }
+
+  // Helper function to escape XML special characters
+  escapeXml(unsafe) {
+    if (unsafe == null) return '';
+    return String(unsafe)
+      .replace(/&/g, '&')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&apos;');
+  }
+
+  render() {
+    // PivotCache Field: http://www.datypic.com/sc/ooxml/e-ssml_cacheField-1.html
+    // Shared Items: http://www.datypic.com/sc/ooxml/e-ssml_sharedItems-1.html
+
+    // integer types
+    if (this.sharedItems === null) {
+      // TK(2023-07-18): left out attributes... minValue="5" maxValue="45"
+      return `<cacheField name="${this.escapeXml(this.name)}" numFmtId="0">
+      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="1" />
+    </cacheField>`;
+    }
+
+    // Check if all items are truly numeric (typeof === 'number')
+    // String values like "03" that look numeric must use <s> tags,
+    // otherwise Excel will reject the pivot table when containsString="0"
+    // but string values are present.
+    const allNumeric = this.sharedItems.every(item => typeof item === 'number');
+
+    if (allNumeric) {
+      // numeric types - use <n> tags
+      const numbers = this.sharedItems.map(item => Number(item));
+      const minValue = Math.min(...numbers);
+      const maxValue = Math.max(...numbers);
+      const containsInteger = numbers.every(n => Number.isInteger(n));
+
+      return `<cacheField name="${this.escapeXml(this.name)}" numFmtId="0">
+      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="${containsInteger ? '1' : '0'}" minValue="${minValue}" maxValue="${maxValue}" count="${this.sharedItems.length}">
+        ${this.sharedItems.map(item => `<n v="${item}" />`).join('')}
+      </sharedItems>
+    </cacheField>`;
+    }
+
+    // string types
+    return `<cacheField name="${this.escapeXml(this.name)}" numFmtId="0">
+      <sharedItems count="${this.sharedItems.length}">
+        ${this.sharedItems.map(item => `<s v="${this.escapeXml(item)}" />`).join('')}
+      </sharedItems>
+    </cacheField>`;
+  }
+}
+
+module.exports = CacheField;

package/lib/xlsx/xform/pivot-table/pivot-cache-definition-xform.js

@@ -0,0 +1,77 @@
+const BaseXform = require('../base-xform');
+const CacheField = require('./cache-field');
+const XmlStream = require('../../../utils/xml-stream');
+
+class PivotCacheDefinitionXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {};
+  }
+
+  prepare(model) {
+    // TK
+  }
+
+  get tag() {
+    // http://www.datypic.com/sc/ooxml/e-ssml_pivotCacheDefinition.html
+    return 'pivotCacheDefinition';
+  }
+
+  render(xmlStream, model) {
+    const {sourceSheet, cacheFields, sourceDataRange} = model;
+
+    xmlStream.openXml(XmlStream.StdDocAttributes);
+    xmlStream.openNode(this.tag, {
+      ...PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES,
+      'r:id': 'rId1',
+      refreshOnLoad: '1', // important for our implementation to work
+      refreshedBy: 'Author',
+      refreshedDate: '45125.026046874998',
+      createdVersion: '8',
+      refreshedVersion: '8',
+      minRefreshableVersion: '3',
+      recordCount: cacheFields.length + 1,
+    });
+
+    xmlStream.openNode('cacheSource', {type: 'worksheet'});
+    xmlStream.leafNode('worksheetSource', {
+      ref: sourceDataRange || sourceSheet.dimensions.shortRange,
+      sheet: sourceSheet.name,
+    });
+    xmlStream.closeNode();
+
+    xmlStream.openNode('cacheFields', {count: cacheFields.length});
+    // Note: keeping this pretty-printed for now to ease debugging.
+    xmlStream.writeXml(cacheFields.map(cacheField => new CacheField(cacheField).render()).join('\n    '));
+    xmlStream.closeNode();
+
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    // TK
+  }
+
+  parseText(text) {
+    // TK
+  }
+
+  parseClose(name) {
+    // TK
+  }
+
+  reconcile(model, options) {
+    // TK
+  }
+}
+
+PivotCacheDefinitionXform.PIVOT_CACHE_DEFINITION_ATTRIBUTES = {
+  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',
+};
+
+module.exports = PivotCacheDefinitionXform;

package/lib/xlsx/xform/pivot-table/pivot-cache-records-xform.js

@@ -0,0 +1,107 @@
+const XmlStream = require('../../../utils/xml-stream');
+
+const BaseXform = require('../base-xform');
+
+class PivotCacheRecordsXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {};
+  }
+
+  prepare(model) {
+    // TK
+  }
+
+  get tag() {
+    // http://www.datypic.com/sc/ooxml/e-ssml_pivotCacheRecords.html
+    return 'pivotCacheRecords';
+  }
+
+  render(xmlStream, model) {
+    const {sourceSheet, cacheFields, dataStartRow = 2} = model;
+    const sourceBodyRows = sourceSheet.getSheetValues().slice(dataStartRow);
+
+    // Pre-build lookup maps for sharedItems to avoid O(n) findIndex on every cell
+    const sharedItemsMaps = cacheFields.map(cf => {
+      if (cf.sharedItems === null) return null;
+      const map = new Map();
+      for (let i = 0; i < cf.sharedItems.length; i++) {
+        const item = cf.sharedItems[i];
+        const key = typeof item === 'string' ? item.toLowerCase() : item;
+        if (!map.has(key)) {
+          map.set(key, i);
+        }
+      }
+      return map;
+    });
+
+    xmlStream.openXml(XmlStream.StdDocAttributes);
+    xmlStream.openNode(this.tag, {
+      ...PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES,
+      count: sourceBodyRows.length,
+    });
+    xmlStream.writeXml(renderTable());
+    xmlStream.closeNode();
+
+    // Helpers
+
+    function renderTable() {
+      const parts = [];
+      for (let rowIdx = 0; rowIdx < sourceBodyRows.length; rowIdx++) {
+        const row = sourceBodyRows[rowIdx];
+        if (!row) continue;
+        parts.push('\n  <r>');
+        for (let colIdx = 1; colIdx < row.length; colIdx++) {
+          const cellValue = row[colIdx];
+          const sharedItemsMap = sharedItemsMaps[colIdx - 1];
+
+          if (cellValue === null || cellValue === undefined) {
+            parts.push('\n    <m />');
+          } else if (sharedItemsMap === null) {
+            if (Number.isFinite(cellValue)) {
+              parts.push(`\n    <n v="${cellValue}" />`);
+            } else {
+              parts.push(`\n    <s v="${cellValue}" />`);
+            }
+          } else {
+            const key = typeof cellValue === 'string' ? cellValue.toLowerCase() : cellValue;
+            const sharedItemsIndex = sharedItemsMap.get(key);
+            if (sharedItemsIndex === undefined) {
+              throw new Error(`${JSON.stringify(cellValue)} not in sharedItems`);
+            }
+            parts.push(`\n    <x v="${sharedItemsIndex}" />`);
+          }
+        }
+        parts.push('\n  </r>');
+      }
+      return parts.join('');
+    }
+  }
+
+  parseOpen(node) {
+    // TK
+  }
+
+  parseText(text) {
+    // TK
+  }
+
+  parseClose(name) {
+    // TK
+  }
+
+  reconcile(model, options) {
+    // TK
+  }
+}
+
+PivotCacheRecordsXform.PIVOT_CACHE_RECORDS_ATTRIBUTES = {
+  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',
+};
+
+module.exports = PivotCacheRecordsXform;

package/lib/xlsx/xform/pivot-table/pivot-table-xform.js

@@ -0,0 +1,265 @@
+const {v4: uuidv4} = require('uuid');
+const colCache = require('../../../utils/col-cache');
+const XmlStream = require('../../../utils/xml-stream');
+const BaseXform = require('../base-xform');
+
+class PivotTableXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {};
+  }
+
+  prepare(model) {
+    // TK
+  }
+
+  get tag() {
+    // http://www.datypic.com/sc/ooxml/e-ssml_pivotTableDefinition.html
+    return 'pivotTableDefinition';
+  }
+
+  render(xmlStream, model) {
+    // eslint-disable-next-line no-unused-vars
+    const {
+      rows,
+      columns,
+      values,
+      pages = [],
+      pageDefaults = {},
+      metric,
+      cacheFields,
+      cacheId,
+      applyWidthHeightFormats,
+      startCell = 'A1',
+      valueNumFmt = null,
+    } = model;
+
+    // Examples
+    // --------
+    // rows: [0, 1], // only 2 items possible for now
+    // columns: [2], // only 1 item possible for now
+    // values: [4], // only 1 item possible for now
+    // pages: [5], // optional page fields
+    // pageDefaults: {5: 1}, // optional default selections (fieldIndex: itemIndex)
+    // metric: 'sum', // only 'sum' possible for now
+    //
+    // the numbers are indices into `cacheFields`.
+
+    // Generate unique UID for each pivot table
+    const uniqueUid = `{${uuidv4()}}`.toUpperCase();
+
+    xmlStream.openXml(XmlStream.StdDocAttributes);
+    xmlStream.openNode(this.tag, {
+      ...PivotTableXform.PIVOT_TABLE_ATTRIBUTES,
+      'xr:uid': uniqueUid,
+      name: 'PivotTable2',
+      cacheId,
+      applyNumberFormats: '0',
+      applyBorderFormats: '0',
+      applyFontFormats: '0',
+      applyPatternFormats: '0',
+      applyAlignmentFormats: '0',
+      applyWidthHeightFormats,
+      dataCaption: 'Values',
+      updatedVersion: '8',
+      minRefreshableVersion: '3',
+      useAutoFormatting: '1',
+      itemPrintTitles: '1',
+      createdVersion: '8',
+      indent: '0',
+      compact: '0',
+      compactData: '0',
+      multipleFieldFilters: '0',
+    });
+
+    // Note: keeping this pretty-printed and verbose for now to ease debugging.
+    //
+    // location: ref="A3:E15"
+    // pivotFields
+    // rowFields and rowItems
+    // colFields and colItems
+    // pageFields (if any)
+    // dataFields
+    // pivotTableStyleInfo
+    // Build location ref from startCell
+    // Default startCell is A1. The ref range will be expanded by Excel on refresh.
+    const startAddr = colCache.decodeAddress(startCell);
+    // Estimate end cell - Excel will recalculate on refresh with refreshOnLoad
+    const endCol = colCache.n2l(startAddr.col + columns.length + rows.length + values.length);
+    const endRow = startAddr.row + 10; // placeholder row count, Excel recalculates
+    const locationRef = `${startCell}:${endCol}${endRow}`;
+
+    const locationAttrs =
+      pages.length > 0
+        ? `ref="${locationRef}" firstHeaderRow="1" firstDataRow="3" firstDataCol="1" rowPageCount="1" colPageCount="1"`
+        : `ref="${locationRef}" firstHeaderRow="1" firstDataRow="2" firstDataCol="1"`;
+
+    xmlStream.writeXml(`
+      <location ${locationAttrs} />
+      <pivotFields count="${cacheFields.length}">
+        ${renderPivotFields(model)}
+      </pivotFields>
+      <rowFields count="${rows.length}">
+        ${rows.map(rowIndex => `<field x="${rowIndex}" />`).join('\n    ')}
+      </rowFields>
+      <rowItems count="1">
+        <i t="grand"><x /></i>
+      </rowItems>
+      <colFields count="${columns.length}">
+        ${columns.map(columnIndex => `<field x="${columnIndex}" />`).join('\n    ')}
+      </colFields>
+      <colItems count="1">
+        <i t="grand"><x /></i>
+      </colItems>
+      ${
+        pages.length > 0
+          ? `<pageFields count="${pages.length}">
+        ${pages.map(pageIndex => `<pageField fld="${pageIndex}" hier="-1" />`).join('\n    ')}
+      </pageFields>`
+          : ''
+      }
+      <dataFields count="${values.length}">
+        <dataField
+          name="${metric === 'count' ? 'Count' : 'Sum'} of ${cacheFields[values[0]].name}"
+          fld="${values[0]}"
+          baseField="0"
+          baseItem="0"
+          ${metric === 'count' ? 'subtotal="count"' : ''}
+          ${valueNumFmt ? `numFmtId="${valueNumFmt}"` : ''}
+        />
+      </dataFields>
+      <pivotTableStyleInfo
+        name="PivotStyleLight16"
+        showRowHeaders="1"
+        showColHeaders="1"
+        showRowStripes="0"
+        showColStripes="0"
+        showLastColumn="1"
+      />
+      <extLst>
+        <ext
+          uri="{962EF5D1-5CA2-4c93-8EF4-DBF5C05439D2}"
+          xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"
+        >
+          <x14:pivotTableDefinition
+            hideValuesRow="1"
+            xmlns:xm="http://schemas.microsoft.com/office/excel/2006/main"
+          />
+        </ext>
+        <ext
+          uri="{747A6164-185A-40DC-8AA5-F01512510D54}"
+          xmlns:xpdl="http://schemas.microsoft.com/office/spreadsheetml/2016/pivotdefaultlayout"
+        >
+          <xpdl:pivotTableDefinition16
+            EnabledSubtotalsDefault="0"
+            SubtotalsOnTopDefault="0"
+          />
+        </ext>
+      </extLst>
+    `);
+
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    // TK
+  }
+
+  parseText(text) {
+    // TK
+  }
+
+  parseClose(name) {
+    // TK
+  }
+
+  reconcile(model, options) {
+    // TK
+  }
+}
+
+// Helpers
+
+function renderPivotFields(pivotTable) {
+  /* eslint-disable no-nested-ternary */
+  const pages = pivotTable.pages || [];
+  const pageDefaults = pivotTable.pageDefaults || {};
+
+  return pivotTable.cacheFields
+    .map((cacheField, fieldIndex) => {
+      const fieldType =
+        pivotTable.rows.indexOf(fieldIndex) >= 0
+          ? 'row'
+          : pivotTable.columns.indexOf(fieldIndex) >= 0
+            ? 'column'
+            : pages.indexOf(fieldIndex) >= 0
+              ? 'page'
+              : pivotTable.values.indexOf(fieldIndex) >= 0
+                ? 'value'
+                : null;
+
+      const defaultItemIndex = fieldType === 'page' ? pageDefaults[fieldIndex] : undefined;
+      return renderPivotField(fieldType, cacheField.sharedItems, defaultItemIndex);
+    })
+    .join('');
+}
+
+function renderPivotField(fieldType, sharedItems, defaultItemIndex) {
+  // fieldType: 'row', 'column', 'page', 'value', null
+
+  const defaultAttributes = 'compact="0" outline="0" showAll="0" defaultSubtotal="0"';
+
+  if (fieldType === 'row' || fieldType === 'column') {
+    const axis = fieldType === 'row' ? 'axisRow' : 'axisCol';
+    return `
+      <pivotField axis="${axis}" ${defaultAttributes}>
+        <items count="${sharedItems.length + 1}">
+          ${sharedItems.map((item, index) => `<item x="${index}" />`).join('\n              ')}
+        </items>
+      </pivotField>
+    `;
+  }
+
+  if (fieldType === 'page') {
+    // Page fields use axis="axisPage" and items with hidden flags
+    if (defaultItemIndex !== undefined && sharedItems) {
+      return `
+      <pivotField axis="axisPage" compact="0" outline="0" subtotalTop="0" multipleItemSelectionAllowed="1" showAll="0" defaultSubtotal="0">
+        <items count="${sharedItems.length}">
+          ${sharedItems
+            .map((item, index) => {
+              const hidden = index !== defaultItemIndex ? ' h="1"' : '';
+              return `<item${hidden} x="${index}" />`;
+            })
+            .join('\n              ')}
+        </items>
+      </pivotField>
+    `;
+    }
+    // Page field without default selection
+    return `
+    <pivotField axis="axisPage" ${defaultAttributes}>
+      <items count="${sharedItems ? sharedItems.length : 1}">
+        ${sharedItems ? sharedItems.map((item, index) => `<item x="${index}" />`).join('\n              ') : ''}
+      </items>
+    </pivotField>
+  `;
+  }
+
+  return `
+    <pivotField
+      ${fieldType === 'value' ? 'dataField="1"' : ''}
+      ${defaultAttributes}
+    />
+  `;
+}
+
+PivotTableXform.PIVOT_TABLE_ATTRIBUTES = {
+  xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+  'xmlns:mc': 'http://schemas.openxmlformats.org/markup-compatibility/2006',
+  'mc:Ignorable': 'xr',
+  'xmlns:xr': 'http://schemas.microsoft.com/office/spreadsheetml/2014/revision',
+};
+
+module.exports = PivotTableXform;