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

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/style/border-xform.js

@@ -0,0 +1,185 @@
+"use strict";
+
+/* eslint-disable max-classes-per-file */
+const BaseXform = require('../base-xform');
+const utils = require('../../../utils/utils');
+const ColorXform = require('./color-xform');
+class EdgeXform extends BaseXform {
+  constructor(name) {
+    super();
+    this.name = name;
+    this.map = {
+      color: new ColorXform()
+    };
+  }
+  get tag() {
+    return this.name;
+  }
+  render(xmlStream, model, defaultColor) {
+    const color = model && model.color || defaultColor || this.defaultColor;
+    xmlStream.openNode(this.name);
+    if (model && model.style) {
+      xmlStream.addAttribute('style', model.style);
+      if (color) {
+        this.map.color.render(xmlStream, color);
+      }
+    }
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.name:
+        {
+          const {
+            style
+          } = node.attributes;
+          if (style) {
+            this.model = {
+              style
+            };
+          } else {
+            this.model = undefined;
+          }
+          return true;
+        }
+      case 'color':
+        this.parser = this.map.color;
+        this.parser.parseOpen(node);
+        return true;
+      default:
+        return false;
+    }
+  }
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.parser = undefined;
+      }
+      return true;
+    }
+    if (name === this.name) {
+      if (this.map.color.model) {
+        if (!this.model) {
+          this.model = {};
+        }
+        this.model.color = this.map.color.model;
+      }
+    }
+    return false;
+  }
+  validStyle(value) {
+    return EdgeXform.validStyleValues[value];
+  }
+}
+EdgeXform.validStyleValues = ['thin', 'dashed', 'dotted', 'dashDot', 'hair', 'dashDotDot', 'slantDashDot', 'mediumDashed', 'mediumDashDotDot', 'mediumDashDot', 'medium', 'double', 'thick'].reduce((p, v) => {
+  p[v] = true;
+  return p;
+}, {});
+
+// Border encapsulates translation from border model to/from xlsx
+class BorderXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      top: new EdgeXform('top'),
+      left: new EdgeXform('left'),
+      bottom: new EdgeXform('bottom'),
+      right: new EdgeXform('right'),
+      diagonal: new EdgeXform('diagonal')
+    };
+  }
+  render(xmlStream, model) {
+    const {
+      color
+    } = model;
+    xmlStream.openNode('border');
+    if (model.diagonal && model.diagonal.style) {
+      if (model.diagonal.up) {
+        xmlStream.addAttribute('diagonalUp', '1');
+      }
+      if (model.diagonal.down) {
+        xmlStream.addAttribute('diagonalDown', '1');
+      }
+    }
+    function add(edgeModel, edgeXform) {
+      if (edgeModel && !edgeModel.color && model.color) {
+        // don't mess with incoming models
+        edgeModel = {
+          ...edgeModel,
+          color: model.color
+        };
+      }
+      edgeXform.render(xmlStream, edgeModel, color);
+    }
+    add(model.left, this.map.left);
+    add(model.right, this.map.right);
+    add(model.top, this.map.top);
+    add(model.bottom, this.map.bottom);
+    add(model.diagonal, this.map.diagonal);
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'border':
+        this.reset();
+        this.diagonalUp = utils.parseBoolean(node.attributes.diagonalUp);
+        this.diagonalDown = utils.parseBoolean(node.attributes.diagonalDown);
+        return true;
+      default:
+        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.parser = undefined;
+      }
+      return true;
+    }
+    if (name === 'border') {
+      const model = this.model = {};
+      const add = function (key, edgeModel, extensions) {
+        if (edgeModel) {
+          if (extensions) {
+            Object.assign(edgeModel, extensions);
+          }
+          model[key] = edgeModel;
+        }
+      };
+      add('left', this.map.left.model);
+      add('right', this.map.right.model);
+      add('top', this.map.top.model);
+      add('bottom', this.map.bottom.model);
+      add('diagonal', this.map.diagonal.model, {
+        up: this.diagonalUp,
+        down: this.diagonalDown
+      });
+    }
+    return false;
+  }
+}
+module.exports = BorderXform;
+//# sourceMappingURL=border-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/style/color-xform.js

