@alienkarma/exceljs 4.4.0-fork.1

package/lib/xlsx/xform/sheet/cf/cf-rule-xform.js

@@ -0,0 +1,301 @@
+const BaseXform = require('../../base-xform');
+const CompositeXform = require('../../composite-xform');
+
+const Range = require('../../../../doc/range');
+
+const DatabarXform = require('./databar-xform');
+const ExtLstRefXform = require('./ext-lst-ref-xform');
+const FormulaXform = require('./formula-xform');
+const ColorScaleXform = require('./color-scale-xform');
+const IconSetXform = require('./icon-set-xform');
+
+const extIcons = {
+  '3Triangles': true,
+  '3Stars': true,
+  '5Boxes': true,
+};
+
+const getTextFormula = model => {
+  if (model.formulae && model.formulae[0]) {
+    return model.formulae[0];
+  }
+
+  const range = new Range(model.ref);
+  const {tl} = range;
+  switch (model.operator) {
+    case 'containsText':
+      return `NOT(ISERROR(SEARCH("${model.text}",${tl})))`;
+    case 'containsBlanks':
+      return `LEN(TRIM(${tl}))=0`;
+    case 'notContainsBlanks':
+      return `LEN(TRIM(${tl}))>0`;
+    case 'containsErrors':
+      return `ISERROR(${tl})`;
+    case 'notContainsErrors':
+      return `NOT(ISERROR(${tl}))`;
+    default:
+      return undefined;
+  }
+};
+
+const getTimePeriodFormula = model => {
+  if (model.formulae && model.formulae[0]) {
+    return model.formulae[0];
+  }
+
+  const range = new Range(model.ref);
+  const {tl} = range;
+  switch (model.timePeriod) {
+    case 'thisWeek':
+      return `AND(TODAY()-ROUNDDOWN(${tl},0)<=WEEKDAY(TODAY())-1,ROUNDDOWN(${tl},0)-TODAY()<=7-WEEKDAY(TODAY()))`;
+    case 'lastWeek':
+      return `AND(TODAY()-ROUNDDOWN(${tl},0)>=(WEEKDAY(TODAY())),TODAY()-ROUNDDOWN(${tl},0)<(WEEKDAY(TODAY())+7))`;
+    case 'nextWeek':
+      return `AND(ROUNDDOWN(${tl},0)-TODAY()>(7-WEEKDAY(TODAY())),ROUNDDOWN(${tl},0)-TODAY()<(15-WEEKDAY(TODAY())))`;
+    case 'yesterday':
+      return `FLOOR(${tl},1)=TODAY()-1`;
+    case 'today':
+      return `FLOOR(${tl},1)=TODAY()`;
+    case 'tomorrow':
+      return `FLOOR(${tl},1)=TODAY()+1`;
+    case 'last7Days':
+      return `AND(TODAY()-FLOOR(${tl},1)<=6,FLOOR(${tl},1)<=TODAY())`;
+    case 'lastMonth':
+      return `AND(MONTH(${tl})=MONTH(EDATE(TODAY(),0-1)),YEAR(${tl})=YEAR(EDATE(TODAY(),0-1)))`;
+    case 'thisMonth':
+      return `AND(MONTH(${tl})=MONTH(TODAY()),YEAR(${tl})=YEAR(TODAY()))`;
+    case 'nextMonth':
+      return `AND(MONTH(${tl})=MONTH(EDATE(TODAY(),0+1)),YEAR(${tl})=YEAR(EDATE(TODAY(),0+1)))`;
+    default:
+      return undefined;
+  }
+};
+
+const opType = attributes => {
+  const {type, operator} = attributes;
+  switch (type) {
+    case 'containsText':
+    case 'containsBlanks':
+    case 'notContainsBlanks':
+    case 'containsErrors':
+    case 'notContainsErrors':
+      return {
+        type: 'containsText',
+        operator: type,
+      };
+
+    default:
+      return {type, operator};
+  }
+};
+
+class CfRuleXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      dataBar: (this.databarXform = new DatabarXform()),
+      extLst: (this.extLstRefXform = new ExtLstRefXform()),
+      formula: (this.formulaXform = new FormulaXform()),
+      colorScale: (this.colorScaleXform = new ColorScaleXform()),
+      iconSet: (this.iconSetXform = new IconSetXform()),
+    };
+  }
+
+  get tag() {
+    return 'cfRule';
+  }
+
+  static isPrimitive(rule) {
+    // is this rule primitive?
+    if (rule.type === 'iconSet') {
+      if (rule.custom || extIcons[rule.iconSet]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  render(xmlStream, model) {
+    switch (model.type) {
+      case 'expression':
+        this.renderExpression(xmlStream, model);
+        break;
+      case 'cellIs':
+        this.renderCellIs(xmlStream, model);
+        break;
+      case 'top10':
+        this.renderTop10(xmlStream, model);
+        break;
+      case 'aboveAverage':
+        this.renderAboveAverage(xmlStream, model);
+        break;
+      case 'dataBar':
+        this.renderDataBar(xmlStream, model);
+        break;
+      case 'colorScale':
+        this.renderColorScale(xmlStream, model);
+        break;
+      case 'iconSet':
+        this.renderIconSet(xmlStream, model);
+        break;
+      case 'containsText':
+        this.renderText(xmlStream, model);
+        break;
+      case 'timePeriod':
+        this.renderTimePeriod(xmlStream, model);
+        break;
+    }
+  }
+
+  renderExpression(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      type: 'expression',
+      dxfId: model.dxfId,
+      priority: model.priority,
+    });
+
+    this.formulaXform.render(xmlStream, model.formulae[0]);
+
+    xmlStream.closeNode();
+  }
+
+  renderCellIs(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      type: 'cellIs',
+      dxfId: model.dxfId,
+      priority: model.priority,
+      operator: model.operator,
+    });
+
+    model.formulae.forEach(formula => {
+      this.formulaXform.render(xmlStream, formula);
+    });
+
+    xmlStream.closeNode();
+  }
+
+  renderTop10(xmlStream, model) {
+    xmlStream.leafNode(this.tag, {
+      type: 'top10',
+      dxfId: model.dxfId,
+      priority: model.priority,
+      percent: BaseXform.toBoolAttribute(model.percent, false),
+      bottom: BaseXform.toBoolAttribute(model.bottom, false),
+      rank: BaseXform.toIntValue(model.rank, 10, true),
+    });
+  }
+
+  renderAboveAverage(xmlStream, model) {
+    xmlStream.leafNode(this.tag, {
+      type: 'aboveAverage',
+      dxfId: model.dxfId,
+      priority: model.priority,
+      aboveAverage: BaseXform.toBoolAttribute(model.aboveAverage, true),
+    });
+  }
+
+  renderDataBar(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      type: 'dataBar',
+      priority: model.priority,
+    });
+
+    this.databarXform.render(xmlStream, model);
+    this.extLstRefXform.render(xmlStream, model);
+
+    xmlStream.closeNode();
+  }
+
+  renderColorScale(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      type: 'colorScale',
+      priority: model.priority,
+    });
+
+    this.colorScaleXform.render(xmlStream, model);
+
+    xmlStream.closeNode();
+  }
+
+  renderIconSet(xmlStream, model) {
+    // iconset is all primitive or all extLst
+    if (!CfRuleXform.isPrimitive(model)) {
+      return;
+    }
+
+    xmlStream.openNode(this.tag, {
+      type: 'iconSet',
+      priority: model.priority,
+    });
+
+    this.iconSetXform.render(xmlStream, model);
+
+    xmlStream.closeNode();
+  }
+
+  renderText(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      type: model.operator,
+      dxfId: model.dxfId,
+      priority: model.priority,
+      operator: BaseXform.toStringAttribute(model.operator, 'containsText'),
+    });
+
+    const formula = getTextFormula(model);
+    if (formula) {
+      this.formulaXform.render(xmlStream, formula);
+    }
+
+    xmlStream.closeNode();
+  }
+
+  renderTimePeriod(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      type: 'timePeriod',
+      dxfId: model.dxfId,
+      priority: model.priority,
+      timePeriod: model.timePeriod,
+    });
+
+    const formula = getTimePeriodFormula(model);
+    if (formula) {
+      this.formulaXform.render(xmlStream, formula);
+    }
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel({attributes}) {
+    return {
+      ...opType(attributes),
+      dxfId: BaseXform.toIntValue(attributes.dxfId),
+      priority: BaseXform.toIntValue(attributes.priority),
+      timePeriod: attributes.timePeriod,
+      percent: BaseXform.toBoolValue(attributes.percent),
+      bottom: BaseXform.toBoolValue(attributes.bottom),
+      rank: BaseXform.toIntValue(attributes.rank),
+      aboveAverage: BaseXform.toBoolValue(attributes.aboveAverage),
+    };
+  }
+
+  onParserClose(name, parser) {
+    switch (name) {
+      case 'dataBar':
+      case 'extLst':
+      case 'colorScale':
+      case 'iconSet':
+        // merge parser model with ours
+        Object.assign(this.model, parser.model);
+        break;
+
+      case 'formula':
+        // except - formula is a string and appends to formulae
+        this.model.formulae = this.model.formulae || [];
+        this.model.formulae.push(parser.model);
+        break;
+    }
+  }
+}
+
+module.exports = CfRuleXform;

