@nocobase/plugin-action-export 1.7.0-beta.8 → 1.8.0-beta.1

package/dist/node_modules/exceljs/dist/es5/doc/column.js

@@ -0,0 +1,274 @@
+'use strict';
+
+const _ = require('../utils/under-dash');
+const Enums = require('./enums');
+const colCache = require('../utils/col-cache');
+const DEFAULT_COLUMN_WIDTH = 9;
+
+// Column defines the column properties for 1 column.
+// This includes header rows, widths, key, (style), etc.
+// Worksheet will condense the columns as appropriate during serialization
+class Column {
+  constructor(worksheet, number, defn) {
+    this._worksheet = worksheet;
+    this._number = number;
+    if (defn !== false) {
+      // sometimes defn will follow
+      this.defn = defn;
+    }
+  }
+  get number() {
+    return this._number;
+  }
+  get worksheet() {
+    return this._worksheet;
+  }
+  get letter() {
+    return colCache.n2l(this._number);
+  }
+  get isCustomWidth() {
+    return this.width !== undefined && this.width !== DEFAULT_COLUMN_WIDTH;
+  }
+  get defn() {
+    return {
+      header: this._header,
+      key: this.key,
+      width: this.width,
+      style: this.style,
+      hidden: this.hidden,
+      outlineLevel: this.outlineLevel
+    };
+  }
+  set defn(value) {
+    if (value) {
+      this.key = value.key;
+      this.width = value.width !== undefined ? value.width : DEFAULT_COLUMN_WIDTH;
+      this.outlineLevel = value.outlineLevel;
+      if (value.style) {
+        this.style = value.style;
+      } else {
+        this.style = {};
+      }
+
+      // headers must be set after style
+      this.header = value.header;
+      this._hidden = !!value.hidden;
+    } else {
+      delete this._header;
+      delete this._key;
+      delete this.width;
+      this.style = {};
+      this.outlineLevel = 0;
+    }
+  }
+  get headers() {
+    return this._header && this._header instanceof Array ? this._header : [this._header];
+  }
+  get header() {
+    return this._header;
+  }
+  set header(value) {
+    if (value !== undefined) {
+      this._header = value;
+      this.headers.forEach((text, index) => {
+        this._worksheet.getCell(index + 1, this.number).value = text;
+      });
+    } else {
+      this._header = undefined;
+    }
+  }
+  get key() {
+    return this._key;
+  }
+  set key(value) {
+    const column = this._key && this._worksheet.getColumnKey(this._key);
+    if (column === this) {
+      this._worksheet.deleteColumnKey(this._key);
+    }
+    this._key = value;
+    if (value) {
+      this._worksheet.setColumnKey(this._key, this);
+    }
+  }
+  get hidden() {
+    return !!this._hidden;
+  }
+  set hidden(value) {
+    this._hidden = value;
+  }
+  get outlineLevel() {
+    return this._outlineLevel || 0;
+  }
+  set outlineLevel(value) {
+    this._outlineLevel = value;
+  }
+  get collapsed() {
+    return !!(this._outlineLevel && this._outlineLevel >= this._worksheet.properties.outlineLevelCol);
+  }
+  toString() {
+    return JSON.stringify({
+      key: this.key,
+      width: this.width,
+      headers: this.headers.length ? this.headers : undefined
+    });
+  }
+  equivalentTo(other) {
+    return this.width === other.width && this.hidden === other.hidden && this.outlineLevel === other.outlineLevel && _.isEqual(this.style, other.style);
+  }
+  get isDefault() {
+    if (this.isCustomWidth) {
+      return false;
+    }
+    if (this.hidden) {
+      return false;
+    }
+    if (this.outlineLevel) {
+      return false;
+    }
+    const s = this.style;
+    if (s && (s.font || s.numFmt || s.alignment || s.border || s.fill || s.protection)) {
+      return false;
+    }
+    return true;
+  }
+  get headerCount() {
+    return this.headers.length;
+  }
+  eachCell(options, iteratee) {
+    const colNumber = this.number;
+    if (!iteratee) {
+      iteratee = options;
+      options = null;
+    }
+    this._worksheet.eachRow(options, (row, rowNumber) => {
+      iteratee(row.getCell(colNumber), rowNumber);
+    });
+  }
+  get values() {
+    const v = [];
+    this.eachCell((cell, rowNumber) => {
+      if (cell && cell.type !== Enums.ValueType.Null) {
+        v[rowNumber] = cell.value;
+      }
+    });
+    return v;
+  }
+  set values(v) {
+    if (!v) {
+      return;
+    }
+    const colNumber = this.number;
+    let offset = 0;
+    if (v.hasOwnProperty('0')) {
+      // assume contiguous array, start at row 1
+      offset = 1;
+    }
+    v.forEach((value, index) => {
+      this._worksheet.getCell(index + offset, colNumber).value = value;
+    });
+  }
+
+  // =========================================================================
+  // styles
+  _applyStyle(name, value) {
+    this.style[name] = value;
+    this.eachCell(cell => {
+      cell[name] = value;
+    });
+    return value;
+  }
+  get numFmt() {
+    return this.style.numFmt;
+  }
+  set numFmt(value) {
+    this._applyStyle('numFmt', value);
+  }
+  get font() {
+    return this.style.font;
+  }
+  set font(value) {
+    this._applyStyle('font', value);
+  }
+  get alignment() {
+    return this.style.alignment;
+  }
+  set alignment(value) {
+    this._applyStyle('alignment', value);
+  }
+  get protection() {
+    return this.style.protection;
+  }
+  set protection(value) {
+    this._applyStyle('protection', value);
+  }
+  get border() {
+    return this.style.border;
+  }
+  set border(value) {
+    this._applyStyle('border', value);
+  }
+  get fill() {
+    return this.style.fill;
+  }
+  set fill(value) {
+    this._applyStyle('fill', value);
+  }
+
+  // =============================================================================
+  // static functions
+
+  static toModel(columns) {
+    // Convert array of Column into compressed list cols
+    const cols = [];
+    let col = null;
+    if (columns) {
+      columns.forEach((column, index) => {
+        if (column.isDefault) {
+          if (col) {
+            col = null;
+          }
+        } else if (!col || !column.equivalentTo(col)) {
+          col = {
+            min: index + 1,
+            max: index + 1,
+            width: column.width !== undefined ? column.width : DEFAULT_COLUMN_WIDTH,
+            style: column.style,
+            isCustomWidth: column.isCustomWidth,
+            hidden: column.hidden,
+            outlineLevel: column.outlineLevel,
+            collapsed: column.collapsed
+          };
+          cols.push(col);
+        } else {
+          col.max = index + 1;
+        }
+      });
+    }
+    return cols.length ? cols : undefined;
+  }
+  static fromModel(worksheet, cols) {
+    cols = cols || [];
+    const columns = [];
+    let count = 1;
+    let index = 0;
+    /**
+     * sort cols by min
+     * If it is not sorted, the subsequent column configuration will be overwritten
+     * */
+    cols = cols.sort(function (pre, next) {
+      return pre.min - next.min;
+    });
+    while (index < cols.length) {
+      const col = cols[index++];
+      while (count < col.min) {
+        columns.push(new Column(worksheet, count++));
+      }
+      while (count <= col.max) {
+        columns.push(new Column(worksheet, count++, col));
+      }
+    }
+    return columns.length ? columns : null;
+  }
+}
+module.exports = Column;
+//# sourceMappingURL=column.js.map

