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

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

@@ -0,0 +1,158 @@
+"use strict";
+
+const XmlStream = require('../../../utils/xml-stream');
+const BaseXform = require('../base-xform');
+const DateXform = require('../simple/date-xform');
+const StringXform = require('../simple/string-xform');
+const IntegerXform = require('../simple/integer-xform');
+class CoreXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      'dc:creator': new StringXform({
+        tag: 'dc:creator'
+      }),
+      'dc:title': new StringXform({
+        tag: 'dc:title'
+      }),
+      'dc:subject': new StringXform({
+        tag: 'dc:subject'
+      }),
+      'dc:description': new StringXform({
+        tag: 'dc:description'
+      }),
+      'dc:identifier': new StringXform({
+        tag: 'dc:identifier'
+      }),
+      'dc:language': new StringXform({
+        tag: 'dc:language'
+      }),
+      'cp:keywords': new StringXform({
+        tag: 'cp:keywords'
+      }),
+      'cp:category': new StringXform({
+        tag: 'cp:category'
+      }),
+      'cp:lastModifiedBy': new StringXform({
+        tag: 'cp:lastModifiedBy'
+      }),
+      'cp:lastPrinted': new DateXform({
+        tag: 'cp:lastPrinted',
+        format: CoreXform.DateFormat
+      }),
+      'cp:revision': new IntegerXform({
+        tag: 'cp:revision'
+      }),
+      'cp:version': new StringXform({
+        tag: 'cp:version'
+      }),
+      'cp:contentStatus': new StringXform({
+        tag: 'cp:contentStatus'
+      }),
+      'cp:contentType': new StringXform({
+        tag: 'cp:contentType'
+      }),
+      'dcterms:created': new DateXform({
+        tag: 'dcterms:created',
+        attrs: CoreXform.DateAttrs,
+        format: CoreXform.DateFormat
+      }),
+      'dcterms:modified': new DateXform({
+        tag: 'dcterms:modified',
+        attrs: CoreXform.DateAttrs,
+        format: CoreXform.DateFormat
+      })
+    };
+  }
+  render(xmlStream, model) {
+    xmlStream.openXml(XmlStream.StdDocAttributes);
+    xmlStream.openNode('cp:coreProperties', CoreXform.CORE_PROPERTY_ATTRIBUTES);
+    this.map['dc:creator'].render(xmlStream, model.creator);
+    this.map['dc:title'].render(xmlStream, model.title);
+    this.map['dc:subject'].render(xmlStream, model.subject);
+    this.map['dc:description'].render(xmlStream, model.description);
+    this.map['dc:identifier'].render(xmlStream, model.identifier);
+    this.map['dc:language'].render(xmlStream, model.language);
+    this.map['cp:keywords'].render(xmlStream, model.keywords);
+    this.map['cp:category'].render(xmlStream, model.category);
+    this.map['cp:lastModifiedBy'].render(xmlStream, model.lastModifiedBy);
+    this.map['cp:lastPrinted'].render(xmlStream, model.lastPrinted);
+    this.map['cp:revision'].render(xmlStream, model.revision);
+    this.map['cp:version'].render(xmlStream, model.version);
+    this.map['cp:contentStatus'].render(xmlStream, model.contentStatus);
+    this.map['cp:contentType'].render(xmlStream, model.contentType);
+    this.map['dcterms:created'].render(xmlStream, model.created);
+    this.map['dcterms:modified'].render(xmlStream, model.modified);
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'cp:coreProperties':
+      case 'coreProperties':
+        return true;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+          return true;
+        }
+        throw new Error(`Unexpected xml node in parseOpen: ${JSON.stringify(node)}`);
+    }
+  }
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.parser = undefined;
+      }
+      return true;
+    }
+    switch (name) {
+      case 'cp:coreProperties':
+      case 'coreProperties':
+        this.model = {
+          creator: this.map['dc:creator'].model,
+          title: this.map['dc:title'].model,
+          subject: this.map['dc:subject'].model,
+          description: this.map['dc:description'].model,
+          identifier: this.map['dc:identifier'].model,
+          language: this.map['dc:language'].model,
+          keywords: this.map['cp:keywords'].model,
+          category: this.map['cp:category'].model,
+          lastModifiedBy: this.map['cp:lastModifiedBy'].model,
+          lastPrinted: this.map['cp:lastPrinted'].model,
+          revision: this.map['cp:revision'].model,
+          contentStatus: this.map['cp:contentStatus'].model,
+          contentType: this.map['cp:contentType'].model,
+          created: this.map['dcterms:created'].model,
+          modified: this.map['dcterms:modified'].model
+        };
+        return false;
+      default:
+        throw new Error(`Unexpected xml node in parseClose: ${name}`);
+    }
+  }
+}
+CoreXform.DateFormat = function (dt) {
+  return dt.toISOString().replace(/[.]\d{3}/, '');
+};
+CoreXform.DateAttrs = {
+  'xsi:type': 'dcterms:W3CDTF'
+};
+CoreXform.CORE_PROPERTY_ATTRIBUTES = {
+  'xmlns:cp': 'http://schemas.openxmlformats.org/package/2006/metadata/core-properties',
+  'xmlns:dc': 'http://purl.org/dc/elements/1.1/',
+  'xmlns:dcterms': 'http://purl.org/dc/terms/',
+  'xmlns:dcmitype': 'http://purl.org/dc/dcmitype/',
+  'xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance'
+};
+module.exports = CoreXform;
+//# sourceMappingURL=core-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/core/relationship-xform.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+class RelationshipXform extends BaseXform {
+  render(xmlStream, model) {
+    xmlStream.leafNode('Relationship', model);
+  }
+  parseOpen(node) {
+    switch (node.name) {
+      case 'Relationship':
+        this.model = node.attributes;
+        return true;
+      default:
+        return false;
+    }
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+module.exports = RelationshipXform;
+//# sourceMappingURL=relationship-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/core/relationships-xform.js

@@ -0,0 +1,65 @@
+"use strict";
+
+const XmlStream = require('../../../utils/xml-stream');
+const BaseXform = require('../base-xform');
+const RelationshipXform = require('./relationship-xform');
+class RelationshipsXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      Relationship: new RelationshipXform()
+    };
+  }
+  render(xmlStream, model) {
+    model = model || this._values;
+    xmlStream.openXml(XmlStream.StdDocAttributes);
+    xmlStream.openNode('Relationships', RelationshipsXform.RELATIONSHIPS_ATTRIBUTES);
+    model.forEach(relationship => {
+      this.map.Relationship.render(xmlStream, relationship);
+    });
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'Relationships':
+        this.model = [];
+        return true;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+          return true;
+        }
+        throw new Error(`Unexpected xml node in parseOpen: ${JSON.stringify(node)}`);
+    }
+  }
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.model.push(this.parser.model);
+        this.parser = undefined;
+      }
+      return true;
+    }
+    switch (name) {
+      case 'Relationships':
+        return false;
+      default:
+        throw new Error(`Unexpected xml node in parseClose: ${name}`);
+    }
+  }
+}
+RelationshipsXform.RELATIONSHIPS_ATTRIBUTES = {
+  xmlns: 'http://schemas.openxmlformats.org/package/2006/relationships'
+};
+module.exports = RelationshipsXform;
+//# sourceMappingURL=relationships-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/drawing/base-cell-anchor-xform.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+class BaseCellAnchorXform extends BaseXform {
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.tag:
+        this.reset();
+        this.model = {
+          range: {
+            editAs: node.attributes.editAs || 'oneCell'
+          }
+        };
+        break;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+        }
+        break;
+    }
+    return true;
+  }
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+  reconcilePicture(model, options) {
+    if (model && model.rId) {
+      const rel = options.rels[model.rId];
+      const match = rel.Target.match(/.*\/media\/(.+[.][a-zA-Z]{3,4})/);
+      if (match) {
+        const name = match[1];
+        const mediaId = options.mediaIndex[name];
+        return options.media[mediaId];
+      }
+    }
+    return undefined;
+  }
+}
+module.exports = BaseCellAnchorXform;
+//# sourceMappingURL=base-cell-anchor-xform.js.map

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