@@ -0,0 +1,66 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+
+// Color encapsulates translation from color model to/from xlsx
+class ColorXform extends BaseXform {
+  constructor(name) {
+    super();
+
+    // this.name controls the xm node name
+    this.name = name || 'color';
+  }
+  get tag() {
+    return this.name;
+  }
+  render(xmlStream, model) {
+    if (model) {
+      xmlStream.openNode(this.name);
+      if (model.argb) {
+        xmlStream.addAttribute('rgb', model.argb);
+      } else if (model.theme !== undefined) {
+        xmlStream.addAttribute('theme', model.theme);
+        if (model.tint !== undefined) {
+          xmlStream.addAttribute('tint', model.tint);
+        }
+      } else if (model.indexed !== undefined) {
+        xmlStream.addAttribute('indexed', model.indexed);
+      } else {
+        xmlStream.addAttribute('auto', '1');
+      }
+      xmlStream.closeNode();
+      return true;
+    }
+    return false;
+  }
+  parseOpen(node) {
+    if (node.name === this.name) {
+      if (node.attributes.rgb) {
+        this.model = {
+          argb: node.attributes.rgb
+        };
+      } else if (node.attributes.theme) {
+        this.model = {
+          theme: parseInt(node.attributes.theme, 10)
+        };
+        if (node.attributes.tint) {
+          this.model.tint = parseFloat(node.attributes.tint);
+        }
+      } else if (node.attributes.indexed) {
+        this.model = {
+          indexed: parseInt(node.attributes.indexed, 10)
+        };
+      } else {
+        this.model = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = ColorXform;
+//# sourceMappingURL=color-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/style/dxf-xform.js

@@ -0,0 +1,106 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+const AlignmentXform = require('./alignment-xform');
+const BorderXform = require('./border-xform');
+const FillXform = require('./fill-xform');
+const FontXform = require('./font-xform');
+const NumFmtXform = require('./numfmt-xform');
+const ProtectionXform = require('./protection-xform');
+
+// <xf numFmtId="[numFmtId]" fontId="[fontId]" fillId="[fillId]" borderId="[xf.borderId]" xfId="[xfId]">
+//   Optional <alignment>
+//   Optional <protection>
+// </xf>
+
+// Style assists translation from style model to/from xlsx
+class DxfXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      alignment: new AlignmentXform(),
+      border: new BorderXform(),
+      fill: new FillXform(),
+      font: new FontXform(),
+      numFmt: new NumFmtXform(),
+      protection: new ProtectionXform()
+    };
+  }
+  get tag() {
+    return 'dxf';
+  }
+
+  // how do we generate dxfid?
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag);
+    if (model.font) {
+      this.map.font.render(xmlStream, model.font);
+    }
+    if (model.numFmt && model.numFmtId) {
+      const numFmtModel = {
+        id: model.numFmtId,
+        formatCode: model.numFmt
+      };
+      this.map.numFmt.render(xmlStream, numFmtModel);
+    }
+    if (model.fill) {
+      this.map.fill.render(xmlStream, model.fill);
+    }
+    if (model.alignment) {
+      this.map.alignment.render(xmlStream, model.alignment);
+    }
+    if (model.border) {
+      this.map.border.render(xmlStream, model.border);
+    }
+    if (model.protection) {
+      this.map.protection.render(xmlStream, model.protection);
+    }
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.tag:
+        // this node is often repeated. Need to reset children
+        this.reset();
+        return true;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+        }
+        return true;
+    }
+  }
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.parser = undefined;
+      }
+      return true;
+    }
+    if (name === this.tag) {
+      this.model = {
+        alignment: this.map.alignment.model,
+        border: this.map.border.model,
+        fill: this.map.fill.model,
+        font: this.map.font.model,
+        numFmt: this.map.numFmt.model,
+        protection: this.map.protection.model
+      };
+      return false;
+    }
+    return true;
+  }
+}
+module.exports = DxfXform;
+//# sourceMappingURL=dxf-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/style/fill-xform.js

