zmdms-webui 1.9.3 → 1.9.5

package/dist/es/node_modules/exceljs/lib/xlsx/xform/style/alignment-xform.js

@@ -0,0 +1,178 @@
+import { e as enums } from '../../../doc/enums.js';
+import { u as utils_1 } from '../../../utils/utils.js';
+import { b as baseXform } from '../base-xform.js';
+
+const Enums = enums;
+
+const utils = utils_1;
+const BaseXform = baseXform;
+
+const validation = {
+  horizontalValues: [
+    'left',
+    'center',
+    'right',
+    'fill',
+    'centerContinuous',
+    'distributed',
+    'justify',
+  ].reduce((p, v) => {
+    p[v] = true;
+    return p;
+  }, {}),
+  horizontal(value) {
+    return this.horizontalValues[value] ? value : undefined;
+  },
+
+  verticalValues: ['top', 'middle', 'bottom', 'distributed', 'justify'].reduce((p, v) => {
+    p[v] = true;
+    return p;
+  }, {}),
+  vertical(value) {
+    if (value === 'middle') return 'center';
+    return this.verticalValues[value] ? value : undefined;
+  },
+  wrapText(value) {
+    return value ? true : undefined;
+  },
+  shrinkToFit(value) {
+    return value ? true : undefined;
+  },
+  textRotation(value) {
+    switch (value) {
+      case 'vertical':
+        return value;
+      default:
+        value = utils.validInt(value);
+        return value >= -90 && value <= 90 ? value : undefined;
+    }
+  },
+  indent(value) {
+    value = utils.validInt(value);
+    return Math.max(0, value);
+  },
+  readingOrder(value) {
+    switch (value) {
+      case 'ltr':
+        return Enums.ReadingOrder.LeftToRight;
+      case 'rtl':
+        return Enums.ReadingOrder.RightToLeft;
+      default:
+        return undefined;
+    }
+  },
+};
+
+const textRotationXform = {
+  toXml(textRotation) {
+    textRotation = validation.textRotation(textRotation);
+    if (textRotation) {
+      if (textRotation === 'vertical') {
+        return 255;
+      }
+
+      const tr = Math.round(textRotation);
+      if (tr >= 0 && tr <= 90) {
+        return tr;
+      }
+
+      if (tr < 0 && tr >= -90) {
+        return 90 - tr;
+      }
+    }
+    return undefined;
+  },
+  toModel(textRotation) {
+    const tr = utils.validInt(textRotation);
+    if (tr !== undefined) {
+      if (tr === 255) {
+        return 'vertical';
+      }
+      if (tr >= 0 && tr <= 90) {
+        return tr;
+      }
+      if (tr > 90 && tr <= 180) {
+        return 90 - tr;
+      }
+    }
+    return undefined;
+  },
+};
+
+// Alignment encapsulates translation from style.alignment model to/from xlsx
+class AlignmentXform extends BaseXform {
+  get tag() {
+    return 'alignment';
+  }
+
+  render(xmlStream, model) {
+    xmlStream.addRollback();
+    xmlStream.openNode('alignment');
+
+    let isValid = false;
+    function add(name, value) {
+      if (value) {
+        xmlStream.addAttribute(name, value);
+        isValid = true;
+      }
+    }
+    add('horizontal', validation.horizontal(model.horizontal));
+    add('vertical', validation.vertical(model.vertical));
+    add('wrapText', validation.wrapText(model.wrapText) ? '1' : false);
+    add('shrinkToFit', validation.shrinkToFit(model.shrinkToFit) ? '1' : false);
+    add('indent', validation.indent(model.indent));
+    add('textRotation', textRotationXform.toXml(model.textRotation));
+    add('readingOrder', validation.readingOrder(model.readingOrder));
+
+    xmlStream.closeNode();
+
+    if (isValid) {
+      xmlStream.commit();
+    } else {
+      xmlStream.rollback();
+    }
+  }
+
+  parseOpen(node) {
+    const model = {};
+
+    let valid = false;
+    function add(truthy, name, value) {
+      if (truthy) {
+        model[name] = value;
+        valid = true;
+      }
+    }
+    add(node.attributes.horizontal, 'horizontal', node.attributes.horizontal);
+    add(
+      node.attributes.vertical,
+      'vertical',
+      node.attributes.vertical === 'center' ? 'middle' : node.attributes.vertical
+    );
+    add(node.attributes.wrapText, 'wrapText', utils.parseBoolean(node.attributes.wrapText));
+    add(node.attributes.shrinkToFit, 'shrinkToFit', utils.parseBoolean(node.attributes.shrinkToFit));
+    add(node.attributes.indent, 'indent', parseInt(node.attributes.indent, 10));
+    add(
+      node.attributes.textRotation,
+      'textRotation',
+      textRotationXform.toModel(node.attributes.textRotation)
+    );
+    add(
+      node.attributes.readingOrder,
+      'readingOrder',
+      node.attributes.readingOrder === '2' ? 'rtl' : 'ltr'
+    );
+
+    this.model = valid ? model : null;
+  }
+
+  parseText() {}
+
+  parseClose() {
+    return false;
+  }
+}
+
+var alignmentXform = AlignmentXform;
+
+export { alignmentXform as a };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/style/border-xform.js

