zmdms-webui 1.9.3 → 1.9.5

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/cf/formula-xform.js

@@ -0,0 +1,29 @@
+import { b as baseXform } from '../../base-xform.js';
+
+const BaseXform = baseXform;
+
+class FormulaXform extends BaseXform {
+  get tag() {
+    return 'formula';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.leafNode(this.tag, null, model);
+  }
+
+  parseOpen() {
+    this.model = '';
+  }
+
+  parseText(text) {
+    this.model += text;
+  }
+
+  parseClose(name) {
+    return name !== this.tag;
+  }
+}
+
+var formulaXform = FormulaXform;
+
+export { formulaXform as f };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/cf/icon-set-xform.js

@@ -0,0 +1,53 @@
+import { b as baseXform } from '../../base-xform.js';
+import { c as compositeXform } from '../../composite-xform.js';
+import { c as cfvoXform } from './cfvo-xform.js';
+
+const BaseXform = baseXform;
+const CompositeXform = compositeXform;
+
+const CfvoXform = cfvoXform;
+
+class IconSetXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      cfvo: (this.cfvoXform = new CfvoXform()),
+    };
+  }
+
+  get tag() {
+    return 'iconSet';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      iconSet: BaseXform.toStringAttribute(model.iconSet, '3TrafficLights'),
+      reverse: BaseXform.toBoolAttribute(model.reverse, false),
+      showValue: BaseXform.toBoolAttribute(model.showValue, true),
+    });
+
+    model.cfvo.forEach(cfvo => {
+      this.cfvoXform.render(xmlStream, cfvo);
+    });
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel({attributes}) {
+    return {
+      iconSet: BaseXform.toStringValue(attributes.iconSet, '3TrafficLights'),
+      reverse: BaseXform.toBoolValue(attributes.reverse),
+      showValue: BaseXform.toBoolValue(attributes.showValue),
+      cfvo: [],
+    };
+  }
+
+  onParserClose(name, parser) {
+    this.model[name].push(parser.model);
+  }
+}
+
+var iconSetXform = IconSetXform;
+
+export { iconSetXform as i };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/cf-ext/cf-icon-ext-xform.js

@@ -0,0 +1,31 @@
+import { b as baseXform } from '../../base-xform.js';
+
+const BaseXform = baseXform;
+
+class CfIconExtXform extends BaseXform {
+  get tag() {
+    return 'x14:cfIcon';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.leafNode(this.tag, {
+      iconSet: model.iconSet,
+      iconId: model.iconId,
+    });
+  }
+
+  parseOpen({attributes}) {
+    this.model = {
+      iconSet: attributes.iconSet,
+      iconId: BaseXform.toIntValue(attributes.iconId),
+    };
+  }
+
+  parseClose(name) {
+    return name !== this.tag;
+  }
+}
+
+var cfIconExtXform = CfIconExtXform;
+
+export { cfIconExtXform as c };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/cf-ext/cf-rule-ext-xform.js

@@ -0,0 +1,106 @@
+import require$$0 from '../../../../../../../_virtual/index16.js';
+import { b as baseXform } from '../../base-xform.js';
+import { c as compositeXform } from '../../composite-xform.js';
+import { d as databarExtXform } from './databar-ext-xform.js';
+import { i as iconSetExtXform } from './icon-set-ext-xform.js';
+
+const {v4: uuidv4} = require$$0;
+const BaseXform = baseXform;
+const CompositeXform = compositeXform;
+
+const DatabarExtXform = databarExtXform;
+const IconSetExtXform = iconSetExtXform;
+
+const extIcons = {
+  '3Triangles': true,
+  '3Stars': true,
+  '5Boxes': true,
+};
+
+class CfRuleExtXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      'x14:dataBar': (this.databarXform = new DatabarExtXform()),
+      'x14:iconSet': (this.iconSetXform = new IconSetExtXform()),
+    };
+  }
+
+  get tag() {
+    return 'x14:cfRule';
+  }
+
+  static isExt(rule) {
+    // is this rule primitive?
+    if (rule.type === 'dataBar') {
+      return DatabarExtXform.isExt(rule);
+    }
+    if (rule.type === 'iconSet') {
+      if (rule.custom || extIcons[rule.iconSet]) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  prepare(model) {
+    if (CfRuleExtXform.isExt(model)) {
+      model.x14Id = `{${uuidv4()}}`.toUpperCase();
+    }
+  }
+
+  render(xmlStream, model) {
+    if (!CfRuleExtXform.isExt(model)) {
+      return;
+    }
+
+    switch (model.type) {
+      case 'dataBar':
+        this.renderDataBar(xmlStream, model);
+        break;
+      case 'iconSet':
+        this.renderIconSet(xmlStream, model);
+        break;
+    }
+  }
+
+  renderDataBar(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      type: 'dataBar',
+      id: model.x14Id,
+    });
+
+    this.databarXform.render(xmlStream, model);
+
+    xmlStream.closeNode();
+  }
+
+  renderIconSet(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      type: 'iconSet',
+      priority: model.priority,
+      id: model.x14Id || `{${uuidv4()}}`,
+    });
+
+    this.iconSetXform.render(xmlStream, model);
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel({attributes}) {
+    return {
+      type: attributes.type,
+      x14Id: attributes.id,
+      priority: BaseXform.toIntValue(attributes.priority),
+    };
+  }
+
+  onParserClose(name, parser) {
+    Object.assign(this.model, parser.model);
+  }
+}
+
+var cfRuleExtXform = CfRuleExtXform;
+
+export { cfRuleExtXform as c };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/cf-ext/cfvo-ext-xform.js

