@alienkarma/exceljs 4.4.0-fork.1

package/lib/xlsx/xform/sheet/data-validations-xform.js

@@ -0,0 +1,257 @@
+const _ = require('../../../utils/under-dash');
+const utils = require('../../../utils/utils');
+const colCache = require('../../../utils/col-cache');
+const BaseXform = require('../base-xform');
+const Range = require('../../../doc/range');
+
+function assign(definedName, attributes, name, defaultValue) {
+  const value = attributes[name];
+  if (value !== undefined) {
+    definedName[name] = value;
+  } else if (defaultValue !== undefined) {
+    definedName[name] = defaultValue;
+  }
+}
+
+function assignBool(definedName, attributes, name, defaultValue) {
+  const value = attributes[name];
+  if (value !== undefined) {
+    definedName[name] = utils.parseBoolean(value);
+  } else if (defaultValue !== undefined) {
+    definedName[name] = defaultValue;
+  }
+}
+
+function optimiseDataValidations(model) {
+  // Squeeze alike data validations together into rectangular ranges
+  // to reduce file size and speed up Excel load time
+  const dvList = _.map(model, (dataValidation, address) => ({
+    address,
+    dataValidation,
+    marked: false,
+  })).sort((a, b) => _.strcmp(a.address, b.address));
+  const dvMap = _.keyBy(dvList, 'address');
+  const matchCol = (addr, height, col) => {
+    for (let i = 0; i < height; i++) {
+      const otherAddress = colCache.encodeAddress(addr.row + i, col);
+      if (!model[otherAddress] || !_.isEqual(model[addr.address], model[otherAddress])) {
+        return false;
+      }
+    }
+    return true;
+  };
+  return dvList
+    .map(dv => {
+      if (!dv.marked) {
+        const addr = colCache.decodeEx(dv.address);
+        if (addr.dimensions) {
+          dvMap[addr.dimensions].marked = true;
+          return {
+            ...dv.dataValidation,
+            sqref: dv.address,
+          };
+        }
+
+        // iterate downwards - finding matching cells
+        let height = 1;
+        let otherAddress = colCache.encodeAddress(addr.row + height, addr.col);
+        while (model[otherAddress] && _.isEqual(dv.dataValidation, model[otherAddress])) {
+          height++;
+          otherAddress = colCache.encodeAddress(addr.row + height, addr.col);
+        }
+
+        // iterate rightwards...
+
+        let width = 1;
+        while (matchCol(addr, height, addr.col + width)) {
+          width++;
+        }
+
+        // mark all included addresses
+        for (let i = 0; i < height; i++) {
+          for (let j = 0; j < width; j++) {
+            otherAddress = colCache.encodeAddress(addr.row + i, addr.col + j);
+            dvMap[otherAddress].marked = true;
+          }
+        }
+
+        if (height > 1 || width > 1) {
+          const bottom = addr.row + (height - 1);
+          const right = addr.col + (width - 1);
+          return {
+            ...dv.dataValidation,
+            sqref: `${dv.address}:${colCache.encodeAddress(bottom, right)}`,
+          };
+        }
+        return {
+          ...dv.dataValidation,
+          sqref: dv.address,
+        };
+      }
+      return null;
+    })
+    .filter(Boolean);
+}
+
+class DataValidationsXform extends BaseXform {
+  get tag() {
+    return 'dataValidations';
+  }
+
+  render(xmlStream, model) {
+    const optimizedModel = optimiseDataValidations(model);
+    if (optimizedModel.length) {
+      xmlStream.openNode('dataValidations', {count: optimizedModel.length});
+
+      optimizedModel.forEach(value => {
+        xmlStream.openNode('dataValidation');
+
+        if (value.type !== 'any') {
+          xmlStream.addAttribute('type', value.type);
+
+          if (value.operator && value.type !== 'list' && value.operator !== 'between') {
+            xmlStream.addAttribute('operator', value.operator);
+          }
+          if (value.allowBlank) {
+            xmlStream.addAttribute('allowBlank', '1');
+          }
+        }
+        if (value.showInputMessage) {
+          xmlStream.addAttribute('showInputMessage', '1');
+        }
+        if (value.promptTitle) {
+          xmlStream.addAttribute('promptTitle', value.promptTitle);
+        }
+        if (value.prompt) {
+          xmlStream.addAttribute('prompt', value.prompt);
+        }
+        if (value.showErrorMessage) {
+          xmlStream.addAttribute('showErrorMessage', '1');
+        }
+        if (value.errorStyle) {
+          xmlStream.addAttribute('errorStyle', value.errorStyle);
+        }
+        if (value.errorTitle) {
+          xmlStream.addAttribute('errorTitle', value.errorTitle);
+        }
+        if (value.error) {
+          xmlStream.addAttribute('error', value.error);
+        }
+        xmlStream.addAttribute('sqref', value.sqref);
+        (value.formulae || []).forEach((formula, index) => {
+          xmlStream.openNode(`formula${index + 1}`);
+          if (value.type === 'date') {
+            xmlStream.writeText(utils.dateToExcel(new Date(formula)));
+          } else {
+            xmlStream.writeText(formula);
+          }
+          xmlStream.closeNode();
+        });
+        xmlStream.closeNode();
+      });
+      xmlStream.closeNode();
+    }
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case 'dataValidations':
+        this.model = {};
+        return true;
+
+      case 'dataValidation': {
+        this._address = node.attributes.sqref;
+        const dataValidation = {type: node.attributes.type || 'any', formulae: []};
+
+        if (node.attributes.type) {
+          assignBool(dataValidation, node.attributes, 'allowBlank');
+        }
+        assignBool(dataValidation, node.attributes, 'showInputMessage');
+        assignBool(dataValidation, node.attributes, 'showErrorMessage');
+
+        switch (dataValidation.type) {
+          case 'any':
+          case 'list':
+          case 'custom':
+            break;
+          default:
+            assign(dataValidation, node.attributes, 'operator', 'between');
+            break;
+        }
+        assign(dataValidation, node.attributes, 'promptTitle');
+        assign(dataValidation, node.attributes, 'prompt');
+        assign(dataValidation, node.attributes, 'errorStyle');
+        assign(dataValidation, node.attributes, 'errorTitle');
+        assign(dataValidation, node.attributes, 'error');
+
+        this._dataValidation = dataValidation;
+        return true;
+      }
+
+      case 'formula1':
+      case 'formula2':
+        this._formula = [];
+        return true;
+
+      default:
+        return false;
+    }
+  }
+
+  parseText(text) {
+    if (this._formula) {
+      this._formula.push(text);
+    }
+  }
+
+  parseClose(name) {
+    switch (name) {
+      case 'dataValidations':
+        return false;
+      case 'dataValidation': {
+        if (!this._dataValidation.formulae || !this._dataValidation.formulae.length) {
+          delete this._dataValidation.formulae;
+          delete this._dataValidation.operator;
+        }
+        // The four known cases: 1. E4:L9 N4:U9  2.E4 L9  3. N4:U9  4. E4
+        const list = this._address.split(/\s+/g) || [];
+        list.forEach(addr => {
+          if (addr.includes(':')) {
+            const range = new Range(addr);
+            range.forEachAddress(address => {
+              this.model[address] = this._dataValidation;
+            });
+          } else {
+            this.model[addr] = this._dataValidation;
+          }
+        });
+        return true;
+      }
+      case 'formula1':
+      case 'formula2': {
+        let formula = this._formula.join('');
+        switch (this._dataValidation.type) {
+          case 'whole':
+          case 'textLength':
+            formula = parseInt(formula, 10);
+            break;
+          case 'decimal':
+            formula = parseFloat(formula);
+            break;
+          case 'date':
+            formula = utils.excelToDate(parseFloat(formula));
+            break;
+          default:
+            break;
+        }
+        this._dataValidation.formulae.push(formula);
+        this._formula = undefined;
+        return true;
+      }
+      default:
+        return true;
+    }
+  }
+}
+
+module.exports = DataValidationsXform;