package/dist/node_modules/exceljs/dist/es5/doc/data-validations.js

@@ -0,0 +1,18 @@
+"use strict";
+
+class DataValidations {
+  constructor(model) {
+    this.model = model || {};
+  }
+  add(address, validation) {
+    return this.model[address] = validation;
+  }
+  find(address) {
+    return this.model[address];
+  }
+  remove(address) {
+    this.model[address] = undefined;
+  }
+}
+module.exports = DataValidations;
+//# sourceMappingURL=data-validations.js.map

package/dist/node_modules/exceljs/dist/es5/doc/defined-names.js

@@ -0,0 +1,173 @@
+'use strict';
+
+const _ = require('../utils/under-dash');
+const colCache = require('../utils/col-cache');
+const CellMatrix = require('../utils/cell-matrix');
+const Range = require('./range');
+const rangeRegexp = /[$](\w+)[$](\d+)(:[$](\w+)[$](\d+))?/;
+class DefinedNames {
+  constructor() {
+    this.matrixMap = {};
+  }
+  getMatrix(name) {
+    const matrix = this.matrixMap[name] || (this.matrixMap[name] = new CellMatrix());
+    return matrix;
+  }
+
+  // add a name to a cell. locStr in the form SheetName!$col$row or SheetName!$c1$r1:$c2:$r2
+  add(locStr, name) {
+    const location = colCache.decodeEx(locStr);
+    this.addEx(location, name);
+  }
+  addEx(location, name) {
+    const matrix = this.getMatrix(name);
+    if (location.top) {
+      for (let col = location.left; col <= location.right; col++) {
+        for (let row = location.top; row <= location.bottom; row++) {
+          const address = {
+            sheetName: location.sheetName,
+            address: colCache.n2l(col) + row,
+            row,
+            col
+          };
+          matrix.addCellEx(address);
+        }
+      }
+    } else {
+      matrix.addCellEx(location);
+    }
+  }
+  remove(locStr, name) {
+    const location = colCache.decodeEx(locStr);
+    this.removeEx(location, name);
+  }
+  removeEx(location, name) {
+    const matrix = this.getMatrix(name);
+    matrix.removeCellEx(location);
+  }
+  removeAllNames(location) {
+    _.each(this.matrixMap, matrix => {
+      matrix.removeCellEx(location);
+    });
+  }
+  forEach(callback) {
+    _.each(this.matrixMap, (matrix, name) => {
+      matrix.forEach(cell => {
+        callback(name, cell);
+      });
+    });
+  }
+
+  // get all the names of a cell
+  getNames(addressStr) {
+    return this.getNamesEx(colCache.decodeEx(addressStr));
+  }
+  getNamesEx(address) {
+    return _.map(this.matrixMap, (matrix, name) => matrix.findCellEx(address) && name).filter(Boolean);
+  }
+  _explore(matrix, cell) {
+    cell.mark = false;
+    const {
+      sheetName
+    } = cell;
+    const range = new Range(cell.row, cell.col, cell.row, cell.col, sheetName);
+    let x;
+    let y;
+
+    // grow vertical - only one col to worry about
+    function vGrow(yy, edge) {
+      const c = matrix.findCellAt(sheetName, yy, cell.col);
+      if (!c || !c.mark) {
+        return false;
+      }
+      range[edge] = yy;
+      c.mark = false;
+      return true;
+    }
+    for (y = cell.row - 1; vGrow(y, 'top'); y--);
+    for (y = cell.row + 1; vGrow(y, 'bottom'); y++);
+
+    // grow horizontal - ensure all rows can grow
+    function hGrow(xx, edge) {
+      const cells = [];
+      for (y = range.top; y <= range.bottom; y++) {
+        const c = matrix.findCellAt(sheetName, y, xx);
+        if (c && c.mark) {
+          cells.push(c);
+        } else {
+          return false;
+        }
+      }
+      range[edge] = xx;
+      for (let i = 0; i < cells.length; i++) {
+        cells[i].mark = false;
+      }
+      return true;
+    }
+    for (x = cell.col - 1; hGrow(x, 'left'); x--);
+    for (x = cell.col + 1; hGrow(x, 'right'); x++);
+    return range;
+  }
+  getRanges(name, matrix) {
+    matrix = matrix || this.matrixMap[name];
+    if (!matrix) {
+      return {
+        name,
+        ranges: []
+      };
+    }
+
+    // mark and sweep!
+    matrix.forEach(cell => {
+      cell.mark = true;
+    });
+    const ranges = matrix.map(cell => cell.mark && this._explore(matrix, cell)).filter(Boolean).map(range => range.$shortRange);
+    return {
+      name,
+      ranges
+    };
+  }
+  normaliseMatrix(matrix, sheetName) {
+    // some of the cells might have shifted on specified sheet
+    // need to reassign rows, cols
+    matrix.forEachInSheet(sheetName, (cell, row, col) => {
+      if (cell) {
+        if (cell.row !== row || cell.col !== col) {
+          cell.row = row;
+          cell.col = col;
+          cell.address = colCache.n2l(col) + row;
+        }
+      }
+    });
+  }
+  spliceRows(sheetName, start, numDelete, numInsert) {
+    _.each(this.matrixMap, matrix => {
+      matrix.spliceRows(sheetName, start, numDelete, numInsert);
+      this.normaliseMatrix(matrix, sheetName);
+    });
+  }
+  spliceColumns(sheetName, start, numDelete, numInsert) {
+    _.each(this.matrixMap, matrix => {
+      matrix.spliceColumns(sheetName, start, numDelete, numInsert);
+      this.normaliseMatrix(matrix, sheetName);
+    });
+  }
+  get model() {
+    // To get names per cell - just iterate over all names finding cells if they exist
+    return _.map(this.matrixMap, (matrix, name) => this.getRanges(name, matrix)).filter(definedName => definedName.ranges.length);
+  }
+  set model(value) {
+    // value is [ { name, ranges }, ... ]
+    const matrixMap = this.matrixMap = {};
+    value.forEach(definedName => {
+      const matrix = matrixMap[definedName.name] = new CellMatrix();
+      definedName.ranges.forEach(rangeStr => {
+        if (rangeRegexp.test(rangeStr.split('!').pop() || '')) {
+          matrix.addCell(rangeStr);
+        }
+      });
+    });
+  }
+}
+module.exports = DefinedNames;
+//# sourceMappingURL=defined-names.js.map

