@alienkarma/exceljs 4.4.0-fork.1

package/lib/xlsx/xform/style/fill-xform.js

@@ -0,0 +1,364 @@
+/* eslint-disable max-classes-per-file */
+const BaseXform = require('../base-xform');
+
+const ColorXform = require('./color-xform');
+
+class StopXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {
+      color: new ColorXform(),
+    };
+  }
+
+  get tag() {
+    return 'stop';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode('stop');
+    xmlStream.addAttribute('position', model.position);
+    this.map.color.render(xmlStream, model.color);
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'stop':
+        this.model = {
+          position: parseFloat(node.attributes.position),
+        };
+        return true;
+      case 'color':
+        this.parser = this.map.color;
+        this.parser.parseOpen(node);
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  parseText() {}
+
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.model.color = this.parser.model;
+        this.parser = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+}
+
+class PatternFillXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {
+      fgColor: new ColorXform('fgColor'),
+      bgColor: new ColorXform('bgColor'),
+    };
+  }
+
+  get name() {
+    return 'pattern';
+  }
+
+  get tag() {
+    return 'patternFill';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode('patternFill');
+    xmlStream.addAttribute('patternType', model.pattern);
+    if (model.fgColor) {
+      this.map.fgColor.render(xmlStream, model.fgColor);
+    }
+    if (model.bgColor) {
+      this.map.bgColor.render(xmlStream, model.bgColor);
+    }
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'patternFill':
+        this.model = {
+          type: 'pattern',
+          pattern: node.attributes.patternType,
+        };
+        return true;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+          return true;
+        }
+        return false;
+    }
+  }
+
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        if (this.parser.model) {
+          this.model[name] = this.parser.model;
+        }
+        this.parser = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+}
+
+class GradientFillXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {
+      stop: new StopXform(),
+    };
+    // if (model) {
+    //   this.gradient = model.gradient;
+    //   if (model.center) {
+    //     this.center = model.center;
+    //   }
+    //   if (model.degree !== undefined) {
+    //     this.degree = model.degree;
+    //   }
+    //   this.stops = model.stops.map(function(stop) { return new StopXform(stop); });
+    // } else {
+    //   this.stops = [];
+    // }
+  }
+
+  get name() {
+    return 'gradient';
+  }
+
+  get tag() {
+    return 'gradientFill';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode('gradientFill');
+    switch (model.gradient) {
+      case 'angle':
+        xmlStream.addAttribute('degree', model.degree);
+        break;
+      case 'path':
+        xmlStream.addAttribute('type', 'path');
+        if (model.center.left) {
+          xmlStream.addAttribute('left', model.center.left);
+          if (model.center.right === undefined) {
+            xmlStream.addAttribute('right', model.center.left);
+          }
+        }
+        if (model.center.right) {
+          xmlStream.addAttribute('right', model.center.right);
+        }
+        if (model.center.top) {
+          xmlStream.addAttribute('top', model.center.top);
+          if (model.center.bottom === undefined) {
+            xmlStream.addAttribute('bottom', model.center.top);
+          }
+        }
+        if (model.center.bottom) {
+          xmlStream.addAttribute('bottom', model.center.bottom);
+        }
+        break;
+
+      default:
+        break;
+    }
+
+    const stopXform = this.map.stop;
+    model.stops.forEach(stopModel => {
+      stopXform.render(xmlStream, stopModel);
+    });
+
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'gradientFill': {
+        const model = (this.model = {
+          stops: [],
+        });
+        if (node.attributes.degree) {
+          model.gradient = 'angle';
+          model.degree = parseInt(node.attributes.degree, 10);
+        } else if (node.attributes.type === 'path') {
+          model.gradient = 'path';
+          model.center = {
+            left: node.attributes.left ? parseFloat(node.attributes.left) : 0,
+            top: node.attributes.top ? parseFloat(node.attributes.top) : 0,
+          };
+          if (node.attributes.right !== node.attributes.left) {
+            model.center.right = node.attributes.right ? parseFloat(node.attributes.right) : 0;
+          }
+          if (node.attributes.bottom !== node.attributes.top) {
+            model.center.bottom = node.attributes.bottom ? parseFloat(node.attributes.bottom) : 0;
+          }
+        }
+        return true;
+      }
+
+      case 'stop':
+        this.parser = this.map.stop;
+        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)) {
+        this.model.stops.push(this.parser.model);
+        this.parser = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+}
+
+// Fill encapsulates translation from fill model to/from xlsx
+class FillXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {
+      patternFill: new PatternFillXform(),
+      gradientFill: new GradientFillXform(),
+    };
+  }
+
+  get tag() {
+    return 'fill';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.addRollback();
+    xmlStream.openNode('fill');
+    switch (model.type) {
+      case 'pattern':
+        this.map.patternFill.render(xmlStream, model);
+        break;
+      case 'gradient':
+        this.map.gradientFill.render(xmlStream, model);
+        break;
+      default:
+        xmlStream.rollback();
+        return;
+    }
+    xmlStream.closeNode();
+    xmlStream.commit();
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'fill':
+        this.model = {};
+        return true;
+      default:
+        this.parser = this.map[node.name];
+        if (this.parser) {
+          this.parser.parseOpen(node);
+          return true;
+        }
+        return false;
+    }
+  }
+
+  parseText(text) {
+    if (this.parser) {
+      this.parser.parseText(text);
+    }
+  }
+
+  parseClose(name) {
+    if (this.parser) {
+      if (!this.parser.parseClose(name)) {
+        this.model = this.parser.model;
+        this.model.type = this.parser.name;
+        this.parser = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  validStyle(value) {
+    return FillXform.validPatternValues[value];
+  }
+}
+
+FillXform.validPatternValues = [
+  'none',
+  'solid',
+  'darkVertical',
+  'darkGray',
+  'mediumGray',
+  'lightGray',
+  'gray125',
+  'gray0625',
+  'darkHorizontal',
+  'darkVertical',
+  'darkDown',
+  'darkUp',
+  'darkGrid',
+  'darkTrellis',
+  'lightHorizontal',
+  'lightVertical',
+  'lightDown',
+  'lightUp',
+  'lightGrid',
+  'lightTrellis',
+  'lightGrid',
+].reduce((p, v) => {
+  p[v] = true;
+  return p;
+}, {});
+
+FillXform.StopXform = StopXform;
+FillXform.PatternFillXform = PatternFillXform;
+FillXform.GradientFillXform = GradientFillXform;
+
+module.exports = FillXform;

package/lib/xlsx/xform/style/font-xform.js

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

package/lib/xlsx/xform/style/numfmt-xform.js

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

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

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

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

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