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

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/comment/vml-notes-xform.js

@@ -0,0 +1,107 @@
+"use strict";
+
+const XmlStream = require('../../../utils/xml-stream');
+const BaseXform = require('../base-xform');
+const VmlShapeXform = require('./vml-shape-xform');
+
+// This class is (currently) single purposed to insert the triangle
+// drawing icons on commented cells
+class VmlNotesXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      'v:shape': new VmlShapeXform()
+    };
+  }
+  get tag() {
+    return 'xml';
+  }
+  render(xmlStream, model) {
+    xmlStream.openXml(XmlStream.StdDocAttributes);
+    xmlStream.openNode(this.tag, VmlNotesXform.DRAWING_ATTRIBUTES);
+    xmlStream.openNode('o:shapelayout', {
+      'v:ext': 'edit'
+    });
+    xmlStream.leafNode('o:idmap', {
+      'v:ext': 'edit',
+      data: 1
+    });
+    xmlStream.closeNode();
+    xmlStream.openNode('v:shapetype', {
+      id: '_x0000_t202',
+      coordsize: '21600,21600',
+      'o:spt': 202,
+      path: 'm,l,21600r21600,l21600,xe'
+    });
+    xmlStream.leafNode('v:stroke', {
+      joinstyle: 'miter'
+    });
+    xmlStream.leafNode('v:path', {
+      gradientshapeok: 't',
+      'o:connecttype': 'rect'
+    });
+    xmlStream.closeNode();
+    model.comments.forEach((item, index) => {
+      this.map['v:shape'].render(xmlStream, item, index);
+    });
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.tag:
+        this.reset();
+        this.model = {
+          comments: []
+        };
+        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.comments.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);
+      }
+    });
+  }
+}
+VmlNotesXform.DRAWING_ATTRIBUTES = {
+  'xmlns:v': 'urn:schemas-microsoft-com:vml',
+  'xmlns:o': 'urn:schemas-microsoft-com:office:office',
+  'xmlns:x': 'urn:schemas-microsoft-com:office:excel'
+};
+module.exports = VmlNotesXform;
+//# sourceMappingURL=vml-notes-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/comment/vml-shape-xform.js

