@nocobase/plugin-action-export 1.7.0-beta.32 → 1.7.0-beta.34

package/dist/externalVersion.js

@@ -10,16 +10,17 @@
 module.exports = {
   "@formily/react": "2.3.0",
   "@formily/shared": "2.3.2",
-  "@nocobase/client": "1.7.0-beta.32",
+  "@nocobase/client": "1.7.0-beta.34",
   "react": "18.2.0",
   "@formily/antd-v5": "1.2.3",
   "react-i18next": "11.18.6",
   "lodash": "4.17.21",
   "file-saver": "2.0.5",
   "antd": "5.24.2",
-  "@nocobase/server": "1.7.0-beta.32",
-  "@nocobase/actions": "1.7.0-beta.32",
-  "@nocobase/database": "1.7.0-beta.32",
+  "@nocobase/server": "1.7.0-beta.34",
+  "@nocobase/logger": "1.7.0-beta.34",
+  "@nocobase/actions": "1.7.0-beta.34",
+  "@nocobase/database": "1.7.0-beta.34",
   "async-mutex": "0.5.0",
-  "@nocobase/data-source-manager": "1.7.0-beta.32"
+  "@nocobase/data-source-manager": "1.7.0-beta.34"
 };

package/dist/node_modules/exceljs/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2019 Guyon Roche
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/dist/node_modules/exceljs/dist/es5/csv/csv.js

