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

package/dist/node_modules/exceljs/dist/es5/utils/cell-matrix.js

@@ -0,0 +1,149 @@
+"use strict";
+
+const _ = require('./under-dash');
+const colCache = require('./col-cache');
+class CellMatrix {
+  constructor(template) {
+    this.template = template;
+    this.sheets = {};
+  }
+  addCell(addressStr) {
+    this.addCellEx(colCache.decodeEx(addressStr));
+  }
+  getCell(addressStr) {
+    return this.findCellEx(colCache.decodeEx(addressStr), true);
+  }
+  findCell(addressStr) {
+    return this.findCellEx(colCache.decodeEx(addressStr), false);
+  }
+  findCellAt(sheetName, rowNumber, colNumber) {
+    const sheet = this.sheets[sheetName];
+    const row = sheet && sheet[rowNumber];
+    return row && row[colNumber];
+  }
+  addCellEx(address) {
+    if (address.top) {
+      for (let row = address.top; row <= address.bottom; row++) {
+        for (let col = address.left; col <= address.right; col++) {
+          this.getCellAt(address.sheetName, row, col);
+        }
+      }
+    } else {
+      this.findCellEx(address, true);
+    }
+  }
+  getCellEx(address) {
+    return this.findCellEx(address, true);
+  }
+  findCellEx(address, create) {
+    const sheet = this.findSheet(address, create);
+    const row = this.findSheetRow(sheet, address, create);
+    return this.findRowCell(row, address, create);
+  }
+  getCellAt(sheetName, rowNumber, colNumber) {
+    const sheet = this.sheets[sheetName] || (this.sheets[sheetName] = []);
+    const row = sheet[rowNumber] || (sheet[rowNumber] = []);
+    const cell = row[colNumber] || (row[colNumber] = {
+      sheetName,
+      address: colCache.n2l(colNumber) + rowNumber,
+      row: rowNumber,
+      col: colNumber
+    });
+    return cell;
+  }
+  removeCellEx(address) {
+    const sheet = this.findSheet(address);
+    if (!sheet) {
+      return;
+    }
+    const row = this.findSheetRow(sheet, address);
+    if (!row) {
+      return;
+    }
+    delete row[address.col];
+  }
+  forEachInSheet(sheetName, callback) {
+    const sheet = this.sheets[sheetName];
+    if (sheet) {
+      sheet.forEach((row, rowNumber) => {
+        if (row) {
+          row.forEach((cell, colNumber) => {
+            if (cell) {
+              callback(cell, rowNumber, colNumber);
+            }
+          });
+        }
+      });
+    }
+  }
+  forEach(callback) {
+    _.each(this.sheets, (sheet, sheetName) => {
+      this.forEachInSheet(sheetName, callback);
+    });
+  }
+  map(callback) {
+    const results = [];
+    this.forEach(cell => {
+      results.push(callback(cell));
+    });
+    return results;
+  }
+  findSheet(address, create) {
+    const name = address.sheetName;
+    if (this.sheets[name]) {
+      return this.sheets[name];
+    }
+    if (create) {
+      return this.sheets[name] = [];
+    }
+    return undefined;
+  }
+  findSheetRow(sheet, address, create) {
+    const {
+      row
+    } = address;
+    if (sheet && sheet[row]) {
+      return sheet[row];
+    }
+    if (create) {
+      return sheet[row] = [];
+    }
+    return undefined;
+  }
+  findRowCell(row, address, create) {
+    const {
+      col
+    } = address;
+    if (row && row[col]) {
+      return row[col];
+    }
+    if (create) {
+      return row[col] = this.template ? Object.assign(address, JSON.parse(JSON.stringify(this.template))) : address;
+    }
+    return undefined;
+  }
+  spliceRows(sheetName, start, numDelete, numInsert) {
+    const sheet = this.sheets[sheetName];
+    if (sheet) {
+      const inserts = [];
+      for (let i = 0; i < numInsert; i++) {
+        inserts.push([]);
+      }
+      sheet.splice(start, numDelete, ...inserts);
+    }
+  }
+  spliceColumns(sheetName, start, numDelete, numInsert) {
+    const sheet = this.sheets[sheetName];
+    if (sheet) {
+      const inserts = [];
+      for (let i = 0; i < numInsert; i++) {
+        inserts.push(null);
+      }
+      _.each(sheet, row => {
+        row.splice(start, numDelete, ...inserts);
+      });
+    }
+  }
+}
+module.exports = CellMatrix;
+//# sourceMappingURL=cell-matrix.js.map

