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

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

@@ -1,17 +1,18 @@
-"use strict";
-
 const utils = require('../../../utils/utils');
 const BaseXform = require('../base-xform');
+
 class ColXform extends BaseXform {
   get tag() {
     return 'col';
   }
+
   prepare(model, options) {
     const styleId = options.styles.addStyleModel(model.style || {});
     if (styleId) {
       model.styleId = styleId;
     }
   }
+
   render(xmlStream, model) {
     xmlStream.openNode('col');
     xmlStream.addAttribute('min', model.min);
@@ -37,13 +38,17 @@ class ColXform extends BaseXform {
     xmlStream.addAttribute('customWidth', '1');
     xmlStream.closeNode();
   }
+
   parseOpen(node) {
     if (node.name === 'col') {
-      const model = this.model = {
+      const model = (this.model = {
         min: parseInt(node.attributes.min || '0', 10),
         max: parseInt(node.attributes.max || '0', 10),
-        width: node.attributes.width === undefined ? undefined : parseFloat(node.attributes.width || '0')
-      };
+        width:
+          node.attributes.width === undefined
+            ? undefined
+            : parseFloat(node.attributes.width || '0'),
+      });
       if (node.attributes.style) {
         model.styleId = parseInt(node.attributes.style, 10);
       }
@@ -63,10 +68,13 @@ class ColXform extends BaseXform {
     }
     return false;
   }
+
   parseText() {}
+
   parseClose() {
     return false;
   }
+
   reconcile(model, options) {
     // reconcile column styles
     if (model.styleId) {
@@ -74,5 +82,5 @@ class ColXform extends BaseXform {
     }
   }
 }
+
 module.exports = ColXform;
-//# sourceMappingURL=col-xform.js.map

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

@@ -1,10 +1,9 @@
-"use strict";
-
 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) {
@@ -13,6 +12,7 @@ function assign(definedName, attributes, name, defaultValue) {
     definedName[name] = defaultValue;
   }
 }
+
 function assignBool(definedName, attributes, name, defaultValue) {
   const value = attributes[name];
   if (value !== undefined) {
@@ -21,13 +21,14 @@ function assignBool(definedName, attributes, name, defaultValue) {
     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
+    marked: false,
   })).sort((a, b) => _.strcmp(a.address, b.address));
   const dvMap = _.keyBy(dvList, 'address');
   const matchCol = (addr, height, col) => {
@@ -39,69 +40,75 @@ function optimiseDataValidations(model) {
     }
     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
-        };
-      }
+  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 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...
+        // iterate rightwards...
 
-      let width = 1;
-      while (matchCol(addr, height, addr.col + width)) {
-        width++;
-      }
+        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;
+        // 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)}`,
+          };
         }
-      }
-      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)}`
+          sqref: dv.address,
         };
       }
-      return {
-        ...dv.dataValidation,
-        sqref: dv.address
-      };
-    }
-    return null;
-  }).filter(Boolean);
+      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
-      });
+      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);
           }
@@ -145,103 +152,106 @@ class DataValidationsXform extends BaseXform {
       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 '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 'dataValidation': {
+        if (!this._dataValidation.formulae || !this._dataValidation.formulae.length) {
+          delete this._dataValidation.formulae;
+          delete this._dataValidation.operator;
         }
-      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;
+        // 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;
           }
-          this._dataValidation.formulae.push(formula);
-          this._formula = undefined;
-          return true;
+        });
+        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;
-//# sourceMappingURL=data-validations-xform.js.map

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

@@ -1,17 +1,16 @@
-"use strict";
-
 const BaseXform = require('../base-xform');
+
 class DimensionXform extends BaseXform {
   get tag() {
     return 'dimension';
   }
+
   render(xmlStream, model) {
     if (model) {
-      xmlStream.leafNode('dimension', {
-        ref: model
-      });
+      xmlStream.leafNode('dimension', {ref: model});
     }
   }
+
   parseOpen(node) {
     if (node.name === 'dimension') {
       this.model = node.attributes.ref;
@@ -19,10 +18,12 @@ class DimensionXform extends BaseXform {
     }
     return false;
   }
+
   parseText() {}
+
   parseClose() {
     return false;
   }
 }
+
 module.exports = DimensionXform;
-//# sourceMappingURL=dimension-xform.js.map

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

@@ -1,32 +1,33 @@
-"use strict";
-
 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
-      });
+      xmlStream.leafNode(this.tag, {'r:id': model.rId});
     }
   }
+
   parseOpen(node) {
     switch (node.name) {
       case this.tag:
         this.model = {
-          rId: node.attributes['r:id']
+          rId: node.attributes['r:id'],
         };
         return true;
       default:
         return false;
     }
   }
+
   parseText() {}
+
   parseClose() {
     return false;
   }
 }
+
 module.exports = DrawingXform;
-//# sourceMappingURL=drawing-xform.js.map

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

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

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

@@ -1,14 +1,16 @@
-"use strict";
-
 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');
@@ -42,6 +44,7 @@ class HeaderFooterXform extends BaseXform {
         xmlStream.leafNode('firstFooter', null, model.firstFooter);
         createTag = true;
       }
+
       if (createTag) {
         xmlStream.closeNode();
         xmlStream.commit();
@@ -50,6 +53,7 @@ class HeaderFooterXform extends BaseXform {
       }
     }
   }
+
   parseOpen(node) {
     switch (node.name) {
       case 'headerFooter':
@@ -61,52 +65,67 @@ class HeaderFooterXform extends BaseXform {
           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':
@@ -117,10 +136,11 @@ class HeaderFooterXform extends BaseXform {
       case 'firstFooter':
         this.currentNode = undefined;
         return true;
+
       default:
         return false;
     }
   }
 }
+
 module.exports = HeaderFooterXform;
-//# sourceMappingURL=header-footer-xform.js.map