zmdms-webui 1.9.3 → 1.9.5

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

@@ -0,0 +1,91 @@
+import { u as utils_1 } from '../../../utils/utils.js';
+import { b as baseXform } from '../base-xform.js';
+
+const utils = utils_1;
+const BaseXform = baseXform;
+
+class ColXform extends BaseXform {
+  get tag() {
+    return 'col';
+  }
+
+  prepare(model, options) {
+    const styleId = options.styles.addStyleModel(model.style || {});
+    if (styleId) {
+      model.styleId = styleId;
+    }
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode('col');
+    xmlStream.addAttribute('min', model.min);
+    xmlStream.addAttribute('max', model.max);
+    if (model.width) {
+      xmlStream.addAttribute('width', model.width);
+    }
+    if (model.styleId) {
+      xmlStream.addAttribute('style', model.styleId);
+    }
+    if (model.hidden) {
+      xmlStream.addAttribute('hidden', '1');
+    }
+    if (model.bestFit) {
+      xmlStream.addAttribute('bestFit', '1');
+    }
+    if (model.outlineLevel) {
+      xmlStream.addAttribute('outlineLevel', model.outlineLevel);
+    }
+    if (model.collapsed) {
+      xmlStream.addAttribute('collapsed', '1');
+    }
+    xmlStream.addAttribute('customWidth', '1');
+    xmlStream.closeNode();
+  }
+
+  parseOpen(node) {
+    if (node.name === 'col') {
+      const model = (this.model = {
+        min: parseInt(node.attributes.min || '0', 10),
+        max: parseInt(node.attributes.max || '0', 10),
+        width:
+          node.attributes.width === undefined
+            ? undefined
+            : parseFloat(node.attributes.width || '0'),
+      });
+      if (node.attributes.style) {
+        model.styleId = parseInt(node.attributes.style, 10);
+      }
+      if (utils.parseBoolean(node.attributes.hidden)) {
+        model.hidden = true;
+      }
+      if (utils.parseBoolean(node.attributes.bestFit)) {
+        model.bestFit = true;
+      }
+      if (node.attributes.outlineLevel) {
+        model.outlineLevel = parseInt(node.attributes.outlineLevel, 10);
+      }
+      if (utils.parseBoolean(node.attributes.collapsed)) {
+        model.collapsed = true;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  parseText() {}
+
+  parseClose() {
+    return false;
+  }
+
+  reconcile(model, options) {
+    // reconcile column styles
+    if (model.styleId) {
+      model.style = options.styles.getStyleModel(model.styleId);
+    }
+  }
+}
+
+var colXform = ColXform;
+
+export { colXform as c };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/data-validations-xform.js

@@ -0,0 +1,263 @@
+import { u as underDash } from '../../../utils/under-dash.js';
+import { u as utils_1 } from '../../../utils/utils.js';
+import { c as colCache_1 } from '../../../utils/col-cache.js';
+import { b as baseXform } from '../base-xform.js';
+import { r as range } from '../../../doc/range.js';
+
+const _ = underDash;
+const utils = utils_1;
+const colCache = colCache_1;
+const BaseXform = baseXform;
+const Range = range;
+
+function assign(definedName, attributes, name, defaultValue) {
+  const value = attributes[name];
+  if (value !== undefined) {
+    definedName[name] = value;
+  } else if (defaultValue !== undefined) {
+    definedName[name] = defaultValue;
+  }
+}
+
+function assignBool(definedName, attributes, name, defaultValue) {
+  const value = attributes[name];
+  if (value !== undefined) {
+    definedName[name] = utils.parseBoolean(value);
+  } else if (defaultValue !== undefined) {
+    definedName[name] = defaultValue;
+  }
+}
+
+function optimiseDataValidations(model) {
+  // Squeeze alike data validations together into rectangular ranges
+  // to reduce file size and speed up Excel load time
+  const dvList = _.map(model, (dataValidation, address) => ({
+    address,
+    dataValidation,
+    marked: false,
+  })).sort((a, b) => _.strcmp(a.address, b.address));
+  const dvMap = _.keyBy(dvList, 'address');
+  const matchCol = (addr, height, col) => {
+    for (let i = 0; i < height; i++) {
+      const otherAddress = colCache.encodeAddress(addr.row + i, col);
+      if (!model[otherAddress] || !_.isEqual(model[addr.address], model[otherAddress])) {
+        return false;
+      }
+    }
+    return true;
+  };
+  return dvList
+    .map(dv => {
+      if (!dv.marked) {
+        const addr = colCache.decodeEx(dv.address);
+        if (addr.dimensions) {
+          dvMap[addr.dimensions].marked = true;
+          return {
+            ...dv.dataValidation,
+            sqref: dv.address,
+          };
+        }
+
+        // iterate downwards - finding matching cells
+        let height = 1;
+        let otherAddress = colCache.encodeAddress(addr.row + height, addr.col);
+        while (model[otherAddress] && _.isEqual(dv.dataValidation, model[otherAddress])) {
+          height++;
+          otherAddress = colCache.encodeAddress(addr.row + height, addr.col);
+        }
+
+        // iterate rightwards...
+
+        let width = 1;
+        while (matchCol(addr, height, addr.col + width)) {
+          width++;
+        }
+
+        // mark all included addresses
+        for (let i = 0; i < height; i++) {
+          for (let j = 0; j < width; j++) {
+            otherAddress = colCache.encodeAddress(addr.row + i, addr.col + j);
+            dvMap[otherAddress].marked = true;
+          }
+        }
+
+        if (height > 1 || width > 1) {
+          const bottom = addr.row + (height - 1);
+          const right = addr.col + (width - 1);
+          return {
+            ...dv.dataValidation,
+            sqref: `${dv.address}:${colCache.encodeAddress(bottom, right)}`,
+          };
+        }
+        return {
+          ...dv.dataValidation,
+          sqref: dv.address,
+        };
+      }
+      return null;
+    })
+    .filter(Boolean);
+}
+
+class DataValidationsXform extends BaseXform {
+  get tag() {
+    return 'dataValidations';
+  }
+
+  render(xmlStream, model) {
+    const optimizedModel = optimiseDataValidations(model);
+    if (optimizedModel.length) {
+      xmlStream.openNode('dataValidations', {count: optimizedModel.length});
+
+      optimizedModel.forEach(value => {
+        xmlStream.openNode('dataValidation');
+
+        if (value.type !== 'any') {
+          xmlStream.addAttribute('type', value.type);
+
+          if (value.operator && value.type !== 'list' && value.operator !== 'between') {
+            xmlStream.addAttribute('operator', value.operator);
+          }
+          if (value.allowBlank) {
+            xmlStream.addAttribute('allowBlank', '1');
+          }
+        }
+        if (value.showInputMessage) {
+          xmlStream.addAttribute('showInputMessage', '1');
+        }
+        if (value.promptTitle) {
+          xmlStream.addAttribute('promptTitle', value.promptTitle);
+        }
+        if (value.prompt) {
+          xmlStream.addAttribute('prompt', value.prompt);
+        }
+        if (value.showErrorMessage) {
+          xmlStream.addAttribute('showErrorMessage', '1');
+        }
+        if (value.errorStyle) {
+          xmlStream.addAttribute('errorStyle', value.errorStyle);
+        }
+        if (value.errorTitle) {
+          xmlStream.addAttribute('errorTitle', value.errorTitle);
+        }
+        if (value.error) {
+          xmlStream.addAttribute('error', value.error);
+        }
+        xmlStream.addAttribute('sqref', value.sqref);
+        (value.formulae || []).forEach((formula, index) => {
+          xmlStream.openNode(`formula${index + 1}`);
+          if (value.type === 'date') {
+            xmlStream.writeText(utils.dateToExcel(new Date(formula)));
+          } else {
+            xmlStream.writeText(formula);
+          }
+          xmlStream.closeNode();
+        });
+        xmlStream.closeNode();
+      });
+      xmlStream.closeNode();
+    }
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case 'dataValidations':
+        this.model = {};
+        return true;
+
+      case 'dataValidation': {
+        this._address = node.attributes.sqref;
+        const dataValidation = {type: node.attributes.type || 'any', formulae: []};
+
+        if (node.attributes.type) {
+          assignBool(dataValidation, node.attributes, 'allowBlank');
+        }
+        assignBool(dataValidation, node.attributes, 'showInputMessage');
+        assignBool(dataValidation, node.attributes, 'showErrorMessage');
+
+        switch (dataValidation.type) {
+          case 'any':
+          case 'list':
+          case 'custom':
+            break;
+          default:
+            assign(dataValidation, node.attributes, 'operator', 'between');
+            break;
+        }
+        assign(dataValidation, node.attributes, 'promptTitle');
+        assign(dataValidation, node.attributes, 'prompt');
+        assign(dataValidation, node.attributes, 'errorStyle');
+        assign(dataValidation, node.attributes, 'errorTitle');
+        assign(dataValidation, node.attributes, 'error');
+
+        this._dataValidation = dataValidation;
+        return true;
+      }
+
+      case 'formula1':
+      case 'formula2':
+        this._formula = [];
+        return true;
+
+      default:
+        return false;
+    }
+  }
+
+  parseText(text) {
+    if (this._formula) {
+      this._formula.push(text);
+    }
+  }
+
+  parseClose(name) {
+    switch (name) {
+      case 'dataValidations':
+        return false;
+      case 'dataValidation': {
+        if (!this._dataValidation.formulae || !this._dataValidation.formulae.length) {
+          delete this._dataValidation.formulae;
+          delete this._dataValidation.operator;
+        }
+        // The four known cases: 1. E4:L9 N4:U9  2.E4 L9  3. N4:U9  4. E4
+        const list = this._address.split(/\s+/g) || [];
+        list.forEach(addr => {
+          if (addr.includes(':')) {
+            const range = new Range(addr);
+            range.forEachAddress(address => {
+              this.model[address] = this._dataValidation;
+            });
+          } else {
+            this.model[addr] = this._dataValidation;
+          }
+        });
+        return true;
+      }
+      case 'formula1':
+      case 'formula2': {
+        let formula = this._formula.join('');
+        switch (this._dataValidation.type) {
+          case 'whole':
+          case 'textLength':
+            formula = parseInt(formula, 10);
+            break;
+          case 'decimal':
+            formula = parseFloat(formula);
+            break;
+          case 'date':
+            formula = utils.excelToDate(parseFloat(formula));
+            break;
+        }
+        this._dataValidation.formulae.push(formula);
+        this._formula = undefined;
+        return true;
+      }
+      default:
+        return true;
+    }
+  }
+}
+
+var dataValidationsXform = DataValidationsXform;
+
+export { dataValidationsXform as d };

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

@@ -0,0 +1,33 @@
+import { b as baseXform } from '../base-xform.js';
+
+const BaseXform = baseXform;
+
+class DimensionXform extends BaseXform {
+  get tag() {
+    return 'dimension';
+  }
+
+  render(xmlStream, model) {
+    if (model) {
+      xmlStream.leafNode('dimension', {ref: model});
+    }
+  }
+
+  parseOpen(node) {
+    if (node.name === 'dimension') {
+      this.model = node.attributes.ref;
+      return true;
+    }
+    return false;
+  }
+
+  parseText() {}
+
+  parseClose() {
+    return false;
+  }
+}
+
+var dimensionXform = DimensionXform;
+
+export { dimensionXform as d };

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

@@ -0,0 +1,37 @@
+import { b as baseXform } from '../base-xform.js';
+
+const BaseXform = baseXform;
+
+class DrawingXform extends BaseXform {
+  get tag() {
+    return 'drawing';
+  }
+
+  render(xmlStream, model) {
+    if (model) {
+      xmlStream.leafNode(this.tag, {'r:id': model.rId});
+    }
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case this.tag:
+        this.model = {
+          rId: node.attributes['r:id'],
+        };
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  parseText() {}
+
+  parseClose() {
+    return false;
+  }
+}
+
+var drawingXform = DrawingXform;
+
+export { drawingXform as d };

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

@@ -0,0 +1,92 @@
+import { c as compositeXform } from '../composite-xform.js';
+import { c as conditionalFormattingsExtXform } from './cf-ext/conditional-formattings-ext-xform.js';
+
+/* eslint-disable max-classes-per-file */
+
+const CompositeXform = compositeXform;
+
+const ConditionalFormattingsExt = conditionalFormattingsExtXform;
+
+class ExtXform extends CompositeXform {
+  constructor() {
+    super();
+    this.map = {
+      'x14:conditionalFormattings': (this.conditionalFormattings = new ConditionalFormattingsExt()),
+    };
+  }
+
+  get tag() {
+    return 'ext';
+  }
+
+  hasContent(model) {
+    return this.conditionalFormattings.hasContent(model.conditionalFormattings);
+  }
+
+  prepare(model, options) {
+    this.conditionalFormattings.prepare(model.conditionalFormattings, options);
+  }
+
+  render(xmlStream, model) {
+    xmlStream.openNode('ext', {
+      uri: '{78C0D931-6437-407d-A8EE-F0AAD7539E65}',
+      'xmlns:x14': 'http://schemas.microsoft.com/office/spreadsheetml/2009/9/main',
+    });
+
+    this.conditionalFormattings.render(xmlStream, model.conditionalFormattings);
+
+    xmlStream.closeNode();
+  }
+
+  createNewModel() {
+    return {};
+  }
+
+  onParserClose(name, parser) {
+    this.model[name] = parser.model;
+  }
+}
+
+class ExtLstXform extends CompositeXform {
+  constructor() {
+    super();
+
+    this.map = {
+      ext: (this.ext = new ExtXform()),
+    };
+  }
+
+  get tag() {
+    return 'extLst';
+  }
+
+  prepare(model, options) {
+    this.ext.prepare(model, options);
+  }
+
+  hasContent(model) {
+    return this.ext.hasContent(model);
+  }
+
+  render(xmlStream, model) {
+    if (!this.hasContent(model)) {
+      return;
+    }
+
+    xmlStream.openNode('extLst');
+    this.ext.render(xmlStream, model);
+    xmlStream.closeNode();
+  }
+
+  createNewModel() {
+    return {};
+  }
+
+  onParserClose(name, parser) {
+    Object.assign(this.model, parser.model);
+  }
+}
+
+var extLstXform = ExtLstXform;
+
+export { extLstXform as e };

package/dist/es/node_modules/exceljs/lib/xlsx/xform/sheet/header-footer-xform.js

@@ -0,0 +1,147 @@
+import { b as baseXform } from '../base-xform.js';
+
+const BaseXform = baseXform;
+
+class HeaderFooterXform extends BaseXform {
+  get tag() {
+    return 'headerFooter';
+  }
+
+  render(xmlStream, model) {
+    if (model) {
+      xmlStream.addRollback();
+
+      let createTag = false;
+
+      xmlStream.openNode('headerFooter');
+      if (model.differentFirst) {
+        xmlStream.addAttribute('differentFirst', '1');
+        createTag = true;
+      }
+      if (model.differentOddEven) {
+        xmlStream.addAttribute('differentOddEven', '1');
+        createTag = true;
+      }
+      if (model.oddHeader && typeof model.oddHeader === 'string') {
+        xmlStream.leafNode('oddHeader', null, model.oddHeader);
+        createTag = true;
+      }
+      if (model.oddFooter && typeof model.oddFooter === 'string') {
+        xmlStream.leafNode('oddFooter', null, model.oddFooter);
+        createTag = true;
+      }
+      if (model.evenHeader && typeof model.evenHeader === 'string') {
+        xmlStream.leafNode('evenHeader', null, model.evenHeader);
+        createTag = true;
+      }
+      if (model.evenFooter && typeof model.evenFooter === 'string') {
+        xmlStream.leafNode('evenFooter', null, model.evenFooter);
+        createTag = true;
+      }
+      if (model.firstHeader && typeof model.firstHeader === 'string') {
+        xmlStream.leafNode('firstHeader', null, model.firstHeader);
+        createTag = true;
+      }
+      if (model.firstFooter && typeof model.firstFooter === 'string') {
+        xmlStream.leafNode('firstFooter', null, model.firstFooter);
+        createTag = true;
+      }
+
+      if (createTag) {
+        xmlStream.closeNode();
+        xmlStream.commit();
+      } else {
+        xmlStream.rollback();
+      }
+    }
+  }
+
+  parseOpen(node) {
+    switch (node.name) {
+      case 'headerFooter':
+        this.model = {};
+        if (node.attributes.differentFirst) {
+          this.model.differentFirst = parseInt(node.attributes.differentFirst, 0) === 1;
+        }
+        if (node.attributes.differentOddEven) {
+          this.model.differentOddEven = parseInt(node.attributes.differentOddEven, 0) === 1;
+        }
+        return true;
+
+      case 'oddHeader':
+        this.currentNode = 'oddHeader';
+        return true;
+
+      case 'oddFooter':
+        this.currentNode = 'oddFooter';
+        return true;
+
+      case 'evenHeader':
+        this.currentNode = 'evenHeader';
+        return true;
+
+      case 'evenFooter':
+        this.currentNode = 'evenFooter';
+        return true;
+
+      case 'firstHeader':
+        this.currentNode = 'firstHeader';
+        return true;
+
+      case 'firstFooter':
+        this.currentNode = 'firstFooter';
+        return true;
+
+      default:
+        return false;
+    }
+  }
+
+  parseText(text) {
+    switch (this.currentNode) {
+      case 'oddHeader':
+        this.model.oddHeader = text;
+        break;
+
+      case 'oddFooter':
+        this.model.oddFooter = text;
+        break;
+
+      case 'evenHeader':
+        this.model.evenHeader = text;
+        break;
+
+      case 'evenFooter':
+        this.model.evenFooter = text;
+        break;
+
+      case 'firstHeader':
+        this.model.firstHeader = text;
+        break;
+
+      case 'firstFooter':
+        this.model.firstFooter = text;
+        break;
+    }
+  }
+
+  parseClose() {
+    switch (this.currentNode) {
+      case 'oddHeader':
+      case 'oddFooter':
+      case 'evenHeader':
+      case 'evenFooter':
+      case 'firstHeader':
+      case 'firstFooter':
+        this.currentNode = undefined;
+        return true;
+
+      default:
+        return false;
+    }
+  }
+}
+
+var headerFooterXform = HeaderFooterXform;
+
+export { headerFooterXform as h };