@@ -0,0 +1,214 @@
+import { b as baseXform } from '../base-xform.js';
+import { u as utils_1 } from '../../../utils/utils.js';
+import { c as colorXform } from './color-xform.js';
+
+/* eslint-disable max-classes-per-file */
+
+const BaseXform = baseXform;
+const utils = utils_1;
+
+const ColorXform = colorXform;
+
+class EdgeXform extends BaseXform {
+  constructor(name) {
+    super();
+
+    this.name = name;
+    this.map = {
+      color: new ColorXform(),
+    };
+  }
+
+  get tag() {
+    return this.name;
+  }
+
+  render(xmlStream, model, defaultColor) {
+    const color = (model && model.color) || defaultColor || this.defaultColor;
+    xmlStream.openNode(this.name);
+    if (model && model.style) {
+      xmlStream.addAttribute('style', model.style);
+      if (color) {
+        this.map.color.render(xmlStream, color);
+      }
+    }
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case this.name: {
+        const {style} = node.attributes;
+        if (style) {
+          this.model = {
+            style,
+          };
+        } else {
+          this.model = undefined;
+        }
+        return true;
+      }
+      case 'color':
+        this.parser = this.map.color;
+        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.parser = undefined;
+      }
+      return true;
+    }
+
+    if (name === this.name) {
+      if (this.map.color.model) {
+        if (!this.model) {
+          this.model = {};
+        }
+        this.model.color = this.map.color.model;
+      }
+    }
+
+    return false;
+  }
+
+  validStyle(value) {
+    return EdgeXform.validStyleValues[value];
+  }
+}
+
+EdgeXform.validStyleValues = [
+  'thin',
+  'dashed',
+  'dotted',
+  'dashDot',
+  'hair',
+  'dashDotDot',
+  'slantDashDot',
+  'mediumDashed',
+  'mediumDashDotDot',
+  'mediumDashDot',
+  'medium',
+  'double',
+  'thick',
+].reduce((p, v) => {
+  p[v] = true;
+  return p;
+}, {});
+
+// Border encapsulates translation from border model to/from xlsx
+class BorderXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {
+      top: new EdgeXform('top'),
+      left: new EdgeXform('left'),
+      bottom: new EdgeXform('bottom'),
+      right: new EdgeXform('right'),
+      diagonal: new EdgeXform('diagonal'),
+    };
+  }
+
+  render(xmlStream, model) {
+    const {color} = model;
+    xmlStream.openNode('border');
+    if (model.diagonal && model.diagonal.style) {
+      if (model.diagonal.up) {
+        xmlStream.addAttribute('diagonalUp', '1');
+      }
+      if (model.diagonal.down) {
+        xmlStream.addAttribute('diagonalDown', '1');
+      }
+    }
+    function add(edgeModel, edgeXform) {
+      if (edgeModel && !edgeModel.color && model.color) {
+        // don't mess with incoming models
+        edgeModel = {
+          ...edgeModel,
+          color: model.color,
+        };
+      }
+      edgeXform.render(xmlStream, edgeModel, color);
+    }
+    add(model.left, this.map.left);
+    add(model.right, this.map.right);
+    add(model.top, this.map.top);
+    add(model.bottom, this.map.bottom);
+    add(model.diagonal, this.map.diagonal);
+
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+    switch (node.name) {
+      case 'border':
+        this.reset();
+        this.diagonalUp = utils.parseBoolean(node.attributes.diagonalUp);
+        this.diagonalDown = utils.parseBoolean(node.attributes.diagonalDown);
+        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.parser = undefined;
+      }
+      return true;
+    }
+    if (name === 'border') {
+      const model = (this.model = {});
+      const add = function(key, edgeModel, extensions) {
+        if (edgeModel) {
+          if (extensions) {
+            Object.assign(edgeModel, extensions);
+          }
+          model[key] = edgeModel;
+        }
+      };
+      add('left', this.map.left.model);
+      add('right', this.map.right.model);
+      add('top', this.map.top.model);
+      add('bottom', this.map.bottom.model);
+      add('diagonal', this.map.diagonal.model, {up: this.diagonalUp, down: this.diagonalDown});
+    }
+    return false;
+  }
+}
+
+var borderXform = BorderXform;
+
+export { borderXform as b };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/style/color-xform.js

