@nocobase/plugin-action-import 1.5.0-beta.2 → 1.5.0-beta.21

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/sheet/data-validations-xform.js

@@ -0,0 +1,247 @@
+"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) {
+    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;
+//# sourceMappingURL=data-validations-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/sheet/dimension-xform.js

@@ -0,0 +1,28 @@
+"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
+      });
+    }
+  }
+  parseOpen(node) {
+    if (node.name === 'dimension') {
+      this.model = node.attributes.ref;
+      return true;
+    }
+    return false;
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = DimensionXform;
+//# sourceMappingURL=dimension-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/sheet/drawing-xform.js

@@ -0,0 +1,32 @@
+"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
+      });
+    }
+  }
+  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;
+//# sourceMappingURL=drawing-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/sheet/ext-lst-xform.js

@@ -0,0 +1,69 @@
+"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()
+    };
+  }
+  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;
+//# sourceMappingURL=ext-lst-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/sheet/header-footer-xform.js

@@ -0,0 +1,126 @@
+"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');
+        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;
+//# sourceMappingURL=header-footer-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/sheet/hyperlink-xform.js

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

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/sheet/merge-cell-xform.js

@@ -0,0 +1,26 @@
+"use strict";
+
+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;
+//# sourceMappingURL=merge-cell-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/sheet/merges.js

@@ -0,0 +1,52 @@
+"use strict";
+
+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;
+//# sourceMappingURL=merges.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/sheet/outline-properties-xform.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+const isDefined = attr => typeof attr !== 'undefined';
+class OutlinePropertiesXform extends BaseXform {
+  get tag() {
+    return 'outlinePr';
+  }
+  render(xmlStream, model) {
+    if (model && (isDefined(model.summaryBelow) || isDefined(model.summaryRight))) {
+      xmlStream.leafNode(this.tag, {
+        summaryBelow: isDefined(model.summaryBelow) ? Number(model.summaryBelow) : undefined,
+        summaryRight: isDefined(model.summaryRight) ? Number(model.summaryRight) : undefined
+      });
+      return true;
+    }
+    return false;
+  }
+  parseOpen(node) {
+    if (node.name === this.tag) {
+      this.model = {
+        summaryBelow: isDefined(node.attributes.summaryBelow) ? Boolean(Number(node.attributes.summaryBelow)) : undefined,
+        summaryRight: isDefined(node.attributes.summaryRight) ? Boolean(Number(node.attributes.summaryRight)) : undefined
+      };
+      return true;
+    }
+    return false;
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = OutlinePropertiesXform;
+//# sourceMappingURL=outline-properties-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/sheet/page-breaks-xform.js

@@ -0,0 +1,24 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+class PageBreaksXform extends BaseXform {
+  get tag() {
+    return 'brk';
+  }
+  render(xmlStream, model) {
+    xmlStream.leafNode('brk', model);
+  }
+  parseOpen(node) {
+    if (node.name === 'brk') {
+      this.model = node.attributes.ref;
+      return true;
+    }
+    return false;
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = PageBreaksXform;
+//# sourceMappingURL=page-breaks-xform.js.map