@@ -0,0 +1,308 @@
+"use strict";
+
+/* eslint-disable max-classes-per-file */
+const BaseXform = require('../base-xform');
+const ColorXform = require('./color-xform');
+class StopXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      color: new ColorXform()
+    };
+  }
+  get tag() {
+    return 'stop';
+  }
+  render(xmlStream, model) {
+    xmlStream.openNode('stop');
+    xmlStream.addAttribute('position', model.position);
+    this.map.color.render(xmlStream, model.color);
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'stop':
+        this.model = {
+          position: parseFloat(node.attributes.position)
+        };
+        return true;
+      case 'color':
+        this.parser = this.map.color;
+        this.parser.parseOpen(node);
+        return true;
+      default:
+        return false;
+    }
+  }
+  parseText() {}
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.model.color = this.parser.model;
+        this.parser = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+}
+class PatternFillXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      fgColor: new ColorXform('fgColor'),
+      bgColor: new ColorXform('bgColor')
+    };
+  }
+  get name() {
+    return 'pattern';
+  }
+  get tag() {
+    return 'patternFill';
+  }
+  render(xmlStream, model) {
+    xmlStream.openNode('patternFill');
+    xmlStream.addAttribute('patternType', model.pattern);
+    if (model.fgColor) {
+      this.map.fgColor.render(xmlStream, model.fgColor);
+    }
+    if (model.bgColor) {
+      this.map.bgColor.render(xmlStream, model.bgColor);
+    }
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'patternFill':
+        this.model = {
+          type: 'pattern',
+          pattern: node.attributes.patternType
+        };
+        return true;
+      default:
+        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)) {
+        if (this.parser.model) {
+          this.model[name] = this.parser.model;
+        }
+        this.parser = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+}
+class GradientFillXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      stop: new StopXform()
+    };
+    // if (model) {
+    //   this.gradient = model.gradient;
+    //   if (model.center) {
+    //     this.center = model.center;
+    //   }
+    //   if (model.degree !== undefined) {
+    //     this.degree = model.degree;
+    //   }
+    //   this.stops = model.stops.map(function(stop) { return new StopXform(stop); });
+    // } else {
+    //   this.stops = [];
+    // }
+  }
+
+  get name() {
+    return 'gradient';
+  }
+  get tag() {
+    return 'gradientFill';
+  }
+  render(xmlStream, model) {
+    xmlStream.openNode('gradientFill');
+    switch (model.gradient) {
+      case 'angle':
+        xmlStream.addAttribute('degree', model.degree);
+        break;
+      case 'path':
+        xmlStream.addAttribute('type', 'path');
+        if (model.center.left) {
+          xmlStream.addAttribute('left', model.center.left);
+          if (model.center.right === undefined) {
+            xmlStream.addAttribute('right', model.center.left);
+          }
+        }
+        if (model.center.right) {
+          xmlStream.addAttribute('right', model.center.right);
+        }
+        if (model.center.top) {
+          xmlStream.addAttribute('top', model.center.top);
+          if (model.center.bottom === undefined) {
+            xmlStream.addAttribute('bottom', model.center.top);
+          }
+        }
+        if (model.center.bottom) {
+          xmlStream.addAttribute('bottom', model.center.bottom);
+        }
+        break;
+      default:
+        break;
+    }
+    const stopXform = this.map.stop;
+    model.stops.forEach(stopModel => {
+      stopXform.render(xmlStream, stopModel);
+    });
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'gradientFill':
+        {
+          const model = this.model = {
+            stops: []
+          };
+          if (node.attributes.degree) {
+            model.gradient = 'angle';
+            model.degree = parseInt(node.attributes.degree, 10);
+          } else if (node.attributes.type === 'path') {
+            model.gradient = 'path';
+            model.center = {
+              left: node.attributes.left ? parseFloat(node.attributes.left) : 0,
+              top: node.attributes.top ? parseFloat(node.attributes.top) : 0
+            };
+            if (node.attributes.right !== node.attributes.left) {
+              model.center.right = node.attributes.right ? parseFloat(node.attributes.right) : 0;
+            }
+            if (node.attributes.bottom !== node.attributes.top) {
+              model.center.bottom = node.attributes.bottom ? parseFloat(node.attributes.bottom) : 0;
+            }
+          }
+          return true;
+        }
+      case 'stop':
+        this.parser = this.map.stop;
+        this.parser.parseOpen(node);
+        return true;
+      default:
+        return false;
+    }
+  }
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.model.stops.push(this.parser.model);
+        this.parser = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+}
+
+// Fill encapsulates translation from fill model to/from xlsx
+class FillXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      patternFill: new PatternFillXform(),
+      gradientFill: new GradientFillXform()
+    };
+  }
+  get tag() {
+    return 'fill';
+  }
+  render(xmlStream, model) {
+    xmlStream.addRollback();
+    xmlStream.openNode('fill');
+    switch (model.type) {
+      case 'pattern':
+        this.map.patternFill.render(xmlStream, model);
+        break;
+      case 'gradient':
+        this.map.gradientFill.render(xmlStream, model);
+        break;
+      default:
+        xmlStream.rollback();
+        return;
+    }
+    xmlStream.closeNode();
+    xmlStream.commit();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'fill':
+        this.model = {};
+        return true;
+      default:
+        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 = this.parser.model;
+        this.model.type = this.parser.name;
+        this.parser = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+  validStyle(value) {
+    return FillXform.validPatternValues[value];
+  }
+}
+FillXform.validPatternValues = ['none', 'solid', 'darkVertical', 'darkGray', 'mediumGray', 'lightGray', 'gray125', 'gray0625', 'darkHorizontal', 'darkVertical', 'darkDown', 'darkUp', 'darkGrid', 'darkTrellis', 'lightHorizontal', 'lightVertical', 'lightDown', 'lightUp', 'lightGrid', 'lightTrellis', 'lightGrid'].reduce((p, v) => {
+  p[v] = true;
+  return p;
+}, {});
+FillXform.StopXform = StopXform;
+FillXform.PatternFillXform = PatternFillXform;
+FillXform.GradientFillXform = GradientFillXform;
+module.exports = FillXform;
+//# sourceMappingURL=fill-xform.js.map