@@ -0,0 +1,61 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+const BlipXform = require('./blip-xform');
+class BlipFillXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      'a:blip': new BlipXform()
+    };
+  }
+  get tag() {
+    return 'xdr:blipFill';
+  }
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag);
+    this.map['a:blip'].render(xmlStream, model);
+
+    // TODO: options for this + parsing
+    xmlStream.openNode('a:stretch');
+    xmlStream.leafNode('a:fillRect');
+    xmlStream.closeNode();
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.tag:
+        this.reset();
+        break;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+        }
+        break;
+    }
+    return true;
+  }
+  parseText() {}
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.parser = undefined;
+      }
+      return true;
+    }
+    switch (name) {
+      case this.tag:
+        this.model = this.map['a:blip'].model;
+        return false;
+      default:
+        return true;
+    }
+  }
+}
+module.exports = BlipFillXform;
+//# sourceMappingURL=blip-fill-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/drawing/blip-xform.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+class BlipXform extends BaseXform {
+  get tag() {
+    return 'a:blip';
+  }
+  render(xmlStream, model) {
+    xmlStream.leafNode(this.tag, {
+      'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+      'r:embed': model.rId,
+      cstate: 'print'
+    });
+    // TODO: handle children (e.g. a:extLst=>a:ext=>a14:useLocalDpi
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.model = {
+          rId: node.attributes['r:embed']
+        };
+        return true;
+      default:
+        return true;
+    }
+  }
+  parseText() {}
+  parseClose(name) {
+    switch (name) {
+      case this.tag:
+        return false;
+      default:
+        // unprocessed internal nodes
+        return true;
+    }
+  }
+}
+module.exports = BlipXform;
+//# sourceMappingURL=blip-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/drawing/c-nv-pic-pr-xform.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+class CNvPicPrXform extends BaseXform {
+  get tag() {
+    return 'xdr:cNvPicPr';
+  }
+  render(xmlStream) {
+    xmlStream.openNode(this.tag);
+    xmlStream.leafNode('a:picLocks', {
+      noChangeAspect: '1'
+    });
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        return true;
+      default:
+        return true;
+    }
+  }
+  parseText() {}
+  parseClose(name) {
+    switch (name) {
+      case this.tag:
+        return false;
+      default:
+        // unprocessed internal nodes
+        return true;
+    }
+  }
+}
+module.exports = CNvPicPrXform;
+//# sourceMappingURL=c-nv-pic-pr-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/drawing/c-nv-pr-xform.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+const HlickClickXform = require('./hlink-click-xform');
+const ExtLstXform = require('./ext-lst-xform');
+class CNvPrXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      'a:hlinkClick': new HlickClickXform(),
+      'a:extLst': new ExtLstXform()
+    };
+  }
+  get tag() {
+    return 'xdr:cNvPr';
+  }
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      id: model.index,
+      name: `Picture ${model.index}`
+    });
+    this.map['a:hlinkClick'].render(xmlStream, model);
+    this.map['a:extLst'].render(xmlStream, model);
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.tag:
+        this.reset();
+        break;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+        }
+        break;
+    }
+    return true;
+  }
+  parseText() {}
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.parser = undefined;
+      }
+      return true;
+    }
+    switch (name) {
+      case this.tag:
+        this.model = this.map['a:hlinkClick'].model;
+        return false;
+      default:
+        return true;
+    }
+  }
+}
+module.exports = CNvPrXform;
+//# sourceMappingURL=c-nv-pr-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/drawing/cell-position-xform.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+const IntegerXform = require('../simple/integer-xform');
+class CellPositionXform extends BaseXform {
+  constructor(options) {
+    super();
+    this.tag = options.tag;
+    this.map = {
+      'xdr:col': new IntegerXform({
+        tag: 'xdr:col',
+        zero: true
+      }),
+      'xdr:colOff': new IntegerXform({
+        tag: 'xdr:colOff',
+        zero: true
+      }),
+      'xdr:row': new IntegerXform({
+        tag: 'xdr:row',
+        zero: true
+      }),
+      'xdr:rowOff': new IntegerXform({
+        tag: 'xdr:rowOff',
+        zero: true
+      })
+    };
+  }
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag);
+    this.map['xdr:col'].render(xmlStream, model.nativeCol);
+    this.map['xdr:colOff'].render(xmlStream, model.nativeColOff);
+    this.map['xdr:row'].render(xmlStream, model.nativeRow);
+    this.map['xdr:rowOff'].render(xmlStream, model.nativeRowOff);
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.tag:
+        this.reset();
+        break;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+        }
+        break;
+    }
+    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;
+    }
+    switch (name) {
+      case this.tag:
+        this.model = {
+          nativeCol: this.map['xdr:col'].model,
+          nativeColOff: this.map['xdr:colOff'].model,
+          nativeRow: this.map['xdr:row'].model,
+          nativeRowOff: this.map['xdr:rowOff'].model
+        };
+        return false;
+      default:
+        // not quite sure how we get here!
+        return true;
+    }
+  }
+}
+module.exports = CellPositionXform;
+//# sourceMappingURL=cell-position-xform.js.map

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

