zmdms-webui 1.9.5 → 1.9.7

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

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

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

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

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

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

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