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

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

@@ -0,0 +1,175 @@
+'use strict';
+
+const ColorXform = require('./color-xform');
+const BooleanXform = require('../simple/boolean-xform');
+const IntegerXform = require('../simple/integer-xform');
+const StringXform = require('../simple/string-xform');
+const UnderlineXform = require('./underline-xform');
+const _ = require('../../../utils/under-dash');
+const BaseXform = require('../base-xform');
+
+// Font encapsulates translation from font model to xlsx
+class FontXform extends BaseXform {
+  constructor(options) {
+    super();
+    this.options = options || FontXform.OPTIONS;
+    this.map = {
+      b: {
+        prop: 'bold',
+        xform: new BooleanXform({
+          tag: 'b',
+          attr: 'val'
+        })
+      },
+      i: {
+        prop: 'italic',
+        xform: new BooleanXform({
+          tag: 'i',
+          attr: 'val'
+        })
+      },
+      u: {
+        prop: 'underline',
+        xform: new UnderlineXform()
+      },
+      charset: {
+        prop: 'charset',
+        xform: new IntegerXform({
+          tag: 'charset',
+          attr: 'val'
+        })
+      },
+      color: {
+        prop: 'color',
+        xform: new ColorXform()
+      },
+      condense: {
+        prop: 'condense',
+        xform: new BooleanXform({
+          tag: 'condense',
+          attr: 'val'
+        })
+      },
+      extend: {
+        prop: 'extend',
+        xform: new BooleanXform({
+          tag: 'extend',
+          attr: 'val'
+        })
+      },
+      family: {
+        prop: 'family',
+        xform: new IntegerXform({
+          tag: 'family',
+          attr: 'val'
+        })
+      },
+      outline: {
+        prop: 'outline',
+        xform: new BooleanXform({
+          tag: 'outline',
+          attr: 'val'
+        })
+      },
+      vertAlign: {
+        prop: 'vertAlign',
+        xform: new StringXform({
+          tag: 'vertAlign',
+          attr: 'val'
+        })
+      },
+      scheme: {
+        prop: 'scheme',
+        xform: new StringXform({
+          tag: 'scheme',
+          attr: 'val'
+        })
+      },
+      shadow: {
+        prop: 'shadow',
+        xform: new BooleanXform({
+          tag: 'shadow',
+          attr: 'val'
+        })
+      },
+      strike: {
+        prop: 'strike',
+        xform: new BooleanXform({
+          tag: 'strike',
+          attr: 'val'
+        })
+      },
+      sz: {
+        prop: 'size',
+        xform: new IntegerXform({
+          tag: 'sz',
+          attr: 'val'
+        })
+      }
+    };
+    this.map[this.options.fontNameTag] = {
+      prop: 'name',
+      xform: new StringXform({
+        tag: this.options.fontNameTag,
+        attr: 'val'
+      })
+    };
+  }
+  get tag() {
+    return this.options.tagName;
+  }
+  render(xmlStream, model) {
+    const {
+      map
+    } = this;
+    xmlStream.openNode(this.options.tagName);
+    _.each(this.map, (defn, tag) => {
+      map[tag].xform.render(xmlStream, model[defn.prop]);
+    });
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    if (this.map[node.name]) {
+      this.parser = this.map[node.name].xform;
+      return this.parser.parseOpen(node);
+    }
+    switch (node.name) {
+      case this.options.tagName:
+        this.model = {};
+        return true;
+      default:
+        return false;
+    }
+  }
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+  parseClose(name) {
+    if (this.parser && !this.parser.parseClose(name)) {
+      const item = this.map[name];
+      if (this.parser.model) {
+        this.model[item.prop] = this.parser.model;
+      }
+      this.parser = undefined;
+      return true;
+    }
+    switch (name) {
+      case this.options.tagName:
+        return false;
+      default:
+        return true;
+    }
+  }
+}
+FontXform.OPTIONS = {
+  tagName: 'font',
+  fontNameTag: 'name'
+};
+module.exports = FontXform;
+//# sourceMappingURL=font-xform.js.map

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