@@ -0,0 +1,92 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+const VmlTextboxXform = require('./vml-textbox-xform');
+const VmlClientDataXform = require('./vml-client-data-xform');
+class VmlShapeXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      'v:textbox': new VmlTextboxXform(),
+      'x:ClientData': new VmlClientDataXform()
+    };
+  }
+  get tag() {
+    return 'v:shape';
+  }
+  render(xmlStream, model, index) {
+    xmlStream.openNode('v:shape', VmlShapeXform.V_SHAPE_ATTRIBUTES(model, index));
+    xmlStream.leafNode('v:fill', {
+      color2: 'infoBackground [80]'
+    });
+    xmlStream.leafNode('v:shadow', {
+      color: 'none [81]',
+      obscured: 't'
+    });
+    xmlStream.leafNode('v:path', {
+      'o:connecttype': 'none'
+    });
+    this.map['v:textbox'].render(xmlStream, model);
+    this.map['x:ClientData'].render(xmlStream, model);
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.tag:
+        this.reset();
+        this.model = {
+          margins: {
+            insetmode: node.attributes['o:insetmode']
+          },
+          anchor: '',
+          editAs: '',
+          protection: {}
+        };
+        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.margins.inset = this.map['v:textbox'].model && this.map['v:textbox'].model.inset;
+        this.model.protection = this.map['x:ClientData'].model && this.map['x:ClientData'].model.protection;
+        this.model.anchor = this.map['x:ClientData'].model && this.map['x:ClientData'].model.anchor;
+        this.model.editAs = this.map['x:ClientData'].model && this.map['x:ClientData'].model.editAs;
+        return false;
+      default:
+        return true;
+    }
+  }
+}
+VmlShapeXform.V_SHAPE_ATTRIBUTES = (model, index) => ({
+  id: `_x0000_s${1025 + index}`,
+  type: '#_x0000_t202',
+  style: 'position:absolute; margin-left:105.3pt;margin-top:10.5pt;width:97.8pt;height:59.1pt;z-index:1;visibility:hidden',
+  fillcolor: 'infoBackground [80]',
+  strokecolor: 'none [81]',
+  'o:insetmode': model.note.margins && model.note.margins.insetmode
+});
+module.exports = VmlShapeXform;
+//# sourceMappingURL=vml-shape-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/comment/vml-textbox-xform.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+class VmlTextboxXform extends BaseXform {
+  get tag() {
+    return 'v:textbox';
+  }
+  conversionUnit(value, multiple, unit) {
+    return `${parseFloat(value) * multiple.toFixed(2)}${unit}`;
+  }
+  reverseConversionUnit(inset) {
+    return (inset || '').split(',').map(margin => {
+      return Number(parseFloat(this.conversionUnit(parseFloat(margin), 0.1, '')).toFixed(2));
+    });
+  }
+  render(xmlStream, model) {
+    const attributes = {
+      style: 'mso-direction-alt:auto'
+    };
+    if (model && model.note) {
+      let {
+        inset
+      } = model.note && model.note.margins;
+      if (Array.isArray(inset)) {
+        inset = inset.map(margin => {
+          return this.conversionUnit(margin, 10, 'mm');
+        }).join(',');
+      }
+      if (inset) {
+        attributes.inset = inset;
+      }
+    }
+    xmlStream.openNode('v:textbox', attributes);
+    xmlStream.leafNode('div', {
+      style: 'text-align:left'
+    });
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.model = {
+          inset: this.reverseConversionUnit(node.attributes.inset)
+        };
+        return true;
+      default:
+        return true;
+    }
+  }
+  parseText() {}
+  parseClose(name) {
+    switch (name) {
+      case this.tag:
+        return false;
+      default:
+        return true;
+    }
+  }
+}
+module.exports = VmlTextboxXform;
+//# sourceMappingURL=vml-textbox-xform.js.map

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

@@ -0,0 +1,51 @@
+"use strict";
+
+const BaseXform = require('./base-xform');
+
+/* 'virtual' methods used as a form of documentation */
+/* eslint-disable class-methods-use-this */
+
+// base class for xforms that are composed of other xforms
+// offers some default implementations
+class CompositeXform extends BaseXform {
+  createNewModel(node) {
+    return {};
+  }
+  parseOpen(node) {
+    // Typical pattern for composite xform
+    this.parser = this.parser || this.map[node.name];
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    if (node.name === this.tag) {
+      this.model = this.createNewModel(node);
+      return true;
+    }
+    return false;
+  }
+  parseText(text) {
+    // Default implementation. Send text to child parser
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+  onParserClose(name, parser) {
+    // parseClose has seen a child parser close
+    // now need to incorporate into this.model somehow
+    this.model[name] = parser.model;
+  }
+  parseClose(name) {
+    // Default implementation
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.onParserClose(name, this.parser);
+        this.parser = undefined;
+      }
+      return true;
+    }
+    return name !== this.tag;
+  }
+}
+module.exports = CompositeXform;
+//# sourceMappingURL=composite-xform.js.map

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

@@ -0,0 +1,30 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+class AppHeadingPairsXform extends BaseXform {
+  render(xmlStream, model) {
+    xmlStream.openNode('HeadingPairs');
+    xmlStream.openNode('vt:vector', {
+      size: 2,
+      baseType: 'variant'
+    });
+    xmlStream.openNode('vt:variant');
+    xmlStream.leafNode('vt:lpstr', undefined, 'Worksheets');
+    xmlStream.closeNode();
+    xmlStream.openNode('vt:variant');
+    xmlStream.leafNode('vt:i4', undefined, model.length);
+    xmlStream.closeNode();
+    xmlStream.closeNode();
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    // no parsing
+    return node.name === 'HeadingPairs';
+  }
+  parseText() {}
+  parseClose(name) {
+    return name !== 'HeadingPairs';
+  }
+}
+module.exports = AppHeadingPairsXform;
+//# sourceMappingURL=app-heading-pairs-xform.js.map