package/dist/node_modules/exceljs/dist/es5/utils/col-cache.js

@@ -0,0 +1,258 @@
+"use strict";
+
+const addressRegex = /^[A-Z]+\d+$/;
+// =========================================================================
+// Column Letter to Number conversion
+const colCache = {
+  _dictionary: ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'],
+  _l2nFill: 0,
+  _l2n: {},
+  _n2l: [],
+  _level(n) {
+    if (n <= 26) {
+      return 1;
+    }
+    if (n <= 26 * 26) {
+      return 2;
+    }
+    return 3;
+  },
+  _fill(level) {
+    let c;
+    let v;
+    let l1;
+    let l2;
+    let l3;
+    let n = 1;
+    if (level >= 4) {
+      throw new Error('Out of bounds. Excel supports columns from 1 to 16384');
+    }
+    if (this._l2nFill < 1 && level >= 1) {
+      while (n <= 26) {
+        c = this._dictionary[n - 1];
+        this._n2l[n] = c;
+        this._l2n[c] = n;
+        n++;
+      }
+      this._l2nFill = 1;
+    }
+    if (this._l2nFill < 2 && level >= 2) {
+      n = 27;
+      while (n <= 26 + 26 * 26) {
+        v = n - (26 + 1);
+        l1 = v % 26;
+        l2 = Math.floor(v / 26);
+        c = this._dictionary[l2] + this._dictionary[l1];
+        this._n2l[n] = c;
+        this._l2n[c] = n;
+        n++;
+      }
+      this._l2nFill = 2;
+    }
+    if (this._l2nFill < 3 && level >= 3) {
+      n = 26 + 26 * 26 + 1;
+      while (n <= 16384) {
+        v = n - (26 * 26 + 26 + 1);
+        l1 = v % 26;
+        l2 = Math.floor(v / 26) % 26;
+        l3 = Math.floor(v / (26 * 26));
+        c = this._dictionary[l3] + this._dictionary[l2] + this._dictionary[l1];
+        this._n2l[n] = c;
+        this._l2n[c] = n;
+        n++;
+      }
+      this._l2nFill = 3;
+    }
+  },
+  l2n(l) {
+    if (!this._l2n[l]) {
+      this._fill(l.length);
+    }
+    if (!this._l2n[l]) {
+      throw new Error(`Out of bounds. Invalid column letter: ${l}`);
+    }
+    return this._l2n[l];
+  },
+  n2l(n) {
+    if (n < 1 || n > 16384) {
+      throw new Error(`${n} is out of bounds. Excel supports columns from 1 to 16384`);
+    }
+    if (!this._n2l[n]) {
+      this._fill(this._level(n));
+    }
+    return this._n2l[n];
+  },
+  // =========================================================================
+  // Address processing
+  _hash: {},
+  // check if value looks like an address
+  validateAddress(value) {
+    if (!addressRegex.test(value)) {
+      throw new Error(`Invalid Address: ${value}`);
+    }
+    return true;
+  },
+  // convert address string into structure
+  decodeAddress(value) {
+    const addr = value.length < 5 && this._hash[value];
+    if (addr) {
+      return addr;
+    }
+    let hasCol = false;
+    let col = '';
+    let colNumber = 0;
+    let hasRow = false;
+    let row = '';
+    let rowNumber = 0;
+    for (let i = 0, char; i < value.length; i++) {
+      char = value.charCodeAt(i);
+      // col should before row
+      if (!hasRow && char >= 65 && char <= 90) {
+        // 65 = 'A'.charCodeAt(0)
+        // 90 = 'Z'.charCodeAt(0)
+        hasCol = true;
+        col += value[i];
+        // colNumber starts from 1
+        colNumber = colNumber * 26 + char - 64;
+      } else if (char >= 48 && char <= 57) {
+        // 48 = '0'.charCodeAt(0)
+        // 57 = '9'.charCodeAt(0)
+        hasRow = true;
+        row += value[i];
+        // rowNumber starts from 0
+        rowNumber = rowNumber * 10 + char - 48;
+      } else if (hasRow && hasCol && char !== 36) {
+        // 36 = '$'.charCodeAt(0)
+        break;
+      }
+    }
+    if (!hasCol) {
+      colNumber = undefined;
+    } else if (colNumber > 16384) {
+      throw new Error(`Out of bounds. Invalid column letter: ${col}`);
+    }
+    if (!hasRow) {
+      rowNumber = undefined;
+    }
+
+    // in case $row$col
+    value = col + row;
+    const address = {
+      address: value,
+      col: colNumber,
+      row: rowNumber,
+      $col$row: `$${col}$${row}`
+    };
+
+    // mem fix - cache only the tl 100x100 square
+    if (colNumber <= 100 && rowNumber <= 100) {
+      this._hash[value] = address;
+      this._hash[address.$col$row] = address;
+    }
+    return address;
+  },
+  // convert r,c into structure (if only 1 arg, assume r is address string)
+  getAddress(r, c) {
+    if (c) {
+      const address = this.n2l(c) + r;
+      return this.decodeAddress(address);
+    }
+    return this.decodeAddress(r);
+  },
+  // convert [address], [tl:br] into address structures
+  decode(value) {
+    const parts = value.split(':');
+    if (parts.length === 2) {
+      const tl = this.decodeAddress(parts[0]);
+      const br = this.decodeAddress(parts[1]);
+      const result = {
+        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)
+      };
+      // reconstruct tl, br and dimensions
+      result.tl = this.n2l(result.left) + result.top;
+      result.br = this.n2l(result.right) + result.bottom;
+      result.dimensions = `${result.tl}:${result.br}`;
+      return result;
+    }
+    return this.decodeAddress(value);
+  },
+  // convert [sheetName!][$]col[$]row[[$]col[$]row] into address or range structures
+  decodeEx(value) {
+    const groups = value.match(/(?:(?:(?:'((?:[^']|'')*)')|([^'^ !]*))!)?(.*)/);
+    const sheetName = groups[1] || groups[2]; // Qouted and unqouted groups
+    const reference = groups[3]; // Remaining address
+
+    const parts = reference.split(':');
+    if (parts.length > 1) {
+      let tl = this.decodeAddress(parts[0]);
+      let br = this.decodeAddress(parts[1]);
+      const top = Math.min(tl.row, br.row);
+      const left = Math.min(tl.col, br.col);
+      const bottom = Math.max(tl.row, br.row);
+      const right = Math.max(tl.col, br.col);
+      tl = this.n2l(left) + top;
+      br = this.n2l(right) + bottom;
+      return {
+        top,
+        left,
+        bottom,
+        right,
+        sheetName,
+        tl: {
+          address: tl,
+          col: left,
+          row: top,
+          $col$row: `$${this.n2l(left)}$${top}`,
+          sheetName
+        },
+        br: {
+          address: br,
+          col: right,
+          row: bottom,
+          $col$row: `$${this.n2l(right)}$${bottom}`,
+          sheetName
+        },
+        dimensions: `${tl}:${br}`
+      };
+    }
+    if (reference.startsWith('#')) {
+      return sheetName ? {
+        sheetName,
+        error: reference
+      } : {
+        error: reference
+      };
+    }
+    const address = this.decodeAddress(reference);
+    return sheetName ? {
+      sheetName,
+      ...address
+    } : address;
+  },
+  // convert row,col into address string
+  encodeAddress(row, col) {
+    return colCache.n2l(col) + row;
+  },
+  // convert row,col into string address or t,l,b,r into range
+  encode() {
+    switch (arguments.length) {
+      case 2:
+        return colCache.encodeAddress(arguments[0], arguments[1]);
+      case 4:
+        return `${colCache.encodeAddress(arguments[0], arguments[1])}:${colCache.encodeAddress(arguments[2], arguments[3])}`;
+      default:
+        throw new Error('Can only encode with 2 or 4 arguments');
+    }
+  },
+  // return true if address is contained within range
+  inRange(range, address) {
+    const [left, top,, right, bottom] = range;
+    const [col, row] = address;
+    return col >= left && col <= right && row >= top && row <= bottom;
+  }
+};
+module.exports = colCache;
+//# sourceMappingURL=col-cache.js.map