package/lib/xlsx/xform/sheet/dimension-xform.js

@@ -0,0 +1,29 @@
+const BaseXform = require('../base-xform');
+
+class DimensionXform extends BaseXform {
+  get tag() {
+    return 'dimension';
+  }
+
+  render(xmlStream, model) {
+    if (model) {
+      xmlStream.leafNode('dimension', {ref: model});
+    }
+  }
+
+  parseOpen(node) {
+    if (node.name === 'dimension') {
+      this.model = node.attributes.ref;
+      return true;
+    }
+    return false;
+  }
+
+  parseText() {}
+
+  parseClose() {
+    return false;
+  }
+}
+
+module.exports = DimensionXform;

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

@@ -0,0 +1,33 @@
+const BaseXform = require('../base-xform');
+
+class DrawingXform extends BaseXform {
+  get tag() {
+    return 'drawing';
+  }
+
+  render(xmlStream, model) {
+    if (model) {
+      xmlStream.leafNode(this.tag, {'r:id': model.rId});
+    }
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.model = {
+          rId: node.attributes['r:id'],
+        };
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  parseText() {}
+
+  parseClose() {
+    return false;
+  }
+}
+
+module.exports = DrawingXform;

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

@@ -0,0 +1,86 @@
+/* eslint-disable max-classes-per-file */
+const CompositeXform = require('../composite-xform');
+
+const ConditionalFormattingsExt = require('./cf-ext/conditional-formattings-ext-xform');
+
+class ExtXform extends CompositeXform {
+  constructor() {
+    super();
+    this.map = {
+      'x14:conditionalFormattings': (this.conditionalFormattings = new ConditionalFormattingsExt()),
+    };
+  }
+
+  get tag() {
+    return 'ext';
+  }
+
+  hasContent(model) {
+    return this.conditionalFormattings.hasContent(model.conditionalFormattings);
+  }
+
+  prepare(model, options) {
+    this.conditionalFormattings.prepare(model.conditionalFormattings, options);
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode('ext', {
+      uri: '{78C0D931-6437-407d-A8EE-F0AAD7539E65}',
+      'xmlns:x14': 'http://schemas.microsoft.com/office/spreadsheetml/2009/9/main',
+    });
+
+    this.conditionalFormattings.render(xmlStream, model.conditionalFormattings);
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel() {
+    return {};
+  }
+
+  onParserClose(name, parser) {
+    this.model[name] = parser.model;
+  }
+}
+
+class ExtLstXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      ext: (this.ext = new ExtXform()),
+    };
+  }
+
+  get tag() {
+    return 'extLst';
+  }
+
+  prepare(model, options) {
+    this.ext.prepare(model, options);
+  }
+
+  hasContent(model) {
+    return this.ext.hasContent(model);
+  }
+
+  render(xmlStream, model) {
+    if (!this.hasContent(model)) {
+      return;
+    }
+
+    xmlStream.openNode('extLst');
+    this.ext.render(xmlStream, model);
+    xmlStream.closeNode();
+  }
+
+  createNewModel() {
+    return {};
+  }
+
+  onParserClose(name, parser) {
+    Object.assign(this.model, parser.model);
+  }
+}
+
+module.exports = ExtLstXform;