package/dist/node_modules/exceljs/dist/es5/xlsx/xform/core/app-titles-of-parts-xform.js

@@ -0,0 +1,27 @@
+"use strict";
+
+const BaseXform = require('../base-xform');
+class AppTitlesOfPartsXform extends BaseXform {
+  render(xmlStream, model) {
+    xmlStream.openNode('TitlesOfParts');
+    xmlStream.openNode('vt:vector', {
+      size: model.length,
+      baseType: 'lpstr'
+    });
+    model.forEach(sheet => {
+      xmlStream.leafNode('vt:lpstr', undefined, sheet.name);
+    });
+    xmlStream.closeNode();
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    // no parsing
+    return node.name === 'TitlesOfParts';
+  }
+  parseText() {}
+  parseClose(name) {
+    return name !== 'TitlesOfParts';
+  }
+}
+module.exports = AppTitlesOfPartsXform;
+//# sourceMappingURL=app-titles-of-parts-xform.js.map

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

@@ -0,0 +1,93 @@
+"use strict";
+
+const XmlStream = require('../../../utils/xml-stream');
+const BaseXform = require('../base-xform');
+const StringXform = require('../simple/string-xform');
+const AppHeadingPairsXform = require('./app-heading-pairs-xform');
+const AppTitleOfPartsXform = require('./app-titles-of-parts-xform');
+class AppXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      Company: new StringXform({
+        tag: 'Company'
+      }),
+      Manager: new StringXform({
+        tag: 'Manager'
+      }),
+      HeadingPairs: new AppHeadingPairsXform(),
+      TitleOfParts: new AppTitleOfPartsXform()
+    };
+  }
+  render(xmlStream, model) {
+    xmlStream.openXml(XmlStream.StdDocAttributes);
+    xmlStream.openNode('Properties', AppXform.PROPERTY_ATTRIBUTES);
+    xmlStream.leafNode('Application', undefined, 'Microsoft Excel');
+    xmlStream.leafNode('DocSecurity', undefined, '0');
+    xmlStream.leafNode('ScaleCrop', undefined, 'false');
+    this.map.HeadingPairs.render(xmlStream, model.worksheets);
+    this.map.TitleOfParts.render(xmlStream, model.worksheets);
+    this.map.Company.render(xmlStream, model.company || '');
+    this.map.Manager.render(xmlStream, model.manager);
+    xmlStream.leafNode('LinksUpToDate', undefined, 'false');
+    xmlStream.leafNode('SharedDoc', undefined, 'false');
+    xmlStream.leafNode('HyperlinksChanged', undefined, 'false');
+    xmlStream.leafNode('AppVersion', undefined, '16.0300');
+    xmlStream.closeNode();
+  }
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'Properties':
+        return true;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+          return true;
+        }
+
+        // there's a lot we don't bother to parse
+        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;
+    }
+    switch (name) {
+      case 'Properties':
+        this.model = {
+          worksheets: this.map.TitleOfParts.model,
+          company: this.map.Company.model,
+          manager: this.map.Manager.model
+        };
+        return false;
+      default:
+        return true;
+    }
+  }
+}
+AppXform.DateFormat = function (dt) {
+  return dt.toISOString().replace(/[.]\d{3,6}/, '');
+};
+AppXform.DateAttrs = {
+  'xsi:type': 'dcterms:W3CDTF'
+};
+AppXform.PROPERTY_ATTRIBUTES = {
+  xmlns: 'http://schemas.openxmlformats.org/officeDocument/2006/extended-properties',
+  'xmlns:vt': 'http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes'
+};
+module.exports = AppXform;
+//# sourceMappingURL=app-xform.js.map

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