package/dist/node_modules/exceljs/dist/es5/utils/copy-style.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const oneDepthCopy = (obj, nestKeys) => ({
+  ...obj,
+  ...nestKeys.reduce((memo, key) => {
+    if (obj[key]) memo[key] = {
+      ...obj[key]
+    };
+    return memo;
+  }, {})
+});
+const setIfExists = function (src, dst, key) {
+  let nestKeys = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+  if (src[key]) dst[key] = oneDepthCopy(src[key], nestKeys);
+};
+const isEmptyObj = obj => Object.keys(obj).length === 0;
+const copyStyle = style => {
+  if (!style) return style;
+  if (isEmptyObj(style)) return {};
+  const copied = {
+    ...style
+  };
+  setIfExists(style, copied, 'font', ['color']);
+  setIfExists(style, copied, 'alignment');
+  setIfExists(style, copied, 'protection');
+  if (style.border) {
+    setIfExists(style, copied, 'border');
+    setIfExists(style.border, copied.border, 'top', ['color']);
+    setIfExists(style.border, copied.border, 'left', ['color']);
+    setIfExists(style.border, copied.border, 'bottom', ['color']);
+    setIfExists(style.border, copied.border, 'right', ['color']);
+    setIfExists(style.border, copied.border, 'diagonal', ['color']);
+  }
+  if (style.fill) {
+    setIfExists(style, copied, 'fill', ['fgColor', 'bgColor', 'center']);
+    if (style.fill.stops) {
+      copied.fill.stops = style.fill.stops.map(s => oneDepthCopy(s, ['color']));
+    }
+  }
+  return copied;
+};
+exports.copyStyle = copyStyle;
+//# sourceMappingURL=copy-style.js.map

