@alienkarma/exceljs 4.4.0-fork.1

package/lib/xlsx/xform/drawing/ext-lst-xform.js

@@ -0,0 +1,43 @@
+const BaseXform = require('../base-xform');
+
+class ExtLstXform extends BaseXform {
+  get tag() {
+    return 'a:extLst';
+  }
+
+  render(xmlStream) {
+    xmlStream.openNode(this.tag);
+    xmlStream.openNode('a:ext', {
+      uri: '{FF2B5EF4-FFF2-40B4-BE49-F238E27FC236}',
+    });
+    xmlStream.leafNode('a16:creationId', {
+      'xmlns:a16': 'http://schemas.microsoft.com/office/drawing/2014/main',
+      id: '{00000000-0008-0000-0000-000002000000}',
+    });
+    xmlStream.closeNode();
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        return true;
+      default:
+        return true;
+    }
+  }
+
+  parseText() {}
+
+  parseClose(name) {
+    switch (name) {
+      case this.tag:
+        return false;
+      default:
+        // unprocessed internal nodes
+        return true;
+    }
+  }
+}
+
+module.exports = ExtLstXform;

package/lib/xlsx/xform/drawing/ext-xform.js

@@ -0,0 +1,44 @@
+const BaseXform = require('../base-xform');
+
+/** https://en.wikipedia.org/wiki/Office_Open_XML_file_formats#DrawingML */
+const EMU_PER_PIXEL_AT_96_DPI = 9525;
+
+class ExtXform extends BaseXform {
+  constructor(options) {
+    super();
+
+    this.tag = options.tag;
+    this.map = {};
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag);
+
+    const width = Math.floor(model.width * EMU_PER_PIXEL_AT_96_DPI);
+    const height = Math.floor(model.height * EMU_PER_PIXEL_AT_96_DPI);
+
+    xmlStream.addAttribute('cx', width);
+    xmlStream.addAttribute('cy', height);
+
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    if (node.name === this.tag) {
+      this.model = {
+        width: parseInt(node.attributes.cx || '0', 10) / EMU_PER_PIXEL_AT_96_DPI,
+        height: parseInt(node.attributes.cy || '0', 10) / EMU_PER_PIXEL_AT_96_DPI,
+      };
+      return true;
+    }
+    return false;
+  }
+
+  parseText(/* text */) {}
+
+  parseClose(/* name */) {
+    return false;
+  }
+}
+
+module.exports = ExtXform;

package/lib/xlsx/xform/drawing/hlink-click-xform.js

@@ -0,0 +1,41 @@
+const BaseXform = require('../base-xform');
+
+class HLinkClickXform extends BaseXform {
+  get tag() {
+    return 'a:hlinkClick';
+  }
+
+  render(xmlStream, model) {
+    if (!(model.hyperlinks && model.hyperlinks.rId)) {
+      return;
+    }
+    xmlStream.leafNode(this.tag, {
+      'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+      'r:id': model.hyperlinks.rId,
+      tooltip: model.hyperlinks.tooltip,
+    });
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.model = {
+          hyperlinks: {
+            rId: node.attributes['r:id'],
+            tooltip: node.attributes.tooltip,
+          },
+        };
+        return true;
+      default:
+        return true;
+    }
+  }
+
+  parseText() {}
+
+  parseClose() {
+    return false;
+  }
+}
+
+module.exports = HLinkClickXform;

package/lib/xlsx/xform/drawing/nv-pic-pr-xform.js