package/lib/xlsx/xform/sheet/header-footer-xform.js

@@ -0,0 +1,146 @@
+const BaseXform = require('../base-xform');
+
+class HeaderFooterXform extends BaseXform {
+  get tag() {
+    return 'headerFooter';
+  }
+
+  render(xmlStream, model) {
+    if (model) {
+      xmlStream.addRollback();
+
+      let createTag = false;
+
+      xmlStream.openNode('headerFooter');
+      if (model.differentFirst) {
+        xmlStream.addAttribute('differentFirst', '1');
+        createTag = true;
+      }
+      if (model.differentOddEven) {
+        xmlStream.addAttribute('differentOddEven', '1');
+        createTag = true;
+      }
+      if (model.oddHeader && typeof model.oddHeader === 'string') {
+        xmlStream.leafNode('oddHeader', null, model.oddHeader);
+        createTag = true;
+      }
+      if (model.oddFooter && typeof model.oddFooter === 'string') {
+        xmlStream.leafNode('oddFooter', null, model.oddFooter);
+        createTag = true;
+      }
+      if (model.evenHeader && typeof model.evenHeader === 'string') {
+        xmlStream.leafNode('evenHeader', null, model.evenHeader);
+        createTag = true;
+      }
+      if (model.evenFooter && typeof model.evenFooter === 'string') {
+        xmlStream.leafNode('evenFooter', null, model.evenFooter);
+        createTag = true;
+      }
+      if (model.firstHeader && typeof model.firstHeader === 'string') {
+        xmlStream.leafNode('firstHeader', null, model.firstHeader);
+        createTag = true;
+      }
+      if (model.firstFooter && typeof model.firstFooter === 'string') {
+        xmlStream.leafNode('firstFooter', null, model.firstFooter);
+        createTag = true;
+      }
+
+      if (createTag) {
+        xmlStream.closeNode();
+        xmlStream.commit();
+      } else {
+        xmlStream.rollback();
+      }
+    }
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case 'headerFooter':
+        this.model = {};
+        if (node.attributes.differentFirst) {
+          this.model.differentFirst = parseInt(node.attributes.differentFirst, 0) === 1;
+        }
+        if (node.attributes.differentOddEven) {
+          this.model.differentOddEven = parseInt(node.attributes.differentOddEven, 0) === 1;
+        }
+        return true;
+
+      case 'oddHeader':
+        this.currentNode = 'oddHeader';
+        return true;
+
+      case 'oddFooter':
+        this.currentNode = 'oddFooter';
+        return true;
+
+      case 'evenHeader':
+        this.currentNode = 'evenHeader';
+        return true;
+
+      case 'evenFooter':
+        this.currentNode = 'evenFooter';
+        return true;
+
+      case 'firstHeader':
+        this.currentNode = 'firstHeader';
+        return true;
+
+      case 'firstFooter':
+        this.currentNode = 'firstFooter';
+        return true;
+
+      default:
+        return false;
+    }
+  }
+
+  parseText(text) {
+    switch (this.currentNode) {
+      case 'oddHeader':
+        this.model.oddHeader = text;
+        break;
+
+      case 'oddFooter':
+        this.model.oddFooter = text;
+        break;
+
+      case 'evenHeader':
+        this.model.evenHeader = text;
+        break;
+
+      case 'evenFooter':
+        this.model.evenFooter = text;
+        break;
+
+      case 'firstHeader':
+        this.model.firstHeader = text;
+        break;
+
+      case 'firstFooter':
+        this.model.firstFooter = text;
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  parseClose() {
+    switch (this.currentNode) {
+      case 'oddHeader':
+      case 'oddFooter':
+      case 'evenHeader':
+      case 'evenFooter':
+      case 'firstHeader':
+      case 'firstFooter':
+        this.currentNode = undefined;
+        return true;
+
+      default:
+        return false;
+    }
+  }
+}
+
+module.exports = HeaderFooterXform;

package/lib/xlsx/xform/sheet/hyperlink-xform.js

@@ -0,0 +1,54 @@
+const BaseXform = require('../base-xform');
+
+class HyperlinkXform extends BaseXform {
+  get tag() {
+    return 'hyperlink';
+  }
+
+  render(xmlStream, model) {
+    if (this.isInternalLink(model)) {
+      xmlStream.leafNode('hyperlink', {
+        ref: model.address,
+        'r:id': model.rId,
+        tooltip: model.tooltip,
+        location: model.target,
+      });
+    } else {
+      xmlStream.leafNode('hyperlink', {
+        ref: model.address,
+        'r:id': model.rId,
+        tooltip: model.tooltip,
+      });
+    }
+  }
+
+  parseOpen(node) {
+    if (node.name === 'hyperlink') {
+      this.model = {
+        address: node.attributes.ref,
+        rId: node.attributes['r:id'],
+        tooltip: node.attributes.tooltip,
+      };
+
+      // This is an internal link
+      if (node.attributes.location) {
+        this.model.target = node.attributes.location;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  parseText() {}
+
+  parseClose() {
+    return false;
+  }
+
+  isInternalLink(model) {
+    // @example: Sheet2!D3, return true
+    return model.target && /^[^!]+![a-zA-Z]+[\d]+$/.test(model.target);
+  }
+}
+
+module.exports = HyperlinkXform;

package/lib/xlsx/xform/sheet/merge-cell-xform.js

@@ -0,0 +1,27 @@
+const BaseXform = require('../base-xform');
+
+class MergeCellXform extends BaseXform {
+  get tag() {
+    return 'mergeCell';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.leafNode('mergeCell', {ref: model});
+  }
+
+  parseOpen(node) {
+    if (node.name === 'mergeCell') {
+      this.model = node.attributes.ref;
+      return true;
+    }
+    return false;
+  }
+
+  parseText() {}
+
+  parseClose() {
+    return false;
+  }
+}
+
+module.exports = MergeCellXform;

package/lib/xlsx/xform/sheet/merges.js

@@ -0,0 +1,56 @@
+const _ = require('../../../utils/under-dash');
+
+const Range = require('../../../doc/range');
+const colCache = require('../../../utils/col-cache');
+const Enums = require('../../../doc/enums');
+
+class Merges {
+  constructor() {
+    // optional mergeCells is array of ranges (like the xml)
+    this.merges = {};
+  }
+
+  add(merge) {
+    // merge is {address, master}
+    if (this.merges[merge.master]) {
+      this.merges[merge.master].expandToAddress(merge.address);
+    } else {
+      const range = `${merge.master}:${merge.address}`;
+      this.merges[merge.master] = new Range(range);
+    }
+  }
+
+  get mergeCells() {
+    return _.map(this.merges, merge => merge.range);
+  }
+
+  reconcile(mergeCells, rows) {
+    // reconcile merge list with merge cells
+    _.each(mergeCells, merge => {
+      const dimensions = colCache.decode(merge);
+      for (let i = dimensions.top; i <= dimensions.bottom; i++) {
+        const row = rows[i - 1];
+        for (let j = dimensions.left; j <= dimensions.right; j++) {
+          const cell = row.cells[j - 1];
+          if (!cell) {
+            // nulls are not included in document - so if master cell has no value - add a null one here
+            row.cells[j] = {
+              type: Enums.ValueType.Null,
+              address: colCache.encodeAddress(i, j),
+            };
+          } else if (cell.type === Enums.ValueType.Merge) {
+            cell.master = dimensions.tl;
+          }
+        }
+      }
+    });
+  }
+
+  getMasterAddress(address) {
+    // if address has been merged, return its master's address. Assumes reconcile has been called
+    const range = this.hash[address];
+    return range && range.tl;
+  }
+}
+
+module.exports = Merges;