@zergai/ztc 0.2.5-dev.36050816660 → 0.2.6-dev.36101352252

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/sheet/cf/cf-rule-xform.js

@@ -1,26 +1,27 @@
-"use strict";
-
 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
+  '5Boxes': true,
 };
+
 const getTextFormula = model => {
   if (model.formulae && model.formulae[0]) {
     return model.formulae[0];
   }
+
   const range = new Range(model.ref);
-  const {
-    tl
-  } = range;
+  const {tl} = range;
   switch (model.operator) {
     case 'containsText':
       return `NOT(ISERROR(SEARCH("${model.text}",${tl})))`;
@@ -36,14 +37,14 @@ const getTextFormula = model => {
       return undefined;
   }
 };
+
 const getTimePeriodFormula = model => {
   if (model.formulae && model.formulae[0]) {
     return model.formulae[0];
   }
+
   const range = new Range(model.ref);
-  const {
-    tl
-  } = range;
+  const {tl} = range;
   switch (model.timePeriod) {
     case 'thisWeek':
       return `AND(TODAY()-ROUNDDOWN(${tl},0)<=WEEKDAY(TODAY())-1,ROUNDDOWN(${tl},0)-TODAY()<=7-WEEKDAY(TODAY()))`;
@@ -69,11 +70,9 @@ const getTimePeriodFormula = model => {
       return undefined;
   }
 };
+
 const opType = attributes => {
-  const {
-    type,
-    operator
-  } = attributes;
+  const {type, operator} = attributes;
   switch (type) {
     case 'containsText':
     case 'containsBlanks':
@@ -82,29 +81,31 @@ const opType = attributes => {
     case 'notContainsErrors':
       return {
         type: 'containsText',
-        operator: type
+        operator: type,
       };
+
     default:
-      return {
-        type,
-        operator
-      };
+      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()
+      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') {
@@ -114,6 +115,7 @@ class CfRuleXform extends CompositeXform {
     }
     return true;
   }
+
   render(xmlStream, model) {
     switch (model.type) {
       case 'expression':
@@ -145,27 +147,34 @@ class CfRuleXform extends CompositeXform {
         break;
     }
   }
+
   renderExpression(xmlStream, model) {
     xmlStream.openNode(this.tag, {
       type: 'expression',
       dxfId: model.dxfId,
-      priority: model.priority
+      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
+      operator: model.operator,
     });
+
     model.formulae.forEach(formula => {
       this.formulaXform.render(xmlStream, formula);
     });
+
     xmlStream.closeNode();
   }
+
   renderTop10(xmlStream, model) {
     xmlStream.leafNode(this.tag, {
       type: 'top10',
@@ -173,76 +182,91 @@ class CfRuleXform extends CompositeXform {
       priority: model.priority,
       percent: BaseXform.toBoolAttribute(model.percent, false),
       bottom: BaseXform.toBoolAttribute(model.bottom, false),
-      rank: BaseXform.toIntValue(model.rank, 10, true)
+      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)
+      aboveAverage: BaseXform.toBoolAttribute(model.aboveAverage, true),
     });
   }
+
   renderDataBar(xmlStream, model) {
     xmlStream.openNode(this.tag, {
       type: 'dataBar',
-      priority: model.priority
+      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
+      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
+      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')
+      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
+      timePeriod: model.timePeriod,
     });
+
     const formula = getTimePeriodFormula(model);
     if (formula) {
       this.formulaXform.render(xmlStream, formula);
     }
+
     xmlStream.closeNode();
   }
-  createNewModel(_ref) {
-    let {
-      attributes
-    } = _ref;
+
+  createNewModel({attributes}) {
     return {
       ...opType(attributes),
       dxfId: BaseXform.toIntValue(attributes.dxfId),
@@ -251,9 +275,10 @@ class CfRuleXform extends CompositeXform {
       percent: BaseXform.toBoolValue(attributes.percent),
       bottom: BaseXform.toBoolValue(attributes.bottom),
       rank: BaseXform.toIntValue(attributes.rank),
-      aboveAverage: BaseXform.toBoolValue(attributes.aboveAverage)
+      aboveAverage: BaseXform.toBoolValue(attributes.aboveAverage),
     };
   }
+
   onParserClose(name, parser) {
     switch (name) {
       case 'dataBar':
@@ -263,6 +288,7 @@ class CfRuleXform extends CompositeXform {
         // 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 || [];
@@ -271,5 +297,5 @@ class CfRuleXform extends CompositeXform {
     }
   }
 }
+
 module.exports = CfRuleXform;
-//# sourceMappingURL=cf-rule-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/sheet/cf/cfvo-xform.js

@@ -1,25 +1,27 @@
-"use strict";
-
 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
+      val: model.value,
     });
   }
+
   parseOpen(node) {
     this.model = {
       type: node.attributes.type,
-      value: BaseXform.toFloatValue(node.attributes.val)
+      value: BaseXform.toFloatValue(node.attributes.val),
     };
   }
+
   parseClose(name) {
     return name !== this.tag;
   }
 }
+
 module.exports = CfvoXform;
-//# sourceMappingURL=cfvo-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/sheet/cf/color-scale-xform.js

@@ -1,38 +1,45 @@
-"use strict";
-
 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()
+      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: []
+      color: [],
     };
   }
+
   onParserClose(name, parser) {
     this.model[name].push(parser.model);
   }
 }
+
 module.exports = ColorScaleXform;
-//# sourceMappingURL=color-scale-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/sheet/cf/conditional-formatting-xform.js

@@ -1,45 +1,48 @@
-"use strict";
-
 const CompositeXform = require('../../composite-xform');
+
 const CfRuleXform = require('./cf-rule-xform');
+
 class ConditionalFormattingXform extends CompositeXform {
   constructor() {
     super();
+
     this.map = {
-      cfRule: new CfRuleXform()
+      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
-    });
+
+    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(_ref) {
-    let {
-      attributes
-    } = _ref;
+
+  createNewModel({attributes}) {
     return {
       ref: attributes.sqref,
-      rules: []
+      rules: [],
     };
   }
+
   onParserClose(name, parser) {
     this.model.rules.push(parser.model);
   }
 }
+
 module.exports = ConditionalFormattingXform;
-//# sourceMappingURL=conditional-formatting-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/sheet/cf/conditional-formattings-xform.js

@@ -1,56 +1,70 @@
-"use strict";
-
 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);
+    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)) {
@@ -62,6 +76,7 @@ class ConditionalFormattingsXform extends BaseXform {
     }
     return false;
   }
+
   reconcile(model, options) {
     model.forEach(cf => {
       cf.rules.forEach(rule => {
@@ -73,5 +88,5 @@ class ConditionalFormattingsXform extends BaseXform {
     });
   }
 }
+
 module.exports = ConditionalFormattingsXform;
-//# sourceMappingURL=conditional-formattings-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/sheet/cf/databar-xform.js

@@ -1,32 +1,39 @@
-"use strict";
-
 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()
+      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: []
+      cfvo: [],
     };
   }
+
   onParserClose(name, parser) {
     switch (name) {
       case 'cfvo':
@@ -38,5 +45,5 @@ class DatabarXform extends CompositeXform {
     }
   }
 }
+
 module.exports = DatabarXform;
-//# sourceMappingURL=databar-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/sheet/cf/ext-lst-ref-xform.js

@@ -1,71 +1,87 @@
-"use strict";
-
 /* 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()
+      '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'
+      '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()
+      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;
-//# sourceMappingURL=ext-lst-ref-xform.js.map

package/{node_modules/exceljs/dist/es5 → packages/exceljs/lib}/xlsx/xform/sheet/cf/formula-xform.js

@@ -1,22 +1,25 @@
-"use strict";
-
 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;
-//# sourceMappingURL=formula-xform.js.map