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

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

@@ -0,0 +1,46 @@
+"use strict";
+
+const _ = require('../../../utils/under-dash');
+const BaseXform = require('../base-xform');
+class PageMarginsXform extends BaseXform {
+  get tag() {
+    return 'pageMargins';
+  }
+  render(xmlStream, model) {
+    if (model) {
+      const attributes = {
+        left: model.left,
+        right: model.right,
+        top: model.top,
+        bottom: model.bottom,
+        header: model.header,
+        footer: model.footer
+      };
+      if (_.some(attributes, value => value !== undefined)) {
+        xmlStream.leafNode(this.tag, attributes);
+      }
+    }
+  }
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.model = {
+          left: parseFloat(node.attributes.left || 0.7),
+          right: parseFloat(node.attributes.right || 0.7),
+          top: parseFloat(node.attributes.top || 0.75),
+          bottom: parseFloat(node.attributes.bottom || 0.75),
+          header: parseFloat(node.attributes.header || 0.3),
+          footer: parseFloat(node.attributes.footer || 0.3)
+        };
+        return true;
+      default:
+        return false;
+    }
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = PageMarginsXform;
+//# sourceMappingURL=page-margins-xform.js.map

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

@@ -0,0 +1,32 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+class PageSetupPropertiesXform extends BaseXform {
+  get tag() {
+    return 'pageSetUpPr';
+  }
+  render(xmlStream, model) {
+    if (model && model.fitToPage) {
+      xmlStream.leafNode(this.tag, {
+        fitToPage: model.fitToPage ? '1' : undefined
+      });
+      return true;
+    }
+    return false;
+  }
+  parseOpen(node) {
+    if (node.name === this.tag) {
+      this.model = {
+        fitToPage: node.attributes.fitToPage === '1'
+      };
+      return true;
+    }
+    return false;
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = PageSetupPropertiesXform;
+//# sourceMappingURL=page-setup-properties-xform.js.map

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

@@ -0,0 +1,99 @@
+"use strict";
+
+const _ = require('../../../utils/under-dash');
+const BaseXform = require('../base-xform');
+function booleanToXml(model) {
+  return model ? '1' : undefined;
+}
+function pageOrderToXml(model) {
+  switch (model) {
+    case 'overThenDown':
+      return model;
+    default:
+      return undefined;
+  }
+}
+function cellCommentsToXml(model) {
+  switch (model) {
+    case 'atEnd':
+    case 'asDisplyed':
+      return model;
+    default:
+      return undefined;
+  }
+}
+function errorsToXml(model) {
+  switch (model) {
+    case 'dash':
+    case 'blank':
+    case 'NA':
+      return model;
+    default:
+      return undefined;
+  }
+}
+function pageSizeToModel(value) {
+  return value !== undefined ? parseInt(value, 10) : undefined;
+}
+class PageSetupXform extends BaseXform {
+  get tag() {
+    return 'pageSetup';
+  }
+  render(xmlStream, model) {
+    if (model) {
+      const attributes = {
+        paperSize: model.paperSize,
+        orientation: model.orientation,
+        horizontalDpi: model.horizontalDpi,
+        verticalDpi: model.verticalDpi,
+        pageOrder: pageOrderToXml(model.pageOrder),
+        blackAndWhite: booleanToXml(model.blackAndWhite),
+        draft: booleanToXml(model.draft),
+        cellComments: cellCommentsToXml(model.cellComments),
+        errors: errorsToXml(model.errors),
+        scale: model.scale,
+        fitToWidth: model.fitToWidth,
+        fitToHeight: model.fitToHeight,
+        firstPageNumber: model.firstPageNumber,
+        useFirstPageNumber: booleanToXml(model.firstPageNumber),
+        usePrinterDefaults: booleanToXml(model.usePrinterDefaults),
+        copies: model.copies
+      };
+      if (_.some(attributes, value => value !== undefined)) {
+        xmlStream.leafNode(this.tag, attributes);
+      }
+    }
+  }
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.model = {
+          paperSize: pageSizeToModel(node.attributes.paperSize),
+          orientation: node.attributes.orientation || 'portrait',
+          horizontalDpi: parseInt(node.attributes.horizontalDpi || '4294967295', 10),
+          verticalDpi: parseInt(node.attributes.verticalDpi || '4294967295', 10),
+          pageOrder: node.attributes.pageOrder || 'downThenOver',
+          blackAndWhite: node.attributes.blackAndWhite === '1',
+          draft: node.attributes.draft === '1',
+          cellComments: node.attributes.cellComments || 'None',
+          errors: node.attributes.errors || 'displayed',
+          scale: parseInt(node.attributes.scale || '100', 10),
+          fitToWidth: parseInt(node.attributes.fitToWidth || '1', 10),
+          fitToHeight: parseInt(node.attributes.fitToHeight || '1', 10),
+          firstPageNumber: parseInt(node.attributes.firstPageNumber || '1', 10),
+          useFirstPageNumber: node.attributes.useFirstPageNumber === '1',
+          usePrinterDefaults: node.attributes.usePrinterDefaults === '1',
+          copies: parseInt(node.attributes.copies || '1', 10)
+        };
+        return true;
+      default:
+        return false;
+    }
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = PageSetupXform;
+//# sourceMappingURL=page-setup-xform.js.map

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

@@ -0,0 +1,32 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+class PictureXform extends BaseXform {
+  get tag() {
+    return 'picture';
+  }
+  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 = PictureXform;
+//# sourceMappingURL=picture-xform.js.map

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

@@ -0,0 +1,45 @@
+"use strict";
+
+const _ = require('../../../utils/under-dash');
+const BaseXform = require('../base-xform');
+function booleanToXml(model) {
+  return model ? '1' : undefined;
+}
+class PrintOptionsXform extends BaseXform {
+  get tag() {
+    return 'printOptions';
+  }
+  render(xmlStream, model) {
+    if (model) {
+      const attributes = {
+        headings: booleanToXml(model.showRowColHeaders),
+        gridLines: booleanToXml(model.showGridLines),
+        horizontalCentered: booleanToXml(model.horizontalCentered),
+        verticalCentered: booleanToXml(model.verticalCentered)
+      };
+      if (_.some(attributes, value => value !== undefined)) {
+        xmlStream.leafNode(this.tag, attributes);
+      }
+    }
+  }
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.model = {
+          showRowColHeaders: node.attributes.headings === '1',
+          showGridLines: node.attributes.gridLines === '1',
+          horizontalCentered: node.attributes.horizontalCentered === '1',
+          verticalCentered: node.attributes.verticalCentered === '1'
+        };
+        return true;
+      default:
+        return false;
+    }
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = PrintOptionsXform;
+//# sourceMappingURL=print-options-xform.js.map

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

@@ -0,0 +1,37 @@
+'use strict';
+
+const PageBreaksXform = require('./page-breaks-xform');
+const ListXform = require('../list-xform');
+class RowBreaksXform extends ListXform {
+  constructor() {
+    const options = {
+      tag: 'rowBreaks',
+      count: true,
+      childXform: new PageBreaksXform()
+    };
+    super(options);
+  }
+
+  // get tag() { return 'rowBreaks'; }
+
+  render(xmlStream, model) {
+    if (model && model.length) {
+      xmlStream.openNode(this.tag, this.$);
+      if (this.count) {
+        xmlStream.addAttribute(this.$count, model.length);
+        xmlStream.addAttribute('manualBreakCount', model.length);
+      }
+      const {
+        childXform
+      } = this;
+      model.forEach(childModel => {
+        childXform.render(xmlStream, childModel);
+      });
+      xmlStream.closeNode();
+    } else if (this.empty) {
+      xmlStream.leafNode(this.tag);
+    }
+  }
+}
+module.exports = RowBreaksXform;
+//# sourceMappingURL=row-breaks-xform.js.map

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

@@ -0,0 +1,128 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+const utils = require('../../../utils/utils');
+const CellXform = require('./cell-xform');
+class RowXform extends BaseXform {
+  constructor(options) {
+    super();
+    this.maxItems = options && options.maxItems;
+    this.map = {
+      c: new CellXform()
+    };
+  }
+  get tag() {
+    return 'row';
+  }
+  prepare(model, options) {
+    const styleId = options.styles.addStyleModel(model.style);
+    if (styleId) {
+      model.styleId = styleId;
+    }
+    const cellXform = this.map.c;
+    model.cells.forEach(cellModel => {
+      cellXform.prepare(cellModel, options);
+    });
+  }
+  render(xmlStream, model, options) {
+    xmlStream.openNode('row');
+    xmlStream.addAttribute('r', model.number);
+    if (model.height) {
+      xmlStream.addAttribute('ht', model.height);
+      xmlStream.addAttribute('customHeight', '1');
+    }
+    if (model.hidden) {
+      xmlStream.addAttribute('hidden', '1');
+    }
+    if (model.min > 0 && model.max > 0 && model.min <= model.max) {
+      xmlStream.addAttribute('spans', `${model.min}:${model.max}`);
+    }
+    if (model.styleId) {
+      xmlStream.addAttribute('s', model.styleId);
+      xmlStream.addAttribute('customFormat', '1');
+    }
+    xmlStream.addAttribute('x14ac:dyDescent', '0.25');
+    if (model.outlineLevel) {
+      xmlStream.addAttribute('outlineLevel', model.outlineLevel);
+    }
+    if (model.collapsed) {
+      xmlStream.addAttribute('collapsed', '1');
+    }
+    const cellXform = this.map.c;
+    model.cells.forEach(cellModel => {
+      cellXform.render(xmlStream, cellModel, options);
+    });
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    if (node.name === 'row') {
+      this.numRowsSeen += 1;
+      const spans = node.attributes.spans ? node.attributes.spans.split(':').map(span => parseInt(span, 10)) : [undefined, undefined];
+      const model = this.model = {
+        number: parseInt(node.attributes.r, 10),
+        min: spans[0],
+        max: spans[1],
+        cells: []
+      };
+      if (node.attributes.s) {
+        model.styleId = parseInt(node.attributes.s, 10);
+      }
+      if (utils.parseBoolean(node.attributes.hidden)) {
+        model.hidden = true;
+      }
+      if (utils.parseBoolean(node.attributes.bestFit)) {
+        model.bestFit = true;
+      }
+      if (node.attributes.ht) {
+        model.height = parseFloat(node.attributes.ht);
+      }
+      if (node.attributes.outlineLevel) {
+        model.outlineLevel = parseInt(node.attributes.outlineLevel, 10);
+      }
+      if (utils.parseBoolean(node.attributes.collapsed)) {
+        model.collapsed = true;
+      }
+      return true;
+    }
+    this.parser = this.map[node.name];
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    return false;
+  }
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.model.cells.push(this.parser.model);
+        if (this.maxItems && this.model.cells.length > this.maxItems) {
+          throw new Error(`Max column count (${this.maxItems}) exceeded`);
+        }
+        this.parser = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+  reconcile(model, options) {
+    model.style = model.styleId ? options.styles.getStyleModel(model.styleId) : {};
+    if (model.styleId !== undefined) {
+      model.styleId = undefined;
+    }
+    const cellXform = this.map.c;
+    model.cells.forEach(cellModel => {
+      cellXform.reconcile(cellModel, options);
+    });
+  }
+}
+module.exports = RowXform;
+//# sourceMappingURL=row-xform.js.map

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

@@ -0,0 +1,51 @@
+"use strict";
+
+const _ = require('../../../utils/under-dash');
+const BaseXform = require('../base-xform');
+class SheetFormatPropertiesXform extends BaseXform {
+  get tag() {
+    return 'sheetFormatPr';
+  }
+  render(xmlStream, model) {
+    if (model) {
+      const attributes = {
+        defaultRowHeight: model.defaultRowHeight,
+        outlineLevelRow: model.outlineLevelRow,
+        outlineLevelCol: model.outlineLevelCol,
+        'x14ac:dyDescent': model.dyDescent
+      };
+      if (model.defaultColWidth) {
+        attributes.defaultColWidth = model.defaultColWidth;
+      }
+
+      // default value for 'defaultRowHeight' is 15, this should not be 'custom'
+      if (!model.defaultRowHeight || model.defaultRowHeight !== 15) {
+        attributes.customHeight = '1';
+      }
+      if (_.some(attributes, value => value !== undefined)) {
+        xmlStream.leafNode('sheetFormatPr', attributes);
+      }
+    }
+  }
+  parseOpen(node) {
+    if (node.name === 'sheetFormatPr') {
+      this.model = {
+        defaultRowHeight: parseFloat(node.attributes.defaultRowHeight || '0'),
+        dyDescent: parseFloat(node.attributes['x14ac:dyDescent'] || '0'),
+        outlineLevelRow: parseInt(node.attributes.outlineLevelRow || '0', 10),
+        outlineLevelCol: parseInt(node.attributes.outlineLevelCol || '0', 10)
+      };
+      if (node.attributes.defaultColWidth) {
+        this.model.defaultColWidth = parseFloat(node.attributes.defaultColWidth);
+      }
+      return true;
+    }
+    return false;
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = SheetFormatPropertiesXform;
+//# sourceMappingURL=sheet-format-properties-xform.js.map

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

@@ -0,0 +1,83 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+const ColorXform = require('../style/color-xform');
+const PageSetupPropertiesXform = require('./page-setup-properties-xform');
+const OutlinePropertiesXform = require('./outline-properties-xform');
+class SheetPropertiesXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      tabColor: new ColorXform('tabColor'),
+      pageSetUpPr: new PageSetupPropertiesXform(),
+      outlinePr: new OutlinePropertiesXform()
+    };
+  }
+  get tag() {
+    return 'sheetPr';
+  }
+  render(xmlStream, model) {
+    if (model) {
+      xmlStream.addRollback();
+      xmlStream.openNode('sheetPr');
+      let inner = false;
+      inner = this.map.tabColor.render(xmlStream, model.tabColor) || inner;
+      inner = this.map.pageSetUpPr.render(xmlStream, model.pageSetup) || inner;
+      inner = this.map.outlinePr.render(xmlStream, model.outlineProperties) || inner;
+      if (inner) {
+        xmlStream.closeNode();
+        xmlStream.commit();
+      } else {
+        xmlStream.rollback();
+      }
+    }
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    if (node.name === this.tag) {
+      this.reset();
+      return true;
+    }
+    if (this.map[node.name]) {
+      this.parser = this.map[node.name];
+      this.parser.parseOpen(node);
+      return true;
+    }
+    return false;
+  }
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+      return true;
+    }
+    return false;
+  }
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.parser = undefined;
+      }
+      return true;
+    }
+    if (this.map.tabColor.model || this.map.pageSetUpPr.model || this.map.outlinePr.model) {
+      this.model = {};
+      if (this.map.tabColor.model) {
+        this.model.tabColor = this.map.tabColor.model;
+      }
+      if (this.map.pageSetUpPr.model) {
+        this.model.pageSetup = this.map.pageSetUpPr.model;
+      }
+      if (this.map.outlinePr.model) {
+        this.model.outlineProperties = this.map.outlinePr.model;
+      }
+    } else {
+      this.model = null;
+    }
+    return false;
+  }
+}
+module.exports = SheetPropertiesXform;
+//# sourceMappingURL=sheet-properties-xform.js.map

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