@@ -0,0 +1,48 @@
+import { c as compositeXform } from '../../composite-xform.js';
+import { f as fExtXform } from './f-ext-xform.js';
+
+const CompositeXform = compositeXform;
+
+const FExtXform = fExtXform;
+
+class CfvoExtXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      'xm:f': (this.fExtXform = new FExtXform()),
+    };
+  }
+
+  get tag() {
+    return 'x14:cfvo';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      type: model.type,
+    });
+    if (model.value !== undefined) {
+      this.fExtXform.render(xmlStream, model.value);
+    }
+    xmlStream.closeNode();
+  }
+
+  createNewModel(node) {
+    return {
+      type: node.attributes.type,
+    };
+  }
+
+  onParserClose(name, parser) {
+    switch (name) {
+      case 'xm:f':
+        this.model.value = parser.model ? parseFloat(parser.model) : 0;
+        break;
+    }
+  }
+}
+
+var cfvoExtXform = CfvoExtXform;
+
+export { cfvoExtXform as c };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/cf-ext/conditional-formatting-ext-xform.js

@@ -0,0 +1,68 @@
+import { c as compositeXform } from '../../composite-xform.js';
+import { s as sqrefExtXform } from './sqref-ext-xform.js';
+import { c as cfRuleExtXform } from './cf-rule-ext-xform.js';
+
+const CompositeXform = compositeXform;
+
+const SqRefExtXform = sqrefExtXform;
+const CfRuleExtXform = cfRuleExtXform;
+
+class ConditionalFormattingExtXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      'xm:sqref': (this.sqRef = new SqRefExtXform()),
+      'x14:cfRule': (this.cfRule = new CfRuleExtXform()),
+    };
+  }
+
+  get tag() {
+    return 'x14:conditionalFormatting';
+  }
+
+  prepare(model, options) {
+    model.rules.forEach(rule => {
+      this.cfRule.prepare(rule, options);
+    });
+  }
+
+  render(xmlStream, model) {
+    if (!model.rules.some(CfRuleExtXform.isExt)) {
+      return;
+    }
+
+    xmlStream.openNode(this.tag, {
+      'xmlns:xm': 'http://schemas.microsoft.com/office/excel/2006/main',
+    });
+
+    model.rules.filter(CfRuleExtXform.isExt).forEach(rule => this.cfRule.render(xmlStream, rule));
+
+    // for some odd reason, Excel needs the <xm:sqref> node to be after the rules
+    this.sqRef.render(xmlStream, model.ref);
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel() {
+    return {
+      rules: [],
+    };
+  }
+
+  onParserClose(name, parser) {
+    switch (name) {
+      case 'xm:sqref':
+        this.model.ref = parser.model;
+        break;
+
+      case 'x14:cfRule':
+        this.model.rules.push(parser.model);
+        break;
+    }
+  }
+}
+
+var conditionalFormattingExtXform = ConditionalFormattingExtXform;
+
+export { conditionalFormattingExtXform as c };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/cf-ext/conditional-formattings-ext-xform.js