package/lib/xlsx/xform/sheet/cf/cfvo-xform.js

@@ -0,0 +1,27 @@
+const BaseXform = require('../../base-xform');
+
+class CfvoXform extends BaseXform {
+  get tag() {
+    return 'cfvo';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.leafNode(this.tag, {
+      type: model.type,
+      val: model.value,
+    });
+  }
+
+  parseOpen(node) {
+    this.model = {
+      type: node.attributes.type,
+      value: BaseXform.toFloatValue(node.attributes.val),
+    };
+  }
+
+  parseClose(name) {
+    return name !== this.tag;
+  }
+}
+
+module.exports = CfvoXform;

package/lib/xlsx/xform/sheet/cf/color-scale-xform.js

@@ -0,0 +1,45 @@
+const CompositeXform = require('../../composite-xform');
+
+const ColorXform = require('../../style/color-xform');
+const CfvoXform = require('./cfvo-xform');
+
+class ColorScaleXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      cfvo: (this.cfvoXform = new CfvoXform()),
+      color: (this.colorXform = new ColorXform()),
+    };
+  }
+
+  get tag() {
+    return 'colorScale';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag);
+
+    model.cfvo.forEach(cfvo => {
+      this.cfvoXform.render(xmlStream, cfvo);
+    });
+    model.color.forEach(color => {
+      this.colorXform.render(xmlStream, color);
+    });
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel(node) {
+    return {
+      cfvo: [],
+      color: [],
+    };
+  }
+
+  onParserClose(name, parser) {
+    this.model[name].push(parser.model);
+  }
+}
+
+module.exports = ColorScaleXform;