@@ -0,0 +1,67 @@
+import { b as baseXform } from '../base-xform.js';
+
+const BaseXform = baseXform;
+
+// Color encapsulates translation from color model to/from xlsx
+class ColorXform extends BaseXform {
+  constructor(name) {
+    super();
+
+    // this.name controls the xm node name
+    this.name = name || 'color';
+  }
+
+  get tag() {
+    return this.name;
+  }
+
+  render(xmlStream, model) {
+    if (model) {
+      xmlStream.openNode(this.name);
+      if (model.argb) {
+        xmlStream.addAttribute('rgb', model.argb);
+      } else if (model.theme !== undefined) {
+        xmlStream.addAttribute('theme', model.theme);
+        if (model.tint !== undefined) {
+          xmlStream.addAttribute('tint', model.tint);
+        }
+      } else if (model.indexed !== undefined) {
+        xmlStream.addAttribute('indexed', model.indexed);
+      } else {
+        xmlStream.addAttribute('auto', '1');
+      }
+      xmlStream.closeNode();
+      return true;
+    }
+    return false;
+  }
+
+  parseOpen(node) {
+    if (node.name === this.name) {
+      if (node.attributes.rgb) {
+        this.model = {argb: node.attributes.rgb};
+      } else if (node.attributes.theme) {
+        this.model = {theme: parseInt(node.attributes.theme, 10)};
+        if (node.attributes.tint) {
+          this.model.tint = parseFloat(node.attributes.tint);
+        }
+      } else if (node.attributes.indexed) {
+        this.model = {indexed: parseInt(node.attributes.indexed, 10)};
+      } else {
+        this.model = undefined;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  parseText() {}
+
+  parseClose() {
+    return false;
+  }
+}
+
+var colorXform = ColorXform;
+
+export { colorXform as c };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/style/dxf-xform.js

@@ -0,0 +1,121 @@
+import { b as baseXform } from '../base-xform.js';
+import { a as alignmentXform } from './alignment-xform.js';
+import { b as borderXform } from './border-xform.js';
+import { f as fillXform } from './fill-xform.js';
+import { f as fontXform } from './font-xform.js';
+import { n as numfmtXform } from './numfmt-xform.js';
+import { p as protectionXform } from './protection-xform.js';
+
+const BaseXform = baseXform;
+
+const AlignmentXform = alignmentXform;
+const BorderXform = borderXform;
+const FillXform = fillXform;
+const FontXform = fontXform;
+const NumFmtXform = numfmtXform;
+const ProtectionXform = protectionXform;
+
+// <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 DxfXform extends BaseXform {
+  constructor() {
+    super();
+
+    this.map = {
+      alignment: new AlignmentXform(),
+      border: new BorderXform(),
+      fill: new FillXform(),
+      font: new FontXform(),
+      numFmt: new NumFmtXform(),
+      protection: new ProtectionXform(),
+    };
+  }
+
+  get tag() {
+    return 'dxf';
+  }
+
+  // how do we generate dxfid?
+
+  render(xmlStream, model) {
+    xmlStream.openNode(this.tag);
+
+    if (model.font) {
+      this.map.font.render(xmlStream, model.font);
+    }
+    if (model.numFmt && model.numFmtId) {
+      const numFmtModel = {id: model.numFmtId, formatCode: model.numFmt};
+      this.map.numFmt.render(xmlStream, numFmtModel);
+    }
+    if (model.fill) {
+      this.map.fill.render(xmlStream, model.fill);
+    }
+    if (model.alignment) {
+      this.map.alignment.render(xmlStream, model.alignment);
+    }
+    if (model.border) {
+      this.map.border.render(xmlStream, model.border);
+    }
+    if (model.protection) {
+      this.map.protection.render(xmlStream, model.protection);
+    }
+
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    if (this.parser) {
+      this.parser.parseOpen(node);
+      return true;
+    }
+
+    switch (node.name) {
+      case this.tag:
+        // this node is often repeated. Need to reset children
+        this.reset();
+        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;
+    }
+    if (name === this.tag) {
+      this.model = {
+        alignment: this.map.alignment.model,
+        border: this.map.border.model,
+        fill: this.map.fill.model,
+        font: this.map.font.model,
+        numFmt: this.map.numFmt.model,
+        protection: this.map.protection.model,
+      };
+      return false;
+    }
+
+    return true;
+  }
+}
+
+var dxfXform = DxfXform;
+
+export { dxfXform as d };