@@ -0,0 +1,56 @@
+import { c as compositeXform } from '../../composite-xform.js';
+import { c as cfRuleExtXform } from './cf-rule-ext-xform.js';
+import { c as conditionalFormattingExtXform } from './conditional-formatting-ext-xform.js';
+
+const CompositeXform = compositeXform;
+
+const CfRuleExtXform = cfRuleExtXform;
+const ConditionalFormattingExtXform = conditionalFormattingExtXform;
+
+class ConditionalFormattingsExtXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      'x14:conditionalFormatting': (this.cfXform = new ConditionalFormattingExtXform()),
+    };
+  }
+
+  get tag() {
+    return 'x14:conditionalFormattings';
+  }
+
+  hasContent(model) {
+    if (model.hasExtContent === undefined) {
+      model.hasExtContent = model.some(cf => cf.rules.some(CfRuleExtXform.isExt));
+    }
+    return model.hasExtContent;
+  }
+
+  prepare(model, options) {
+    model.forEach(cf => {
+      this.cfXform.prepare(cf, options);
+    });
+  }
+
+  render(xmlStream, model) {
+    if (this.hasContent(model)) {
+      xmlStream.openNode(this.tag);
+      model.forEach(cf => this.cfXform.render(xmlStream, cf));
+      xmlStream.closeNode();
+    }
+  }
+
+  createNewModel() {
+    return [];
+  }
+
+  onParserClose(name, parser) {
+    // model is array of conditional formatting objects
+    this.model.push(parser.model);
+  }
+}
+
+var conditionalFormattingsExtXform = ConditionalFormattingsExtXform;
+
+export { conditionalFormattingsExtXform as c };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/cf-ext/databar-ext-xform.js

@@ -0,0 +1,105 @@
+import { b as baseXform } from '../../base-xform.js';
+import { c as compositeXform } from '../../composite-xform.js';
+import { c as colorXform } from '../../style/color-xform.js';
+import { c as cfvoExtXform } from './cfvo-ext-xform.js';
+
+const BaseXform = baseXform;
+const CompositeXform = compositeXform;
+
+const ColorXform = colorXform;
+const CfvoExtXform = cfvoExtXform;
+
+class DatabarExtXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      'x14:cfvo': (this.cfvoXform = new CfvoExtXform()),
+      'x14:borderColor': (this.borderColorXform = new ColorXform('x14:borderColor')),
+      'x14:negativeBorderColor': (this.negativeBorderColorXform = new ColorXform(
+        'x14:negativeBorderColor'
+      )),
+      'x14:negativeFillColor': (this.negativeFillColorXform = new ColorXform(
+        'x14:negativeFillColor'
+      )),
+      'x14:axisColor': (this.axisColorXform = new ColorXform('x14:axisColor')),
+    };
+  }
+
+  static isExt(rule) {
+    // not all databars need ext
+    // TODO: refine this
+    return !rule.gradient;
+  }
+
+  get tag() {
+    return 'x14:dataBar';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      minLength: BaseXform.toIntAttribute(model.minLength, 0, true),
+      maxLength: BaseXform.toIntAttribute(model.maxLength, 100, true),
+      border: BaseXform.toBoolAttribute(model.border, false),
+      gradient: BaseXform.toBoolAttribute(model.gradient, true),
+      negativeBarColorSameAsPositive: BaseXform.toBoolAttribute(
+        model.negativeBarColorSameAsPositive,
+        true
+      ),
+      negativeBarBorderColorSameAsPositive: BaseXform.toBoolAttribute(
+        model.negativeBarBorderColorSameAsPositive,
+        true
+      ),
+      axisPosition: BaseXform.toAttribute(model.axisPosition, 'auto'),
+      direction: BaseXform.toAttribute(model.direction, 'leftToRight'),
+    });
+
+    model.cfvo.forEach(cfvo => {
+      this.cfvoXform.render(xmlStream, cfvo);
+    });
+
+    this.borderColorXform.render(xmlStream, model.borderColor);
+    this.negativeBorderColorXform.render(xmlStream, model.negativeBorderColor);
+    this.negativeFillColorXform.render(xmlStream, model.negativeFillColor);
+    this.axisColorXform.render(xmlStream, model.axisColor);
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel({attributes}) {
+    return {
+      cfvo: [],
+      minLength: BaseXform.toIntValue(attributes.minLength, 0),
+      maxLength: BaseXform.toIntValue(attributes.maxLength, 100),
+      border: BaseXform.toBoolValue(attributes.border, false),
+      gradient: BaseXform.toBoolValue(attributes.gradient, true),
+      negativeBarColorSameAsPositive: BaseXform.toBoolValue(
+        attributes.negativeBarColorSameAsPositive,
+        true
+      ),
+      negativeBarBorderColorSameAsPositive: BaseXform.toBoolValue(
+        attributes.negativeBarBorderColorSameAsPositive,
+        true
+      ),
+      axisPosition: BaseXform.toStringValue(attributes.axisPosition, 'auto'),
+      direction: BaseXform.toStringValue(attributes.direction, 'leftToRight'),
+    };
+  }
+
+  onParserClose(name, parser) {
+    const [, prop] = name.split(':');
+    switch (prop) {
+      case 'cfvo':
+        this.model.cfvo.push(parser.model);
+        break;
+
+      default:
+        this.model[prop] = parser.model;
+        break;
+    }
+  }
+}
+
+var databarExtXform = DatabarExtXform;
+
+export { databarExtXform as d };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/cf-ext/f-ext-xform.js