package/dist/node_modules/exceljs/dist/es5/doc/enums.js

@@ -0,0 +1,49 @@
+'use strict';
+
+module.exports = {
+  ValueType: {
+    Null: 0,
+    Merge: 1,
+    Number: 2,
+    String: 3,
+    Date: 4,
+    Hyperlink: 5,
+    Formula: 6,
+    SharedString: 7,
+    RichText: 8,
+    Boolean: 9,
+    Error: 10
+  },
+  FormulaType: {
+    None: 0,
+    Master: 1,
+    Shared: 2
+  },
+  RelationshipType: {
+    None: 0,
+    OfficeDocument: 1,
+    Worksheet: 2,
+    CalcChain: 3,
+    SharedStrings: 4,
+    Styles: 5,
+    Theme: 6,
+    Hyperlink: 7
+  },
+  DocumentType: {
+    Xlsx: 1
+  },
+  ReadingOrder: {
+    LeftToRight: 1,
+    RightToLeft: 2
+  },
+  ErrorValue: {
+    NotApplicable: '#N/A',
+    Ref: '#REF!',
+    Name: '#NAME?',
+    DivZero: '#DIV/0!',
+    Null: '#NULL!',
+    Value: '#VALUE!',
+    Num: '#NUM!'
+  }
+};
+//# sourceMappingURL=enums.js.map