@@ -0,0 +1,182 @@
+"use strict";
+
+const fs = require('fs');
+const fastCsv = require('fast-csv');
+const customParseFormat = require('dayjs/plugin/customParseFormat');
+const utc = require('dayjs/plugin/utc');
+const dayjs = require('dayjs').extend(customParseFormat).extend(utc);
+const StreamBuf = require('../utils/stream-buf');
+const {
+  fs: {
+    exists
+  }
+} = require('../utils/utils');
+
+/* eslint-disable quote-props */
+const SpecialValues = {
+  true: true,
+  false: false,
+  '#N/A': {
+    error: '#N/A'
+  },
+  '#REF!': {
+    error: '#REF!'
+  },
+  '#NAME?': {
+    error: '#NAME?'
+  },
+  '#DIV/0!': {
+    error: '#DIV/0!'
+  },
+  '#NULL!': {
+    error: '#NULL!'
+  },
+  '#VALUE!': {
+    error: '#VALUE!'
+  },
+  '#NUM!': {
+    error: '#NUM!'
+  }
+};
+/* eslint-ensable quote-props */
+
+class CSV {
+  constructor(workbook) {
+    this.workbook = workbook;
+    this.worksheet = null;
+  }
+  async readFile(filename, options) {
+    options = options || {};
+    if (!(await exists(filename))) {
+      throw new Error(`File not found: ${filename}`);
+    }
+    const stream = fs.createReadStream(filename);
+    const worksheet = await this.read(stream, options);
+    stream.close();
+    return worksheet;
+  }
+  read(stream, options) {
+    options = options || {};
+    return new Promise((resolve, reject) => {
+      const worksheet = this.workbook.addWorksheet(options.sheetName);
+      const dateFormats = options.dateFormats || ['YYYY-MM-DD[T]HH:mm:ssZ', 'YYYY-MM-DD[T]HH:mm:ss', 'MM-DD-YYYY', 'YYYY-MM-DD'];
+      const map = options.map || function (datum) {
+        if (datum === '') {
+          return null;
+        }
+        const datumNumber = Number(datum);
+        if (!Number.isNaN(datumNumber) && datumNumber !== Infinity) {
+          return datumNumber;
+        }
+        const dt = dateFormats.reduce((matchingDate, currentDateFormat) => {
+          if (matchingDate) {
+            return matchingDate;
+          }
+          const dayjsObj = dayjs(datum, currentDateFormat, true);
+          if (dayjsObj.isValid()) {
+            return dayjsObj;
+          }
+          return null;
+        }, null);
+        if (dt) {
+          return new Date(dt.valueOf());
+        }
+        const special = SpecialValues[datum];
+        if (special !== undefined) {
+          return special;
+        }
+        return datum;
+      };
+      const csvStream = fastCsv.parse(options.parserOptions).on('data', data => {
+        worksheet.addRow(data.map(map));
+      }).on('end', () => {
+        csvStream.emit('worksheet', worksheet);
+      });
+      csvStream.on('worksheet', resolve).on('error', reject);
+      stream.pipe(csvStream);
+    });
+  }
+
+  /**
+   * @deprecated since version 4.0. You should use `CSV#read` instead. Please follow upgrade instruction: https://github.com/exceljs/exceljs/blob/master/UPGRADE-4.0.md
+   */
+  createInputStream() {
+    throw new Error('`CSV#createInputStream` is deprecated. You should use `CSV#read` instead. This method will be removed in version 5.0. Please follow upgrade instruction: https://github.com/exceljs/exceljs/blob/master/UPGRADE-4.0.md');
+  }
+  write(stream, options) {
+    return new Promise((resolve, reject) => {
+      options = options || {};
+      // const encoding = options.encoding || 'utf8';
+      // const separator = options.separator || ',';
+      // const quoteChar = options.quoteChar || '\'';
+
+      const worksheet = this.workbook.getWorksheet(options.sheetName || options.sheetId);
+      const csvStream = fastCsv.format(options.formatterOptions);
+      stream.on('finish', () => {
+        resolve();
+      });
+      csvStream.on('error', reject);
+      csvStream.pipe(stream);
+      const {
+        dateFormat,
+        dateUTC
+      } = options;
+      const map = options.map || (value => {
+        if (value) {
+          if (value.text || value.hyperlink) {
+            return value.hyperlink || value.text || '';
+          }
+          if (value.formula || value.result) {
+            return value.result || '';
+          }
+          if (value instanceof Date) {
+            if (dateFormat) {
+              return dateUTC ? dayjs.utc(value).format(dateFormat) : dayjs(value).format(dateFormat);
+            }
+            return dateUTC ? dayjs.utc(value).format() : dayjs(value).format();
+          }
+          if (value.error) {
+            return value.error;
+          }
+          if (typeof value === 'object') {
+            return JSON.stringify(value);
+          }
+        }
+        return value;
+      });
+      const includeEmptyRows = options.includeEmptyRows === undefined || options.includeEmptyRows;
+      let lastRow = 1;
+      if (worksheet) {
+        worksheet.eachRow((row, rowNumber) => {
+          if (includeEmptyRows) {
+            while (lastRow++ < rowNumber - 1) {
+              csvStream.write([]);
+            }
+          }
+          const {
+            values
+          } = row;
+          values.shift();
+          csvStream.write(values.map(map));
+          lastRow = rowNumber;
+        });
+      }
+      csvStream.end();
+    });
+  }
+  writeFile(filename, options) {
+    options = options || {};
+    const streamOptions = {
+      encoding: options.encoding || 'utf8'
+    };
+    const stream = fs.createWriteStream(filename, streamOptions);
+    return this.write(stream, options);
+  }
+  async writeBuffer(options) {
+    const stream = new StreamBuf();
+    await this.write(stream, options);
+    return stream.read();
+  }
+}
+module.exports = CSV;
+//# sourceMappingURL=csv.js.map

package/dist/node_modules/exceljs/dist/es5/csv/line-buffer.js