@@ -0,0 +1,29 @@
+import { b as baseXform } from '../../base-xform.js';
+
+const BaseXform = baseXform;
+
+class FExtXform extends BaseXform {
+  get tag() {
+    return 'xm:f';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.leafNode(this.tag, null, model);
+  }
+
+  parseOpen() {
+    this.model = '';
+  }
+
+  parseText(text) {
+    this.model += text;
+  }
+
+  parseClose(name) {
+    return name !== this.tag;
+  }
+}
+
+var fExtXform = FExtXform;
+
+export { fExtXform as f };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/cf-ext/icon-set-ext-xform.js

@@ -0,0 +1,80 @@
+import { b as baseXform } from '../../base-xform.js';
+import { c as compositeXform } from '../../composite-xform.js';
+import { c as cfvoExtXform } from './cfvo-ext-xform.js';
+import { c as cfIconExtXform } from './cf-icon-ext-xform.js';
+
+const BaseXform = baseXform;
+const CompositeXform = compositeXform;
+
+const CfvoExtXform = cfvoExtXform;
+const CfIconExtXform = cfIconExtXform;
+
+class IconSetExtXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      'x14:cfvo': (this.cfvoXform = new CfvoExtXform()),
+      'x14:cfIcon': (this.cfIconXform = new CfIconExtXform()),
+    };
+  }
+
+  get tag() {
+    return 'x14:iconSet';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag, {
+      iconSet: BaseXform.toStringAttribute(model.iconSet),
+      reverse: BaseXform.toBoolAttribute(model.reverse, false),
+      showValue: BaseXform.toBoolAttribute(model.showValue, true),
+      custom: BaseXform.toBoolAttribute(model.icons, false),
+    });
+
+    model.cfvo.forEach(cfvo => {
+      this.cfvoXform.render(xmlStream, cfvo);
+    });
+
+    if (model.icons) {
+      model.icons.forEach((icon, i) => {
+        icon.iconId = i;
+        this.cfIconXform.render(xmlStream, icon);
+      });
+    }
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel({attributes}) {
+    return {
+      cfvo: [],
+      iconSet: BaseXform.toStringValue(attributes.iconSet, '3TrafficLights'),
+      reverse: BaseXform.toBoolValue(attributes.reverse, false),
+      showValue: BaseXform.toBoolValue(attributes.showValue, true),
+    };
+  }
+
+  onParserClose(name, parser) {
+    const [, prop] = name.split(':');
+    switch (prop) {
+      case 'cfvo':
+        this.model.cfvo.push(parser.model);
+        break;
+
+      case 'cfIcon':
+        if (!this.model.icons) {
+          this.model.icons = [];
+        }
+        this.model.icons.push(parser.model);
+        break;
+
+      default:
+        this.model[prop] = parser.model;
+        break;
+    }
+  }
+}
+
+var iconSetExtXform = IconSetExtXform;
+
+export { iconSetExtXform as i };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/cf-ext/sqref-ext-xform.js

@@ -0,0 +1,29 @@
+import { b as baseXform } from '../../base-xform.js';
+
+const BaseXform = baseXform;
+
+class SqrefExtXform extends BaseXform {
+  get tag() {
+    return 'xm:sqref';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.leafNode(this.tag, null, model);
+  }
+
+  parseOpen() {
+    this.model = '';
+  }
+
+  parseText(text) {
+    this.model += text;
+  }
+
+  parseClose(name) {
+    return name !== this.tag;
+  }
+}
+
+var sqrefExtXform = SqrefExtXform;
+
+export { sqrefExtXform as s };