package/lib/xlsx/xform/sheet/cf/conditional-formatting-xform.js

@@ -0,0 +1,48 @@
+const CompositeXform = require('../../composite-xform');
+
+const CfRuleXform = require('./cf-rule-xform');
+
+class ConditionalFormattingXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      cfRule: new CfRuleXform(),
+    };
+  }
+
+  get tag() {
+    return 'conditionalFormatting';
+  }
+
+  render(xmlStream, model) {
+    // if there are no primitive rules, exit now
+    if (!model.rules.some(CfRuleXform.isPrimitive)) {
+      return;
+    }
+
+    xmlStream.openNode(this.tag, {sqref: model.ref});
+
+    model.rules.forEach(rule => {
+      if (CfRuleXform.isPrimitive(rule)) {
+        rule.ref = model.ref;
+        this.map.cfRule.render(xmlStream, rule);
+      }
+    });
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel({attributes}) {
+    return {
+      ref: attributes.sqref,
+      rules: [],
+    };
+  }
+
+  onParserClose(name, parser) {
+    this.model.rules.push(parser.model);
+  }
+}
+
+module.exports = ConditionalFormattingXform;

package/lib/xlsx/xform/sheet/cf/conditional-formattings-xform.js

@@ -0,0 +1,92 @@
+const BaseXform = require('../../base-xform');
+
+const ConditionalFormattingXform = require('./conditional-formatting-xform');
+
+class ConditionalFormattingsXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.cfXform = new ConditionalFormattingXform();
+  }
+
+  get tag() {
+    return 'conditionalFormatting';
+  }
+
+  reset() {
+    this.model = [];
+  }
+
+  prepare(model, options) {
+    // ensure each rule has a priority value
+    let nextPriority = model.reduce(
+      (p, cf) => Math.max(p, ...cf.rules.map(rule => rule.priority || 0)),
+      1
+    );
+    model.forEach(cf => {
+      cf.rules.forEach(rule => {
+        if (!rule.priority) {
+          rule.priority = nextPriority++;
+        }
+
+        if (rule.style) {
+          rule.dxfId = options.styles.addDxfStyle(rule.style);
+        }
+      });
+    });
+  }
+
+  render(xmlStream, model) {
+    model.forEach(cf => {
+      this.cfXform.render(xmlStream, cf);
+    });
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+
+    switch (node.name) {
+      case 'conditionalFormatting':
+        this.parser = this.cfXform;
+        this.parser.parseOpen(node);
+        return true;
+
+      default:
+        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;
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  reconcile(model, options) {
+    model.forEach(cf => {
+      cf.rules.forEach(rule => {
+        if (rule.dxfId !== undefined) {
+          rule.style = options.styles.getDxfStyle(rule.dxfId);
+          delete rule.dxfId;
+        }
+      });
+    });
+  }
+}
+
+module.exports = ConditionalFormattingsXform;

package/lib/xlsx/xform/sheet/cf/databar-xform.js

@@ -0,0 +1,49 @@
+const CompositeXform = require('../../composite-xform');
+
+const ColorXform = require('../../style/color-xform');
+const CfvoXform = require('./cfvo-xform');
+
+class DatabarXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      cfvo: (this.cfvoXform = new CfvoXform()),
+      color: (this.colorXform = new ColorXform()),
+    };
+  }
+
+  get tag() {
+    return 'dataBar';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag);
+
+    model.cfvo.forEach(cfvo => {
+      this.cfvoXform.render(xmlStream, cfvo);
+    });
+    this.colorXform.render(xmlStream, model.color);
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel() {
+    return {
+      cfvo: [],
+    };
+  }
+
+  onParserClose(name, parser) {
+    switch (name) {
+      case 'cfvo':
+        this.model.cfvo.push(parser.model);
+        break;
+      case 'color':
+        this.model.color = parser.model;
+        break;
+    }
+  }
+}
+
+module.exports = DatabarXform;

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