@@ -0,0 +1,68 @@
+"use strict";
+
+const {
+  EventEmitter
+} = require('events');
+class LineBuffer extends EventEmitter {
+  constructor(options) {
+    super();
+    this.encoding = options.encoding;
+    this.buffer = null;
+
+    // part of cork/uncork
+    this.corked = false;
+    this.queue = [];
+  }
+
+  // Events:
+  //  line: here is a line
+  //  done: all lines emitted
+
+  write(chunk) {
+    // find line or lines in chunk and emit them if not corked
+    // or queue them if corked
+    const data = this.buffer ? this.buffer + chunk : chunk;
+    const lines = data.split(/\r?\n/g);
+
+    // save the last line
+    this.buffer = lines.pop();
+    lines.forEach(function (line) {
+      if (this.corked) {
+        this.queue.push(line);
+      } else {
+        this.emit('line', line);
+      }
+    });
+    return !this.corked;
+  }
+  cork() {
+    this.corked = true;
+  }
+  uncork() {
+    this.corked = false;
+    this._flush();
+
+    // tell the source I'm ready again
+    this.emit('drain');
+  }
+  setDefaultEncoding() {
+    // ?
+  }
+  end() {
+    if (this.buffer) {
+      this.emit('line', this.buffer);
+      this.buffer = null;
+    }
+    this.emit('done');
+  }
+  _flush() {
+    if (!this.corked) {
+      this.queue.forEach(line => {
+        this.emit('line', line);
+      });
+      this.queue = [];
+    }
+  }
+}
+module.exports = LineBuffer;
+//# sourceMappingURL=line-buffer.js.map

package/dist/node_modules/exceljs/dist/es5/csv/stream-converter.js

@@ -0,0 +1,110 @@
+"use strict";
+
+// =======================================================================================================
+// StreamConverter
+//
+// convert between encoding schemes in a stream
+// Work in Progress - Will complete this at some point
+let jconv;
+class StreamConverter {
+  constructor(inner, options) {
+    this.inner = inner;
+    options = options || {};
+    this.innerEncoding = (options.innerEncoding || 'UTF8').toUpperCase();
+    this.outerEncoding = (options.outerEncoding || 'UTF8').toUpperCase();
+    this.innerBOM = options.innerBOM || null;
+    this.outerBOM = options.outerBOM || null;
+    this.writeStarted = false;
+  }
+  convertInwards(data) {
+    if (data) {
+      if (typeof data === 'string') {
+        data = Buffer.from(data, this.outerEncoding);
+      }
+      if (this.innerEncoding !== this.outerEncoding) {
+        data = jconv.convert(data, this.outerEncoding, this.innerEncoding);
+      }
+    }
+    return data;
+  }
+  convertOutwards(data) {
+    if (typeof data === 'string') {
+      data = Buffer.from(data, this.innerEncoding);
+    }
+    if (this.innerEncoding !== this.outerEncoding) {
+      data = jconv.convert(data, this.innerEncoding, this.outerEncoding);
+    }
+    return data;
+  }
+  addListener(event, handler) {
+    this.inner.addListener(event, handler);
+  }
+  removeListener(event, handler) {
+    this.inner.removeListener(event, handler);
+  }
+  write(data, encoding, callback) {
+    if (encoding instanceof Function) {
+      callback = encoding;
+      encoding = undefined;
+    }
+    if (!this.writeStarted) {
+      // if inner encoding has BOM, write it now
+      if (this.innerBOM) {
+        this.inner.write(this.innerBOM);
+      }
+
+      // if outer encoding has BOM, delete it now
+      if (this.outerBOM) {
+        if (data.length <= this.outerBOM.length) {
+          if (callback) {
+            callback();
+          }
+          return;
+        }
+        const bomless = Buffer.alloc(data.length - this.outerBOM.length);
+        data.copy(bomless, 0, this.outerBOM.length, data.length);
+        data = bomless;
+      }
+      this.writeStarted = true;
+    }
+    this.inner.write(this.convertInwards(data), encoding ? this.innerEncoding : undefined, callback);
+  }
+  read() {
+    // TBD
+  }
+  pipe(destination, options) {
+    const reverseConverter = new StreamConverter(destination, {
+      innerEncoding: this.outerEncoding,
+      outerEncoding: this.innerEncoding,
+      innerBOM: this.outerBOM,
+      outerBOM: this.innerBOM
+    });
+    this.inner.pipe(reverseConverter, options);
+  }
+  close() {
+    this.inner.close();
+  }
+  on(type, callback) {
+    switch (type) {
+      case 'data':
+        this.inner.on('data', chunk => {
+          callback(this.convertOutwards(chunk));
+        });
+        return this;
+      default:
+        this.inner.on(type, callback);
+        return this;
+    }
+  }
+  once(type, callback) {
+    this.inner.once(type, callback);
+  }
+  end(chunk, encoding, callback) {
+    this.inner.end(this.convertInwards(chunk), this.innerEncoding, callback);
+  }
+  emit(type, value) {
+    this.inner.emit(type, value);
+  }
+}
+module.exports = StreamConverter;
+//# sourceMappingURL=stream-converter.js.map

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

