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

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

@@ -0,0 +1,196 @@
+'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;

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

@@ -0,0 +1,48 @@
+'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!',
+  },
+};

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

@@ -0,0 +1,59 @@
+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({type, imageId, range, hyperlinks}) {
+    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;

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

@@ -0,0 +1,18 @@
+'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;

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

@@ -0,0 +1,65 @@
+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;

package/dist/node_modules/exceljs/lib/doc/range.js

@@ -0,0 +1,257 @@
+const colCache = require('../utils/col-cache');
+
+// used by worksheet to calculate sheet dimensions
+class Range {
+  constructor() {
+    this.decode(arguments);
+  }
+
+  setTLBR(t, l, b, r, s) {
+    if (arguments.length < 4) {
+      // setTLBR(tl, br, s)
+      const tl = colCache.decodeAddress(t);
+      const br = colCache.decodeAddress(l);
+      this.model = {
+        top: Math.min(tl.row, br.row),
+        left: Math.min(tl.col, br.col),
+        bottom: Math.max(tl.row, br.row),
+        right: Math.max(tl.col, br.col),
+        sheetName: b,
+      };
+
+      this.setTLBR(tl.row, tl.col, br.row, br.col, s);
+    } else {
+      // setTLBR(t, l, b, r, s)
+      this.model = {
+        top: Math.min(t, b),
+        left: Math.min(l, r),
+        bottom: Math.max(t, b),
+        right: Math.max(l, r),
+        sheetName: s,
+      };
+    }
+  }
+
+  decode(argv) {
+    switch (argv.length) {
+      case 5: // [t,l,b,r,s]
+        this.setTLBR(argv[0], argv[1], argv[2], argv[3], argv[4]);
+        break;
+      case 4: // [t,l,b,r]
+        this.setTLBR(argv[0], argv[1], argv[2], argv[3]);
+        break;
+
+      case 3: // [tl,br,s]
+        this.setTLBR(argv[0], argv[1], argv[2]);
+        break;
+      case 2: // [tl,br]
+        this.setTLBR(argv[0], argv[1]);
+        break;
+
+      case 1: {
+        const value = argv[0];
+        if (value instanceof Range) {
+          // copy constructor
+          this.model = {
+            top: value.model.top,
+            left: value.model.left,
+            bottom: value.model.bottom,
+            right: value.model.right,
+            sheetName: value.sheetName,
+          };
+        } else if (value instanceof Array) {
+          // an arguments array
+          this.decode(value);
+        } else if (value.top && value.left && value.bottom && value.right) {
+          // a model
+          this.model = {
+            top: value.top,
+            left: value.left,
+            bottom: value.bottom,
+            right: value.right,
+            sheetName: value.sheetName,
+          };
+        } else {
+          // [sheetName!]tl:br
+          const tlbr = colCache.decodeEx(value);
+          if (tlbr.top) {
+            this.model = {
+              top: tlbr.top,
+              left: tlbr.left,
+              bottom: tlbr.bottom,
+              right: tlbr.right,
+              sheetName: tlbr.sheetName,
+            };
+          } else {
+            this.model = {
+              top: tlbr.row,
+              left: tlbr.col,
+              bottom: tlbr.row,
+              right: tlbr.col,
+              sheetName: tlbr.sheetName,
+            };
+          }
+        }
+        break;
+      }
+
+      case 0:
+        this.model = {
+          top: 0,
+          left: 0,
+          bottom: 0,
+          right: 0,
+        };
+        break;
+
+      default:
+        throw new Error(`Invalid number of arguments to _getDimensions() - ${argv.length}`);
+    }
+  }
+
+  get top() {
+    return this.model.top || 1;
+  }
+
+  set top(value) {
+    this.model.top = value;
+  }
+
+  get left() {
+    return this.model.left || 1;
+  }
+
+  set left(value) {
+    this.model.left = value;
+  }
+
+  get bottom() {
+    return this.model.bottom || 1;
+  }
+
+  set bottom(value) {
+    this.model.bottom = value;
+  }
+
+  get right() {
+    return this.model.right || 1;
+  }
+
+  set right(value) {
+    this.model.right = value;
+  }
+
+  get sheetName() {
+    return this.model.sheetName;
+  }
+
+  set sheetName(value) {
+    this.model.sheetName = value;
+  }
+
+  get _serialisedSheetName() {
+    const {sheetName} = this.model;
+    if (sheetName) {
+      if (/^[a-zA-Z0-9]*$/.test(sheetName)) {
+        return `${sheetName}!`;
+      }
+      return `'${sheetName}'!`;
+    }
+    return '';
+  }
+
+  expand(top, left, bottom, right) {
+    if (!this.model.top || top < this.top) this.top = top;
+    if (!this.model.left || left < this.left) this.left = left;
+    if (!this.model.bottom || bottom > this.bottom) this.bottom = bottom;
+    if (!this.model.right || right > this.right) this.right = right;
+  }
+
+  expandRow(row) {
+    if (row) {
+      const {dimensions, number} = row;
+      if (dimensions) {
+        this.expand(number, dimensions.min, number, dimensions.max);
+      }
+    }
+  }
+
+  expandToAddress(addressStr) {
+    const address = colCache.decodeEx(addressStr);
+    this.expand(address.row, address.col, address.row, address.col);
+  }
+
+  get tl() {
+    return colCache.n2l(this.left) + this.top;
+  }
+
+  get $t$l() {
+    return `$${colCache.n2l(this.left)}$${this.top}`;
+  }
+
+  get br() {
+    return colCache.n2l(this.right) + this.bottom;
+  }
+
+  get $b$r() {
+    return `$${colCache.n2l(this.right)}$${this.bottom}`;
+  }
+
+  get range() {
+    return `${this._serialisedSheetName + this.tl}:${this.br}`;
+  }
+
+  get $range() {
+    return `${this._serialisedSheetName + this.$t$l}:${this.$b$r}`;
+  }
+
+  get shortRange() {
+    return this.count > 1 ? this.range : this._serialisedSheetName + this.tl;
+  }
+
+  get $shortRange() {
+    return this.count > 1 ? this.$range : this._serialisedSheetName + this.$t$l;
+  }
+
+  get count() {
+    return (1 + this.bottom - this.top) * (1 + this.right - this.left);
+  }
+
+  toString() {
+    return this.range;
+  }
+
+  intersects(other) {
+    if (other.sheetName && this.sheetName && other.sheetName !== this.sheetName) return false;
+    if (other.bottom < this.top) return false;
+    if (other.top > this.bottom) return false;
+    if (other.right < this.left) return false;
+    if (other.left > this.right) return false;
+    return true;
+  }
+
+  contains(addressStr) {
+    const address = colCache.decodeEx(addressStr);
+    return this.containsEx(address);
+  }
+
+  containsEx(address) {
+    if (address.sheetName && this.sheetName && address.sheetName !== this.sheetName) return false;
+    return (
+      address.row >= this.top &&
+      address.row <= this.bottom &&
+      address.col >= this.left &&
+      address.col <= this.right
+    );
+  }
+
+  forEachAddress(cb) {
+    for (let col = this.left; col <= this.right; col++) {
+      for (let row = this.top; row <= this.bottom; row++) {
+        cb(colCache.encodeAddress(row, col), row, col);
+      }
+    }
+  }
+}
+
+module.exports = Range;