@@ -0,0 +1,84 @@
+"use strict";
+
+const _ = require('../../../utils/under-dash');
+const BaseXform = require('../base-xform');
+function booleanToXml(model, value) {
+  return model ? value : undefined;
+}
+function xmlToBoolean(value, equals) {
+  return value === equals ? true : undefined;
+}
+class SheetProtectionXform extends BaseXform {
+  get tag() {
+    return 'sheetProtection';
+  }
+  render(xmlStream, model) {
+    if (model) {
+      const attributes = {
+        sheet: booleanToXml(model.sheet, '1'),
+        selectLockedCells: model.selectLockedCells === false ? '1' : undefined,
+        selectUnlockedCells: model.selectUnlockedCells === false ? '1' : undefined,
+        formatCells: booleanToXml(model.formatCells, '0'),
+        formatColumns: booleanToXml(model.formatColumns, '0'),
+        formatRows: booleanToXml(model.formatRows, '0'),
+        insertColumns: booleanToXml(model.insertColumns, '0'),
+        insertRows: booleanToXml(model.insertRows, '0'),
+        insertHyperlinks: booleanToXml(model.insertHyperlinks, '0'),
+        deleteColumns: booleanToXml(model.deleteColumns, '0'),
+        deleteRows: booleanToXml(model.deleteRows, '0'),
+        sort: booleanToXml(model.sort, '0'),
+        autoFilter: booleanToXml(model.autoFilter, '0'),
+        pivotTables: booleanToXml(model.pivotTables, '0')
+      };
+      if (model.sheet) {
+        attributes.algorithmName = model.algorithmName;
+        attributes.hashValue = model.hashValue;
+        attributes.saltValue = model.saltValue;
+        attributes.spinCount = model.spinCount;
+        attributes.objects = booleanToXml(model.objects === false, '1');
+        attributes.scenarios = booleanToXml(model.scenarios === false, '1');
+      }
+      if (_.some(attributes, value => value !== undefined)) {
+        xmlStream.leafNode(this.tag, attributes);
+      }
+    }
+  }
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.model = {
+          sheet: xmlToBoolean(node.attributes.sheet, '1'),
+          objects: node.attributes.objects === '1' ? false : undefined,
+          scenarios: node.attributes.scenarios === '1' ? false : undefined,
+          selectLockedCells: node.attributes.selectLockedCells === '1' ? false : undefined,
+          selectUnlockedCells: node.attributes.selectUnlockedCells === '1' ? false : undefined,
+          formatCells: xmlToBoolean(node.attributes.formatCells, '0'),
+          formatColumns: xmlToBoolean(node.attributes.formatColumns, '0'),
+          formatRows: xmlToBoolean(node.attributes.formatRows, '0'),
+          insertColumns: xmlToBoolean(node.attributes.insertColumns, '0'),
+          insertRows: xmlToBoolean(node.attributes.insertRows, '0'),
+          insertHyperlinks: xmlToBoolean(node.attributes.insertHyperlinks, '0'),
+          deleteColumns: xmlToBoolean(node.attributes.deleteColumns, '0'),
+          deleteRows: xmlToBoolean(node.attributes.deleteRows, '0'),
+          sort: xmlToBoolean(node.attributes.sort, '0'),
+          autoFilter: xmlToBoolean(node.attributes.autoFilter, '0'),
+          pivotTables: xmlToBoolean(node.attributes.pivotTables, '0')
+        };
+        if (node.attributes.algorithmName) {
+          this.model.algorithmName = node.attributes.algorithmName;
+          this.model.hashValue = node.attributes.hashValue;
+          this.model.saltValue = node.attributes.saltValue;
+          this.model.spinCount = parseInt(node.attributes.spinCount, 10);
+        }
+        return true;
+      default:
+        return false;
+    }
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = SheetProtectionXform;
+//# sourceMappingURL=sheet-protection-xform.js.map