@yuanliwei/exceljs 4.4.0

package/lib/xlsx/xform/book/workbook-xform.js

@@ -0,0 +1,259 @@
+const _ = require('../../../utils/under-dash');
+
+const colCache = require('../../../utils/col-cache');
+const XmlStream = require('../../../utils/xml-stream');
+
+const BaseXform = require('../base-xform');
+const StaticXform = require('../static-xform');
+const ListXform = require('../list-xform');
+const DefinedNameXform = require('./defined-name-xform');
+const SheetXform = require('./sheet-xform');
+const WorkbookViewXform = require('./workbook-view-xform');
+const WorkbookPropertiesXform = require('./workbook-properties-xform');
+const WorkbookCalcPropertiesXform = require('./workbook-calc-properties-xform');
+const WorkbookPivotCacheXform = require('./workbook-pivot-cache-xform');
+
+class WorkbookXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {
+      fileVersion: WorkbookXform.STATIC_XFORMS.fileVersion,
+      workbookPr: new WorkbookPropertiesXform(),
+      bookViews: new ListXform({
+        tag: 'bookViews',
+        count: false,
+        childXform: new WorkbookViewXform(),
+      }),
+      sheets: new ListXform({tag: 'sheets', count: false, childXform: new SheetXform()}),
+      definedNames: new ListXform({
+        tag: 'definedNames',
+        count: false,
+        childXform: new DefinedNameXform(),
+      }),
+      calcPr: new WorkbookCalcPropertiesXform(),
+      pivotCaches: new ListXform({
+        tag: 'pivotCaches',
+        count: false,
+        childXform: new WorkbookPivotCacheXform(),
+      }),
+    };
+  }
+
+  prepare(model) {
+    model.sheets = model.worksheets;
+
+    // collate all the print areas from all of the sheets and add them to the defined names
+    const printAreas = [];
+    let index = 0; // sheets is sparse array - calc index manually
+    model.sheets.forEach(sheet => {
+      if (sheet.pageSetup && sheet.pageSetup.printArea) {
+        sheet.pageSetup.printArea.split('&&').forEach(printArea => {
+          const printAreaComponents = printArea.split(':');
+          const definedName = {
+            name: '_xlnm.Print_Area',
+            ranges: [`'${sheet.name}'!$${printAreaComponents[0]}:$${printAreaComponents[1]}`],
+            localSheetId: index,
+          };
+          printAreas.push(definedName);
+        });
+      }
+
+      if (sheet.pageSetup && (sheet.pageSetup.printTitlesRow || sheet.pageSetup.printTitlesColumn)) {
+        const ranges = [];
+
+        if (sheet.pageSetup.printTitlesColumn) {
+          const titlesColumns = sheet.pageSetup.printTitlesColumn.split(':');
+          ranges.push(`'${sheet.name}'!$${titlesColumns[0]}:$${titlesColumns[1]}`);
+        }
+
+        if (sheet.pageSetup.printTitlesRow) {
+          const titlesRows = sheet.pageSetup.printTitlesRow.split(':');
+          ranges.push(`'${sheet.name}'!$${titlesRows[0]}:$${titlesRows[1]}`);
+        }
+
+        const definedName = {
+          name: '_xlnm.Print_Titles',
+          ranges,
+          localSheetId: index,
+        };
+
+        printAreas.push(definedName);
+      }
+      index++;
+    });
+    if (printAreas.length) {
+      model.definedNames = model.definedNames.concat(printAreas);
+    }
+
+    (model.media || []).forEach((medium, i) => {
+      // assign name
+      medium.name = medium.type + (i + 1);
+    });
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openXml(XmlStream.StdDocAttributes);
+    xmlStream.openNode('workbook', WorkbookXform.WORKBOOK_ATTRIBUTES);
+
+    this.map.fileVersion.render(xmlStream);
+    this.map.workbookPr.render(xmlStream, model.properties);
+    this.map.bookViews.render(xmlStream, model.views);
+    this.map.sheets.render(xmlStream, model.sheets);
+    this.map.definedNames.render(xmlStream, model.definedNames);
+    this.map.calcPr.render(xmlStream, model.calcProperties);
+    this.map.pivotCaches.render(xmlStream, model.pivotTables);
+
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'workbook':
+        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;
+    }
+    switch (name) {
+      case 'workbook':
+        this.model = {
+          sheets: this.map.sheets.model,
+          properties: this.map.workbookPr.model || {},
+          views: this.map.bookViews.model,
+          calcProperties: {},
+        };
+        if (this.map.definedNames.model) {
+          this.model.definedNames = this.map.definedNames.model;
+        }
+
+        return false;
+      default:
+        // not quite sure how we get here!
+        return true;
+    }
+  }
+
+  reconcile(model) {
+    const rels = (model.workbookRels || []).reduce((map, rel) => {
+      map[rel.Id] = rel;
+      return map;
+    }, {});
+
+    // reconcile sheet ids, rIds and names
+    const worksheets = [];
+    let worksheet;
+    let index = 0;
+
+    (model.sheets || []).forEach(sheet => {
+      const rel = rels[sheet.rId];
+      if (!rel) {
+        return;
+      }
+      // if rel.Target start with `[space]/xl/` or `/xl/` , then it will be replaced with `''` and spliced behind `xl/`,
+      // otherwise it will be spliced directly behind `xl/`. i.g.
+      worksheet = model.worksheetHash[`xl/${rel.Target.replace(/^(\s|\/xl\/)+/, '')}`];
+      // If there are "chartsheets" in the file, rel.Target will
+      // come out as chartsheets/sheet1.xml or similar here, and
+      // that won't be in model.worksheetHash.
+      // As we don't have the infrastructure to support chartsheets,
+      // we will ignore them for now:
+      if (worksheet) {
+        worksheet.name = sheet.name;
+        worksheet.id = sheet.id;
+        worksheet.state = sheet.state;
+        worksheets[index++] = worksheet;
+      }
+    });
+
+    // reconcile print areas
+    const definedNames = [];
+    _.each(model.definedNames, definedName => {
+      if (definedName.name === '_xlnm.Print_Area') {
+        worksheet = worksheets[definedName.localSheetId];
+        if (worksheet) {
+          if (!worksheet.pageSetup) {
+            worksheet.pageSetup = {};
+          }
+          const range = colCache.decodeEx(definedName.ranges[0]);
+          worksheet.pageSetup.printArea = worksheet.pageSetup.printArea
+            ? `${worksheet.pageSetup.printArea}&&${range.dimensions}`
+            : range.dimensions;
+        }
+      } else if (definedName.name === '_xlnm.Print_Titles') {
+        worksheet = worksheets[definedName.localSheetId];
+        if (worksheet) {
+          if (!worksheet.pageSetup) {
+            worksheet.pageSetup = {};
+          }
+
+          const rangeString = definedName.ranges.join(',');
+
+          const dollarRegex = /\$/g;
+
+          const rowRangeRegex = /\$\d+:\$\d+/;
+          const rowRangeMatches = rangeString.match(rowRangeRegex);
+
+          if (rowRangeMatches && rowRangeMatches.length) {
+            const range = rowRangeMatches[0];
+            worksheet.pageSetup.printTitlesRow = range.replace(dollarRegex, '');
+          }
+
+          const columnRangeRegex = /\$[A-Z]+:\$[A-Z]+/;
+          const columnRangeMatches = rangeString.match(columnRangeRegex);
+
+          if (columnRangeMatches && columnRangeMatches.length) {
+            const range = columnRangeMatches[0];
+            worksheet.pageSetup.printTitlesColumn = range.replace(dollarRegex, '');
+          }
+        }
+      } else {
+        definedNames.push(definedName);
+      }
+    });
+    model.definedNames = definedNames;
+
+    // used by sheets to build their image models
+    model.media.forEach((media, i) => {
+      media.index = i;
+    });
+  }
+}
+
+WorkbookXform.WORKBOOK_ATTRIBUTES = {
+  xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+  'xmlns:r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+  'xmlns:mc': 'http://schemas.openxmlformats.org/markup-compatibility/2006',
+  'mc:Ignorable': 'x15',
+  'xmlns:x15': 'http://schemas.microsoft.com/office/spreadsheetml/2010/11/main',
+};
+WorkbookXform.STATIC_XFORMS = {
+  fileVersion: new StaticXform({
+    tag: 'fileVersion',
+    $: {appName: 'xl', lastEdited: 5, lowestEdited: 5, rupBuild: 9303},
+  }),
+};
+
+module.exports = WorkbookXform;

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

