@lyit/exceljs 4.4.1

package/lib/xlsx/xform/core/content-types-xform.js

@@ -0,0 +1,211 @@
+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',
+      });
+    });
+
+    // Content types for programmatic pivot tables
+    (model.pivotTables || []).forEach((pivotTable, index) => {
+      const tableNum = index + 1;
+      xmlStream.leafNode('Override', {
+        PartName: `/xl/pivotCache/pivotCacheDefinition${tableNum}.xml`,
+        ContentType:
+          'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml',
+      });
+      xmlStream.leafNode('Override', {
+        PartName: `/xl/pivotCache/pivotCacheRecords${tableNum}.xml`,
+        ContentType:
+          'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml',
+      });
+      xmlStream.leafNode('Override', {
+        PartName: `/xl/pivotTables/pivotTable${tableNum}.xml`,
+        ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml',
+      });
+    });
+
+    // Content types for preserved pivot tables (from round-trip)
+    if (model.preservedPivotTables) {
+      Object.keys(model.preservedPivotTables.pivotTables || {}).forEach(name => {
+        const tableNum = name.match(/\d+/)[0];
+        xmlStream.leafNode('Override', {
+          PartName: `/xl/pivotCache/pivotCacheDefinition${tableNum}.xml`,
+          ContentType:
+            'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml',
+        });
+        xmlStream.leafNode('Override', {
+          PartName: `/xl/pivotCache/pivotCacheRecords${tableNum}.xml`,
+          ContentType:
+            'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml',
+        });
+        xmlStream.leafNode('Override', {
+          PartName: `/xl/pivotTables/pivotTable${tableNum}.xml`,
+          ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml',
+        });
+      });
+    }
+
+    // Content types for preserved charts (from round-trip)
+    if (model.preservedChartsXml) {
+      Object.keys(model.preservedChartsXml).forEach(name => {
+        xmlStream.leafNode('Override', {
+          PartName: `/xl/charts/${name}.xml`,
+          ContentType: 'application/vnd.openxmlformats-officedocument.drawingml.chart+xml',
+        });
+      });
+    }
+
+    // Content types for preserved chart styles
+    if (model.preservedChartStylesXml) {
+      Object.keys(model.preservedChartStylesXml).forEach(name => {
+        xmlStream.leafNode('Override', {
+          PartName: `/xl/charts/${name}.xml`,
+          ContentType: 'application/vnd.ms-office.chartstyle+xml',
+        });
+      });
+    }
+
+    // Content types for preserved chart colors
+    if (model.preservedChartColorsXml) {
+      Object.keys(model.preservedChartColorsXml).forEach(name => {
+        xmlStream.leafNode('Override', {
+          PartName: `/xl/charts/${name}.xml`,
+          ContentType: 'application/vnd.ms-office.chartcolorstyle+xml',
+        });
+      });
+    }
+
+    // Content types for preserved drawings (with charts)
+    if (model.preservedDrawingsXml) {
+      Object.keys(model.preservedDrawingsXml).forEach(name => {
+        xmlStream.leafNode('Override', {
+          PartName: `/xl/drawings/${name}.xml`,
+          ContentType: 'application/vnd.openxmlformats-officedocument.drawing+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 || model.formControlRefs) {
+      xmlStream.leafNode('Default', {
+        Extension: 'vml',
+        ContentType: 'application/vnd.openxmlformats-officedocument.vmlDrawing',
+      });
+
+      if (model.commentRefs) {
+        model.commentRefs.forEach(({commentName}) => {
+          xmlStream.leafNode('Override', {
+            PartName: `/xl/${commentName}.xml`,
+            ContentType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml',
+          });
+        });
+      }
+    }
+
+    if (model.formControlRefs) {
+      model.formControlRefs.forEach(ref => {
+        xmlStream.leafNode('Override', {
+          PartName: `/xl/ctrlProps/ctrlProp${ref.id}.xml`,
+          ContentType: 'application/vnd.ms-excel.controlproperties+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;

package/lib/xlsx/xform/core/core-xform.js

@@ -0,0 +1,142 @@
+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;
+        }
+        // Ignore unknown tags for compatibility with non-Excel spreadsheet applications
+        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 "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:
+        // Ignore unknown tags for compatibility with non-Excel spreadsheet applications
+        return true;
+    }
+  }
+}
+
+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;

package/lib/xlsx/xform/core/relationship-xform.js

@@ -0,0 +1,25 @@
+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;

package/lib/xlsx/xform/core/relationships-xform.js

@@ -0,0 +1,73 @@
+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;

package/lib/xlsx/xform/drawing/base-cell-anchor-xform.js

@@ -0,0 +1,48 @@
+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;

package/lib/xlsx/xform/drawing/blip-fill-xform.js

@@ -0,0 +1,71 @@
+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;

package/lib/xlsx/xform/drawing/blip-xform.js

@@ -0,0 +1,42 @@
+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;

package/lib/xlsx/xform/drawing/c-nv-pic-pr-xform.js

@@ -0,0 +1,38 @@
+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;