@@ -0,0 +1,87 @@
+/* eslint-disable max-classes-per-file */
+const BaseXform = require('../../base-xform');
+const CompositeXform = require('../../composite-xform');
+
+class X14IdXform extends BaseXform {
+  get tag() {
+    return 'x14:id';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.leafNode(this.tag, null, model);
+  }
+
+  parseOpen() {
+    this.model = '';
+  }
+
+  parseText(text) {
+    this.model += text;
+  }
+
+  parseClose(name) {
+    return name !== this.tag;
+  }
+}
+
+class ExtXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      'x14:id': (this.idXform = new X14IdXform()),
+    };
+  }
+
+  get tag() {
+    return 'ext';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      uri: '{B025F937-C7B1-47D3-B67F-A62EFF666E3E}',
+      'xmlns:x14': 'http://schemas.microsoft.com/office/spreadsheetml/2009/9/main',
+    });
+
+    this.idXform.render(xmlStream, model.x14Id);
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel() {
+    return {};
+  }
+
+  onParserClose(name, parser) {
+    this.model.x14Id = parser.model;
+  }
+}
+
+class ExtLstRefXform extends CompositeXform {
+  constructor() {
+    super();
+    this.map = {
+      ext: new ExtXform(),
+    };
+  }
+
+  get tag() {
+    return 'extLst';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag);
+    this.map.ext.render(xmlStream, model);
+    xmlStream.closeNode();
+  }
+
+  createNewModel() {
+    return {};
+  }
+
+  onParserClose(name, parser) {
+    Object.assign(this.model, parser.model);
+  }
+}
+
+module.exports = ExtLstRefXform;

package/lib/xlsx/xform/sheet/cf/formula-xform.js

@@ -0,0 +1,25 @@
+const BaseXform = require('../../base-xform');
+
+class FormulaXform extends BaseXform {
+  get tag() {
+    return 'formula';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.leafNode(this.tag, null, model);
+  }
+
+  parseOpen() {
+    this.model = '';
+  }
+
+  parseText(text) {
+    this.model += text;
+  }
+
+  parseClose(name) {
+    return name !== this.tag;
+  }
+}
+
+module.exports = FormulaXform;