@@ -0,0 +1,105 @@
+const RichTextXform = require('../strings/rich-text-xform');
+const utils = require('../../../utils/utils');
+const BaseXform = require('../base-xform');
+
+/**
+  <comment ref="B1" authorId="0">
+    <text>
+      <r>
+        <rPr>
+          <b/>
+          <sz val="9"/>
+          <rFont val="宋体"/>
+          <charset val="134"/>
+        </rPr>
+        <t>51422:</t>
+      </r>
+      <r>
+        <rPr>
+          <sz val="9"/>
+          <rFont val="宋体"/>
+          <charset val="134"/>
+        </rPr>
+        <t xml:space="preserve">&#10;test</t>
+      </r>
+    </text>
+  </comment>
+ */
+
+const CommentXform = (module.exports = function(model) {
+  this.model = model;
+});
+
+utils.inherits(CommentXform, BaseXform, {
+  get tag() {
+    return 'r';
+  },
+
+  get richTextXform() {
+    if (!this._richTextXform) {
+      this._richTextXform = new RichTextXform();
+    }
+    return this._richTextXform;
+  },
+
+  render(xmlStream, model) {
+    model = model || this.model;
+
+    xmlStream.openNode('comment', {
+      ref: model.ref,
+      authorId: 0,
+    });
+    xmlStream.openNode('text');
+    if (model && model.note && model.note.texts) {
+      model.note.texts.forEach(text => {
+        this.richTextXform.render(xmlStream, text);
+      });
+    }
+    xmlStream.closeNode();
+    xmlStream.closeNode();
+  },
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'comment':
+        this.model = {
+          type: 'note',
+          note: {
+            texts: [],
+          },
+          ...node.attributes,
+        };
+        return true;
+      case 'r':
+        this.parser = this.richTextXform;
+        this.parser.parseOpen(node);
+        return true;
+      default:
+        return false;
+    }
+  },
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  },
+  parseClose(name) {
+    switch (name) {
+      case 'comment':
+        return false;
+      case 'r':
+        this.model.note.texts.push(this.parser.model);
+        this.parser = undefined;
+        return true;
+      default:
+        if (this.parser) {
+          this.parser.parseClose(name);
+        }
+        return true;
+    }
+  },
+});