@@ -0,0 +1,98 @@
+"use strict";
+
+const colCache = require('../../../utils/col-cache');
+const XmlStream = require('../../../utils/xml-stream');
+const BaseXform = require('../base-xform');
+const TwoCellAnchorXform = require('./two-cell-anchor-xform');
+const OneCellAnchorXform = require('./one-cell-anchor-xform');
+function getAnchorType(model) {
+  const range = typeof model.range === 'string' ? colCache.decode(model.range) : model.range;
+  return range.br ? 'xdr:twoCellAnchor' : 'xdr:oneCellAnchor';
+}
+class DrawingXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      'xdr:twoCellAnchor': new TwoCellAnchorXform(),
+      'xdr:oneCellAnchor': new OneCellAnchorXform()
+    };
+  }
+  prepare(model) {
+    model.anchors.forEach((item, index) => {
+      item.anchorType = getAnchorType(item);
+      const anchor = this.map[item.anchorType];
+      anchor.prepare(item, {
+        index
+      });
+    });
+  }
+  get tag() {
+    return 'xdr:wsDr';
+  }
+  render(xmlStream, model) {
+    xmlStream.openXml(XmlStream.StdDocAttributes);
+    xmlStream.openNode(this.tag, DrawingXform.DRAWING_ATTRIBUTES);
+    model.anchors.forEach(item => {
+      const anchor = this.map[item.anchorType];
+      anchor.render(xmlStream, item);
+    });
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.tag:
+        this.reset();
+        this.model = {
+          anchors: []
+        };
+        break;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+        }
+        break;
+    }
+    return true;
+  }
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.model.anchors.push(this.parser.model);
+        this.parser = undefined;
+      }
+      return true;
+    }
+    switch (name) {
+      case this.tag:
+        return false;
+      default:
+        // could be some unrecognised tags
+        return true;
+    }
+  }
+  reconcile(model, options) {
+    model.anchors.forEach(anchor => {
+      if (anchor.br) {
+        this.map['xdr:twoCellAnchor'].reconcile(anchor, options);
+      } else {
+        this.map['xdr:oneCellAnchor'].reconcile(anchor, options);
+      }
+    });
+  }
+}
+DrawingXform.DRAWING_ATTRIBUTES = {
+  'xmlns:xdr': 'http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing',
+  'xmlns:a': 'http://schemas.openxmlformats.org/drawingml/2006/main'
+};
+module.exports = DrawingXform;
+//# sourceMappingURL=drawing-xform.js.map