@@ -0,0 +1,112 @@
+"use strict";
+
+const XmlStream = require('../../../utils/xml-stream');
+const BaseXform = require('../base-xform');
+
+// used for rendering the [Content_Types].xml file
+// not used for parsing
+class ContentTypesXform extends BaseXform {
+  render(xmlStream, model) {
+    xmlStream.openXml(XmlStream.StdDocAttributes);
+    xmlStream.openNode('Types', ContentTypesXform.PROPERTY_ATTRIBUTES);
+    const mediaHash = {};
+    (model.media || []).forEach(medium => {
+      if (medium.type === 'image') {
+        const imageType = medium.extension;
+        if (!mediaHash[imageType]) {
+          mediaHash[imageType] = true;
+          xmlStream.leafNode('Default', {
+            Extension: imageType,
+            ContentType: `image/${imageType}`
+          });
+        }
+      }
+    });
+    xmlStream.leafNode('Default', {
+      Extension: 'rels',
+      ContentType: 'application/vnd.openxmlformats-package.relationships+xml'
+    });
+    xmlStream.leafNode('Default', {
+      Extension: 'xml',
+      ContentType: 'application/xml'
+    });
+    xmlStream.leafNode('Override', {
+      PartName: '/xl/workbook.xml',
+      ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml'
+    });
+    model.worksheets.forEach(worksheet => {
+      const name = `/xl/worksheets/sheet${worksheet.id}.xml`;
+      xmlStream.leafNode('Override', {
+        PartName: name,
+        ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml'
+      });
+    });
+    xmlStream.leafNode('Override', {
+      PartName: '/xl/theme/theme1.xml',
+      ContentType: 'application/vnd.openxmlformats-officedocument.theme+xml'
+    });
+    xmlStream.leafNode('Override', {
+      PartName: '/xl/styles.xml',
+      ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml'
+    });
+    const hasSharedStrings = model.sharedStrings && model.sharedStrings.count;
+    if (hasSharedStrings) {
+      xmlStream.leafNode('Override', {
+        PartName: '/xl/sharedStrings.xml',
+        ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml'
+      });
+    }
+    if (model.tables) {
+      model.tables.forEach(table => {
+        xmlStream.leafNode('Override', {
+          PartName: `/xl/tables/${table.target}`,
+          ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml'
+        });
+      });
+    }
+    if (model.drawings) {
+      model.drawings.forEach(drawing => {
+        xmlStream.leafNode('Override', {
+          PartName: `/xl/drawings/${drawing.name}.xml`,
+          ContentType: 'application/vnd.openxmlformats-officedocument.drawing+xml'
+        });
+      });
+    }
+    if (model.commentRefs) {
+      xmlStream.leafNode('Default', {
+        Extension: 'vml',
+        ContentType: 'application/vnd.openxmlformats-officedocument.vmlDrawing'
+      });
+      model.commentRefs.forEach(_ref => {
+        let {
+          commentName
+        } = _ref;
+        xmlStream.leafNode('Override', {
+          PartName: `/xl/${commentName}.xml`,
+          ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml'
+        });
+      });
+    }
+    xmlStream.leafNode('Override', {
+      PartName: '/docProps/core.xml',
+      ContentType: 'application/vnd.openxmlformats-package.core-properties+xml'
+    });
+    xmlStream.leafNode('Override', {
+      PartName: '/docProps/app.xml',
+      ContentType: 'application/vnd.openxmlformats-officedocument.extended-properties+xml'
+    });
+    xmlStream.closeNode();
+  }
+  parseOpen() {
+    return false;
+  }
+  parseText() {}
+  parseClose() {
+    return false;
+  }
+}
+ContentTypesXform.PROPERTY_ATTRIBUTES = {
+  xmlns: 'http://schemas.openxmlformats.org/package/2006/content-types'
+};
+module.exports = ContentTypesXform;
+//# sourceMappingURL=content-types-xform.js.map