@@ -0,0 +1,73 @@
+'use strict';
+
+const colCache = require('../utils/col-cache');
+class Anchor {
+  constructor(worksheet, address) {
+    let offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    this.worksheet = worksheet;
+    if (!address) {
+      this.nativeCol = 0;
+      this.nativeColOff = 0;
+      this.nativeRow = 0;
+      this.nativeRowOff = 0;
+    } else if (typeof address === 'string') {
+      const decoded = colCache.decodeAddress(address);
+      this.nativeCol = decoded.col + offset;
+      this.nativeColOff = 0;
+      this.nativeRow = decoded.row + offset;
+      this.nativeRowOff = 0;
+    } else if (address.nativeCol !== undefined) {
+      this.nativeCol = address.nativeCol || 0;
+      this.nativeColOff = address.nativeColOff || 0;
+      this.nativeRow = address.nativeRow || 0;
+      this.nativeRowOff = address.nativeRowOff || 0;
+    } else if (address.col !== undefined) {
+      this.col = address.col + offset;
+      this.row = address.row + offset;
+    } else {
+      this.nativeCol = 0;
+      this.nativeColOff = 0;
+      this.nativeRow = 0;
+      this.nativeRowOff = 0;
+    }
+  }
+  static asInstance(model) {
+    return model instanceof Anchor || model == null ? model : new Anchor(model);
+  }
+  get col() {
+    return this.nativeCol + Math.min(this.colWidth - 1, this.nativeColOff) / this.colWidth;
+  }
+  set col(v) {
+    this.nativeCol = Math.floor(v);
+    this.nativeColOff = Math.floor((v - this.nativeCol) * this.colWidth);
+  }
+  get row() {
+    return this.nativeRow + Math.min(this.rowHeight - 1, this.nativeRowOff) / this.rowHeight;
+  }
+  set row(v) {
+    this.nativeRow = Math.floor(v);
+    this.nativeRowOff = Math.floor((v - this.nativeRow) * this.rowHeight);
+  }
+  get colWidth() {
+    return this.worksheet && this.worksheet.getColumn(this.nativeCol + 1) && this.worksheet.getColumn(this.nativeCol + 1).isCustomWidth ? Math.floor(this.worksheet.getColumn(this.nativeCol + 1).width * 10000) : 640000;
+  }
+  get rowHeight() {
+    return this.worksheet && this.worksheet.getRow(this.nativeRow + 1) && this.worksheet.getRow(this.nativeRow + 1).height ? Math.floor(this.worksheet.getRow(this.nativeRow + 1).height * 10000) : 180000;
+  }
+  get model() {
+    return {
+      nativeCol: this.nativeCol,
+      nativeColOff: this.nativeColOff,
+      nativeRow: this.nativeRow,
+      nativeRowOff: this.nativeRowOff
+    };
+  }
+  set model(value) {
+    this.nativeCol = value.nativeCol;
+    this.nativeColOff = value.nativeColOff;
+    this.nativeRow = value.nativeRow;
+    this.nativeRowOff = value.nativeRowOff;
+  }
+}
+module.exports = Anchor;
+//# sourceMappingURL=anchor.js.map