package/dist/node_modules/exceljs/dist/es5/utils/encryptor.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const crypto = require('crypto');
+const Encryptor = {
+  /**
+   * Calculate a hash of the concatenated buffers with the given algorithm.
+   * @param {string} algorithm - The hash algorithm.
+   * @returns {Buffer} The hash
+   */
+  hash(algorithm) {
+    const hash = crypto.createHash(algorithm);
+    for (var _len = arguments.length, buffers = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      buffers[_key - 1] = arguments[_key];
+    }
+    hash.update(Buffer.concat(buffers));
+    return hash.digest();
+  },
+  /**
+   * Convert a password into an encryption key
+   * @param {string} password - The password
+   * @param {string} hashAlgorithm - The hash algoritm
+   * @param {string} saltValue - The salt value
+   * @param {number} spinCount - The spin count
+   * @param {number} keyBits - The length of the key in bits
+   * @param {Buffer} blockKey - The block key
+   * @returns {Buffer} The encryption key
+   */
+  convertPasswordToHash(password, hashAlgorithm, saltValue, spinCount) {
+    hashAlgorithm = hashAlgorithm.toLowerCase();
+    const hashes = crypto.getHashes();
+    if (hashes.indexOf(hashAlgorithm) < 0) {
+      throw new Error(`Hash algorithm '${hashAlgorithm}' not supported!`);
+    }
+
+    // Password must be in unicode buffer
+    const passwordBuffer = Buffer.from(password, 'utf16le');
+    // Generate the initial hash
+    let key = this.hash(hashAlgorithm, Buffer.from(saltValue, 'base64'), passwordBuffer);
+    // Now regenerate until spin count
+    for (let i = 0; i < spinCount; i++) {
+      const iterator = Buffer.alloc(4);
+      // this is the 'special' element of Excel password hashing
+      // that stops us from using crypto.pbkdf2()
+      iterator.writeUInt32LE(i, 0);
+      key = this.hash(hashAlgorithm, key, iterator);
+    }
+    return key.toString('base64');
+  },
+  /**
+   * Generates cryptographically strong pseudo-random data.
+   * @param size The size argument is a number indicating the number of bytes to generate.
+   */
+  randomBytes(size) {
+    return crypto.randomBytes(size);
+  }
+};
+module.exports = Encryptor;
+//# sourceMappingURL=encryptor.js.map

package/dist/node_modules/exceljs/dist/es5/utils/iterate-stream.js

@@ -0,0 +1,46 @@
+"use strict";
+
+module.exports = async function* iterateStream(stream) {
+  const contents = [];
+  stream.on('data', data => contents.push(data));
+  let resolveStreamEndedPromise;
+  const streamEndedPromise = new Promise(resolve => resolveStreamEndedPromise = resolve);
+  let ended = false;
+  stream.on('end', () => {
+    ended = true;
+    resolveStreamEndedPromise();
+  });
+  let error = false;
+  stream.on('error', err => {
+    error = err;
+    resolveStreamEndedPromise();
+  });
+  while (!ended || contents.length > 0) {
+    if (contents.length === 0) {
+      stream.resume();
+      // eslint-disable-next-line no-await-in-loop
+      await Promise.race([once(stream, 'data'), streamEndedPromise]);
+    } else {
+      stream.pause();
+      const data = contents.shift();
+      yield data;
+    }
+    if (error) throw error;
+  }
+  resolveStreamEndedPromise();
+};
+function once(eventEmitter, type) {
+  // TODO: Use require('events').once when node v10 is dropped
+  return new Promise(resolve => {
+    let fired = false;
+    const handler = () => {
+      if (!fired) {
+        fired = true;
+        eventEmitter.removeListener(type, handler);
+        resolve();
+      }
+    };
+    eventEmitter.addListener(type, handler);
+  });
+}
+//# sourceMappingURL=iterate-stream.js.map