package/lib/xlsx/xform/comment/comments-xform.js

@@ -0,0 +1,82 @@
+const XmlStream = require('../../../utils/xml-stream');
+const utils = require('../../../utils/utils');
+const BaseXform = require('../base-xform');
+
+const CommentXform = require('./comment-xform');
+
+const CommentsXform = (module.exports = function() {
+  this.map = {
+    comment: new CommentXform(),
+  };
+});
+
+utils.inherits(
+  CommentsXform,
+  BaseXform,
+  {
+    COMMENTS_ATTRIBUTES: {
+      xmlns: 'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+    },
+  },
+  {
+    render(xmlStream, model) {
+      model = model || this.model;
+      xmlStream.openXml(XmlStream.StdDocAttributes);
+      xmlStream.openNode('comments', CommentsXform.COMMENTS_ATTRIBUTES);
+
+      // authors
+      // TODO: support authors properly
+      xmlStream.openNode('authors');
+      xmlStream.leafNode('author', null, 'Author');
+      xmlStream.closeNode();
+
+      // comments
+      xmlStream.openNode('commentList');
+      model.comments.forEach(comment => {
+        this.map.comment.render(xmlStream, comment);
+      });
+      xmlStream.closeNode();
+      xmlStream.closeNode();
+    },
+
+    parseOpen(node) {
+      if (this.parser) {
+        this.parser.parseOpen(node);
+        return true;
+      }
+      switch (node.name) {
+        case 'commentList':
+          this.model = {
+            comments: [],
+          };
+          return true;
+        case 'comment':
+          this.parser = this.map.comment;
+          this.parser.parseOpen(node);
+          return true;
+        default:
+          return false;
+      }
+    },
+    parseText(text) {
+      if (this.parser) {
+        this.parser.parseText(text);
+      }
+    },
+    parseClose(name) {
+      switch (name) {
+        case 'commentList':
+          return false;
+        case 'comment':
+          this.model.comments.push(this.parser.model);
+          this.parser = undefined;
+          return true;
+        default:
+          if (this.parser) {
+            this.parser.parseClose(name);
+          }
+          return true;
+      }
+    },
+  }
+);

package/lib/xlsx/xform/comment/style/vml-position-xform.js

@@ -0,0 +1,39 @@
+const BaseXform = require('../../base-xform');
+
+class VmlPositionXform extends BaseXform {
+  constructor(model) {
+    super();
+    this._model = model;
+  }
+
+  get tag() {
+    return this._model && this._model.tag;
+  }
+
+  render(xmlStream, model, type) {
+    if (model === type[2]) {
+      xmlStream.leafNode(this.tag);
+    } else if (this.tag === 'x:SizeWithCells' && model === type[1]) {
+      xmlStream.leafNode(this.tag);
+    }
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.model = {};
+        this.model[this.tag] = true;
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  parseText() {}
+
+  parseClose() {
+    return false;
+  }
+}
+
+module.exports = VmlPositionXform;

package/lib/xlsx/xform/comment/style/vml-protection-xform.js

@@ -0,0 +1,36 @@
+const BaseXform = require('../../base-xform');
+
+class VmlProtectionXform extends BaseXform {
+  constructor(model) {
+    super();
+    this._model = model;
+  }
+
+  get tag() {
+    return this._model && this._model.tag;
+  }
+
+  render(xmlStream, model) {
+    xmlStream.leafNode(this.tag, null, model);
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.text = '';
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  parseText(text) {
+    this.text = text;
+  }
+
+  parseClose() {
+    return false;
+  }
+}
+
+module.exports = VmlProtectionXform;

package/lib/xlsx/xform/comment/vml-anchor-xform.js

@@ -0,0 +1,60 @@
+const BaseXform = require('../base-xform');
+
+// render the triangle in the cell for the comment
+class VmlAnchorXform extends BaseXform {
+  get tag() {
+    return 'x:Anchor';
+  }
+
+  getAnchorRect(anchor) {
+    const l = Math.floor(anchor.left);
+    const lf = Math.floor((anchor.left - l) * 68);
+    const t = Math.floor(anchor.top);
+    const tf = Math.floor((anchor.top - t) * 18);
+    const r = Math.floor(anchor.right);
+    const rf = Math.floor((anchor.right - r) * 68);
+    const b = Math.floor(anchor.bottom);
+    const bf = Math.floor((anchor.bottom - b) * 18);
+    return [l, lf, t, tf, r, rf, b, bf];
+  }
+
+  getDefaultRect(ref) {
+    const l = ref.col;
+    const lf = 6;
+    const t = Math.max(ref.row - 2, 0);
+    const tf = 14;
+    const r = l + 2;
+    const rf = 2;
+    const b = t + 4;
+    const bf = 16;
+    return [l, lf, t, tf, r, rf, b, bf];
+  }
+
+  render(xmlStream, model) {
+    const rect = model.anchor
+      ? this.getAnchorRect(model.anchor)
+      : this.getDefaultRect(model.refAddress);
+
+    xmlStream.leafNode('x:Anchor', null, rect.join(', '));
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.text = '';
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  parseText(text) {
+    this.text = text;
+  }
+
+  parseClose() {
+    return false;
+  }
+}
+
+module.exports = VmlAnchorXform;

package/lib/xlsx/xform/comment/vml-client-data-xform.js

@@ -0,0 +1,95 @@
+const BaseXform = require('../base-xform');
+
+const VmlAnchorXform = require('./vml-anchor-xform');
+const VmlProtectionXform = require('./style/vml-protection-xform');
+const VmlPositionXform = require('./style/vml-position-xform');
+
+const POSITION_TYPE = ['twoCells', 'oneCells', 'absolute'];
+
+class VmlClientDataXform extends BaseXform {
+  constructor() {
+    super();
+    this.map = {
+      'x:Anchor': new VmlAnchorXform(),
+      'x:Locked': new VmlProtectionXform({tag: 'x:Locked'}),
+      'x:LockText': new VmlProtectionXform({tag: 'x:LockText'}),
+      'x:SizeWithCells': new VmlPositionXform({tag: 'x:SizeWithCells'}),
+      'x:MoveWithCells': new VmlPositionXform({tag: 'x:MoveWithCells'}),
+    };
+  }
+
+  get tag() {
+    return 'x:ClientData';
+  }
+
+  render(xmlStream, model) {
+    const {protection, editAs} = model.note;
+    xmlStream.openNode(this.tag, {ObjectType: 'Note'});
+    this.map['x:MoveWithCells'].render(xmlStream, editAs, POSITION_TYPE);
+    this.map['x:SizeWithCells'].render(xmlStream, editAs, POSITION_TYPE);
+    this.map['x:Anchor'].render(xmlStream, model);
+    this.map['x:Locked'].render(xmlStream, protection.locked);
+    xmlStream.leafNode('x:AutoFill', null, 'False');
+    this.map['x:LockText'].render(xmlStream, protection.lockText);
+    xmlStream.leafNode('x:Row', null, model.refAddress.row - 1);
+    xmlStream.leafNode('x:Column', null, model.refAddress.col - 1);
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.reset();
+        this.model = {
+          anchor: [],
+          protection: {},
+          editAs: '',
+        };
+        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.normalizeModel();
+        return false;
+      default:
+        return true;
+    }
+  }
+
+  normalizeModel() {
+    const position = Object.assign(
+      {},
+      this.map['x:MoveWithCells'].model,
+      this.map['x:SizeWithCells'].model
+    );
+    const len = Object.keys(position).length;
+    this.model.editAs = POSITION_TYPE[len];
+    this.model.anchor = this.map['x:Anchor'].text;
+    this.model.protection.locked = this.map['x:Locked'].text;
+    this.model.protection.lockText = this.map['x:LockText'].text;
+  }
+}
+
+module.exports = VmlClientDataXform;