@@ -0,0 +1,65 @@
+const BaseXform = require('../base-xform');
+const CNvPrXform = require('./c-nv-pr-xform');
+const CNvPicPrXform = require('./c-nv-pic-pr-xform');
+
+class NvPicPrXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {
+      'xdr:cNvPr': new CNvPrXform(),
+      'xdr:cNvPicPr': new CNvPicPrXform(),
+    };
+  }
+
+  get tag() {
+    return 'xdr:nvPicPr';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag);
+    this.map['xdr:cNvPr'].render(xmlStream, model);
+    this.map['xdr:cNvPicPr'].render(xmlStream, model);
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+
+    switch (node.name) {
+      case this.tag:
+        this.reset();
+        break;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+        }
+        break;
+    }
+    return true;
+  }
+
+  parseText() {}
+
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.parser = undefined;
+      }
+      return true;
+    }
+    switch (name) {
+      case this.tag:
+        this.model = this.map['xdr:cNvPr'].model;
+        return false;
+      default:
+        return true;
+    }
+  }
+}
+
+module.exports = NvPicPrXform;

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

@@ -0,0 +1,63 @@
+const BaseCellAnchorXform = require('./base-cell-anchor-xform');
+const StaticXform = require('../static-xform');
+
+const CellPositionXform = require('./cell-position-xform');
+const ExtXform = require('./ext-xform');
+const PicXform = require('./pic-xform');
+
+class OneCellAnchorXform extends BaseCellAnchorXform {
+  constructor() {
+    super();
+
+    this.map = {
+      'xdr:from': new CellPositionXform({tag: 'xdr:from'}),
+      'xdr:ext': new ExtXform({tag: 'xdr:ext'}),
+      'xdr:pic': new PicXform(),
+      'xdr:clientData': new StaticXform({tag: 'xdr:clientData'}),
+    };
+  }
+
+  get tag() {
+    return 'xdr:oneCellAnchor';
+  }
+
+  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:ext'].render(xmlStream, model.range.ext);
+    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.ext = this.map['xdr:ext'].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 = OneCellAnchorXform;

package/lib/xlsx/xform/drawing/pic-xform.js

@@ -0,0 +1,77 @@
+const BaseXform = require('../base-xform');
+const StaticXform = require('../static-xform');
+
+const BlipFillXform = require('./blip-fill-xform');
+const NvPicPrXform = require('./nv-pic-pr-xform');
+
+const spPrJSON = require('./sp-pr');
+
+class PicXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {
+      'xdr:nvPicPr': new NvPicPrXform(),
+      'xdr:blipFill': new BlipFillXform(),
+      'xdr:spPr': new StaticXform(spPrJSON),
+    };
+  }
+
+  get tag() {
+    return 'xdr:pic';
+  }
+
+  prepare(model, options) {
+    model.index = options.index + 1;
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag);
+
+    this.map['xdr:nvPicPr'].render(xmlStream, model);
+    this.map['xdr:blipFill'].render(xmlStream, model);
+    this.map['xdr:spPr'].render(xmlStream, model);
+
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.tag:
+        this.reset();
+        break;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+        }
+        break;
+    }
+    return true;
+  }
+
+  parseText() {}
+
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.mergeModel(this.parser.model);
+        this.parser = undefined;
+      }
+      return true;
+    }
+    switch (name) {
+      case this.tag:
+        return false;
+      default:
+        // not quite sure how we get here!
+        return true;
+    }
+  }
+}
+
+module.exports = PicXform;

package/lib/xlsx/xform/drawing/sp-pr.js

@@ -0,0 +1,17 @@
+module.exports = {
+  tag: 'xdr:spPr',
+  c: [
+    {
+      tag: 'a:xfrm',
+      c: [
+        {tag: 'a:off', $: {x: '0', y: '0'}},
+        {tag: 'a:ext', $: {cx: '0', cy: '0'}},
+      ],
+    },
+    {
+      tag: 'a:prstGeom',
+      $: {prst: 'rect'},
+      c: [{tag: 'a:avLst'}],
+    },
+  ],
+};

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,43 @@
+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;
+  }
+
+  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.name}" numFmtId="0">
+      <sharedItems containsSemiMixedTypes="0" containsString="0" containsNumber="1" containsInteger="1" />
+    </cacheField>`;
+    }
+
+    // string types
+    return `<cacheField name="${this.name}" numFmtId="0">
+      <sharedItems count="${this.sharedItems.length}">
+        ${this.sharedItems.map(item => `<s v="${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} = 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: 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;