@@ -0,0 +1,59 @@
+"use strict";
+
+const _ = require('../../../utils/under-dash');
+const defaultNumFormats = require('../../defaultnumformats');
+const BaseXform = require('../base-xform');
+function hashDefaultFormats() {
+  const hash = {};
+  _.each(defaultNumFormats, (dnf, id) => {
+    if (dnf.f) {
+      hash[dnf.f] = parseInt(id, 10);
+    }
+    // at some point, add the other cultures here...
+  });
+
+  return hash;
+}
+const defaultFmtHash = hashDefaultFormats();
+
+// NumFmt encapsulates translation between number format and xlsx
+class NumFmtXform extends BaseXform {
+  constructor(id, formatCode) {
+    super();
+    this.id = id;
+    this.formatCode = formatCode;
+  }
+  get tag() {
+    return 'numFmt';
+  }
+  render(xmlStream, model) {
+    xmlStream.leafNode('numFmt', {
+      numFmtId: model.id,
+      formatCode: model.formatCode
+    });
+  }
+  parseOpen(node) {
+    switch (node.name) {
+      case 'numFmt':
+        this.model = {
+          id: parseInt(node.attributes.numFmtId, 10),
+          formatCode: node.attributes.formatCode.replace(/[\\](.)/g, '$1')
+        };
+        return true;
+      default:
+        return false;
+    }
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+NumFmtXform.getDefaultFmtId = function getDefaultFmtId(formatCode) {
+  return defaultFmtHash[formatCode];
+};
+NumFmtXform.getDefaultFmtCode = function getDefaultFmtCode(numFmtId) {
+  return defaultNumFormats[numFmtId] && defaultNumFormats[numFmtId].f;
+};
+module.exports = NumFmtXform;
+//# sourceMappingURL=numfmt-xform.js.map

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

@@ -0,0 +1,53 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+const validation = {
+  boolean(value, dflt) {
+    if (value === undefined) {
+      return dflt;
+    }
+    return value;
+  }
+};
+
+// Protection encapsulates translation from style.protection model to/from xlsx
+class ProtectionXform extends BaseXform {
+  get tag() {
+    return 'protection';
+  }
+  render(xmlStream, model) {
+    xmlStream.addRollback();
+    xmlStream.openNode('protection');
+    let isValid = false;
+    function add(name, value) {
+      if (value !== undefined) {
+        xmlStream.addAttribute(name, value);
+        isValid = true;
+      }
+    }
+    add('locked', validation.boolean(model.locked, true) ? undefined : '0');
+    add('hidden', validation.boolean(model.hidden, false) ? '1' : undefined);
+    xmlStream.closeNode();
+    if (isValid) {
+      xmlStream.commit();
+    } else {
+      xmlStream.rollback();
+    }
+  }
+  parseOpen(node) {
+    const model = {
+      locked: !(node.attributes.locked === '0'),
+      hidden: node.attributes.hidden === '1'
+    };
+
+    // only want to record models that differ from defaults
+    const isSignificant = !model.locked || model.hidden;
+    this.model = isSignificant ? model : null;
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = ProtectionXform;
+//# sourceMappingURL=protection-xform.js.map

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

@@ -0,0 +1,118 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+const AlignmentXform = require('./alignment-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 StyleXform extends BaseXform {
+  constructor(options) {
+    super();
+    this.xfId = !!(options && options.xfId);
+    this.map = {
+      alignment: new AlignmentXform(),
+      protection: new ProtectionXform()
+    };
+  }
+  get tag() {
+    return 'xf';
+  }
+  render(xmlStream, model) {
+    xmlStream.openNode('xf', {
+      numFmtId: model.numFmtId || 0,
+      fontId: model.fontId || 0,
+      fillId: model.fillId || 0,
+      borderId: model.borderId || 0
+    });
+    if (this.xfId) {
+      xmlStream.addAttribute('xfId', model.xfId || 0);
+    }
+    if (model.numFmtId) {
+      xmlStream.addAttribute('applyNumberFormat', '1');
+    }
+    if (model.fontId) {
+      xmlStream.addAttribute('applyFont', '1');
+    }
+    if (model.fillId) {
+      xmlStream.addAttribute('applyFill', '1');
+    }
+    if (model.borderId) {
+      xmlStream.addAttribute('applyBorder', '1');
+    }
+    if (model.alignment) {
+      xmlStream.addAttribute('applyAlignment', '1');
+    }
+    if (model.protection) {
+      xmlStream.addAttribute('applyProtection', '1');
+    }
+
+    /**
+     * Rendering tags causes close of XML stream.
+     * Therefore adding attributes must be done before rendering tags.
+     */
+
+    if (model.alignment) {
+      this.map.alignment.render(xmlStream, model.alignment);
+    }
+    if (model.protection) {
+      this.map.protection.render(xmlStream, model.protection);
+    }
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    // used during sax parsing of xml to build font object
+    switch (node.name) {
+      case 'xf':
+        this.model = {
+          numFmtId: parseInt(node.attributes.numFmtId, 10),
+          fontId: parseInt(node.attributes.fontId, 10),
+          fillId: parseInt(node.attributes.fillId, 10),
+          borderId: parseInt(node.attributes.borderId, 10)
+        };
+        if (this.xfId) {
+          this.model.xfId = parseInt(node.attributes.xfId, 10);
+        }
+        return true;
+      case 'alignment':
+        this.parser = this.map.alignment;
+        this.parser.parseOpen(node);
+        return true;
+      case 'protection':
+        this.parser = this.map.protection;
+        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)) {
+        if (this.map.protection === this.parser) {
+          this.model.protection = this.parser.model;
+        } else {
+          this.model.alignment = this.parser.model;
+        }
+        this.parser = undefined;
+      }
+      return true;
+    }
+    return name !== 'xf';
+  }
+}
+module.exports = StyleXform;
+//# sourceMappingURL=style-xform.js.map