package/dist/node_modules/exceljs/dist/es5/doc/image.js

@@ -0,0 +1,69 @@
+"use strict";
+
+const colCache = require('../utils/col-cache');
+const Anchor = require('./anchor');
+class Image {
+  constructor(worksheet, model) {
+    this.worksheet = worksheet;
+    this.model = model;
+  }
+  get model() {
+    switch (this.type) {
+      case 'background':
+        return {
+          type: this.type,
+          imageId: this.imageId
+        };
+      case 'image':
+        return {
+          type: this.type,
+          imageId: this.imageId,
+          hyperlinks: this.range.hyperlinks,
+          range: {
+            tl: this.range.tl.model,
+            br: this.range.br && this.range.br.model,
+            ext: this.range.ext,
+            editAs: this.range.editAs
+          }
+        };
+      default:
+        throw new Error('Invalid Image Type');
+    }
+  }
+  set model(_ref) {
+    let {
+      type,
+      imageId,
+      range,
+      hyperlinks
+    } = _ref;
+    this.type = type;
+    this.imageId = imageId;
+    if (type === 'image') {
+      if (typeof range === 'string') {
+        const decoded = colCache.decode(range);
+        this.range = {
+          tl: new Anchor(this.worksheet, {
+            col: decoded.left,
+            row: decoded.top
+          }, -1),
+          br: new Anchor(this.worksheet, {
+            col: decoded.right,
+            row: decoded.bottom
+          }, 0),
+          editAs: 'oneCell'
+        };
+      } else {
+        this.range = {
+          tl: new Anchor(this.worksheet, range.tl, 0),
+          br: range.br && new Anchor(this.worksheet, range.br, 0),
+          ext: range.ext,
+          editAs: range.editAs,
+          hyperlinks: hyperlinks || range.hyperlinks
+        };
+      }
+    }
+  }
+}
+module.exports = Image;
+//# sourceMappingURL=image.js.map

package/dist/node_modules/exceljs/dist/es5/doc/modelcontainer.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const XLSX = require('../xlsx/xlsx');
+class ModelContainer {
+  constructor(model) {
+    this.model = model;
+  }
+  get xlsx() {
+    if (!this._xlsx) {
+      this._xlsx = new XLSX(this);
+    }
+    return this._xlsx;
+  }
+}
+module.exports = ModelContainer;
+//# sourceMappingURL=modelcontainer.js.map

package/dist/node_modules/exceljs/dist/es5/doc/note.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const _ = require('../utils/under-dash');
+class Note {
+  constructor(note) {
+    this.note = note;
+  }
+  get model() {
+    let value = null;
+    switch (typeof this.note) {
+      case 'string':
+        value = {
+          type: 'note',
+          note: {
+            texts: [{
+              text: this.note
+            }]
+          }
+        };
+        break;
+      default:
+        value = {
+          type: 'note',
+          note: this.note
+        };
+        break;
+    }
+    // Suitable for all cell comments
+    return _.deepMerge({}, Note.DEFAULT_CONFIGS, value);
+  }
+  set model(value) {
+    const {
+      note
+    } = value;
+    const {
+      texts
+    } = note;
+    if (texts.length === 1 && Object.keys(texts[0]).length === 1) {
+      this.note = texts[0].text;
+    } else {
+      this.note = note;
+    }
+  }
+  static fromModel(model) {
+    const note = new Note();
+    note.model = model;
+    return note;
+  }
+}
+Note.DEFAULT_CONFIGS = {
+  note: {
+    margins: {
+      insetmode: 'auto',
+      inset: [0.13, 0.13, 0.25, 0.25]
+    },
+    protection: {
+      locked: 'True',
+      lockText: 'True'
+    },
+    editAs: 'absolute'
+  }
+};
+module.exports = Note;
+//# sourceMappingURL=note.js.map