package/dist/node_modules/exceljs/dist/es5/utils/parse-sax.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const {
+  SaxesParser
+} = require('saxes');
+const {
+  PassThrough
+} = require('readable-stream');
+const {
+  bufferToString
+} = require('./browser-buffer-decode');
+module.exports = async function* (iterable) {
+  // TODO: Remove once node v8 is deprecated
+  // Detect and upgrade old streams
+  if (iterable.pipe && !iterable[Symbol.asyncIterator]) {
+    iterable = iterable.pipe(new PassThrough());
+  }
+  const saxesParser = new SaxesParser();
+  let error;
+  saxesParser.on('error', err => {
+    error = err;
+  });
+  let events = [];
+  saxesParser.on('opentag', value => events.push({
+    eventType: 'opentag',
+    value
+  }));
+  saxesParser.on('text', value => events.push({
+    eventType: 'text',
+    value
+  }));
+  saxesParser.on('closetag', value => events.push({
+    eventType: 'closetag',
+    value
+  }));
+  for await (const chunk of iterable) {
+    saxesParser.write(bufferToString(chunk));
+    // saxesParser.write and saxesParser.on() are synchronous,
+    // so we can only reach the below line once all events have been emitted
+    if (error) throw error;
+    // As a performance optimization, we gather all events instead of passing
+    // them one by one, which would cause each event to go through the event queue
+    yield events;
+    events = [];
+  }
+};
+//# sourceMappingURL=parse-sax.js.map

package/dist/node_modules/exceljs/dist/es5/utils/shared-formula.js

@@ -0,0 +1,42 @@
+"use strict";
+
+const colCache = require('./col-cache');
+
+// const cellRefRegex = /(([a-z_\-0-9]*)!)?[$]?([a-z]+)[$]?([1-9][0-9]*)/i;
+const replacementCandidateRx = /(([a-z_\-0-9]*)!)?([a-z0-9_$]{2,})([(])?/gi;
+const CRrx = /^([$])?([a-z]+)([$])?([1-9][0-9]*)$/i;
+function slideFormula(formula, fromCell, toCell) {
+  const offset = colCache.decode(fromCell);
+  const to = colCache.decode(toCell);
+  return formula.replace(replacementCandidateRx, (refMatch, sheet, sheetMaybe, addrPart, trailingParen) => {
+    if (trailingParen) {
+      return refMatch;
+    }
+    const match = CRrx.exec(addrPart);
+    if (match) {
+      const colDollar = match[1];
+      const colStr = match[2].toUpperCase();
+      const rowDollar = match[3];
+      const rowStr = match[4];
+      if (colStr.length > 3 || colStr.length === 3 && colStr > 'XFD') {
+        // > XFD is the highest col number in excel 2007 and beyond, so this is a named range
+        return refMatch;
+      }
+      let col = colCache.l2n(colStr);
+      let row = parseInt(rowStr, 10);
+      if (!colDollar) {
+        col += to.col - offset.col;
+      }
+      if (!rowDollar) {
+        row += to.row - offset.row;
+      }
+      const res = (sheet || '') + (colDollar || '') + colCache.n2l(col) + (rowDollar || '') + row;
+      return res;
+    }
+    return refMatch;
+  });
+}
+module.exports = {
+  slideFormula
+};
+//# sourceMappingURL=shared-formula.js.map

package/dist/node_modules/exceljs/dist/es5/utils/shared-strings.js

@@ -0,0 +1,32 @@
+"use strict";
+
+class SharedStrings {
+  constructor() {
+    this._values = [];
+    this._totalRefs = 0;
+    this._hash = Object.create(null);
+  }
+  get count() {
+    return this._values.length;
+  }
+  get values() {
+    return this._values;
+  }
+  get totalRefs() {
+    return this._totalRefs;
+  }
+  getString(index) {
+    return this._values[index];
+  }
+  add(value) {
+    let index = this._hash[value];
+    if (index === undefined) {
+      index = this._hash[value] = this._values.length;
+      this._values.push(value);
+    }
+    this._totalRefs++;
+    return index;
+  }
+}
+module.exports = SharedStrings;
+//# sourceMappingURL=shared-strings.js.map