office-viewer 0.3.13 → 0.3.15

package/esm/node_modules/echarts/lib/util/clazz.js

@@ -1,265 +0,0 @@
-import { __extends } from 'tslib';
-import { each, inherits, extend, isFunction, assert } from '../../../zrender/lib/core/util.js';
-
-var TYPE_DELIMITER = '.';
-var IS_CONTAINER = '___EC__COMPONENT__CONTAINER___';
-var IS_EXTENDED_CLASS = '___EC__EXTENDED_CLASS___';
-/**
- * Notice, parseClassType('') should returns {main: '', sub: ''}
- * @public
- */
-function parseClassType(componentType) {
-  var ret = {
-    main: '',
-    sub: ''
-  };
-  if (componentType) {
-    var typeArr = componentType.split(TYPE_DELIMITER);
-    ret.main = typeArr[0] || '';
-    ret.sub = typeArr[1] || '';
-  }
-  return ret;
-}
-/**
- * @public
- */
-function checkClassType(componentType) {
-  assert(/^[a-zA-Z0-9_]+([.][a-zA-Z0-9_]+)?$/.test(componentType), 'componentType "' + componentType + '" illegal');
-}
-function isExtendedClass(clz) {
-  return !!(clz && clz[IS_EXTENDED_CLASS]);
-}
-/**
- * Implements `ExtendableConstructor` for `rootClz`.
- *
- * @usage
- * ```ts
- * class Xxx {}
- * type XxxConstructor = typeof Xxx & ExtendableConstructor
- * enableClassExtend(Xxx as XxxConstructor);
- * ```
- */
-function enableClassExtend(rootClz, mandatoryMethods) {
-  rootClz.$constructor = rootClz; // FIXME: not necessary?
-  rootClz.extend = function (proto) {
-    if (process.env.NODE_ENV !== 'production') {
-      each(mandatoryMethods, function (method) {
-        if (!proto[method]) {
-          console.warn('Method `' + method + '` should be implemented' + (proto.type ? ' in ' + proto.type : '') + '.');
-        }
-      });
-    }
-    var superClass = this;
-    var ExtendedClass;
-    if (isESClass(superClass)) {
-      ExtendedClass = /** @class */function (_super) {
-        __extends(class_1, _super);
-        function class_1() {
-          return _super.apply(this, arguments) || this;
-        }
-        return class_1;
-      }(superClass);
-    } else {
-      // For backward compat, we both support ts class inheritance and this
-      // "extend" approach.
-      // The constructor should keep the same behavior as ts class inheritance:
-      // If this constructor/$constructor is not declared, auto invoke the super
-      // constructor.
-      // If this constructor/$constructor is declared, it is responsible for
-      // calling the super constructor.
-      ExtendedClass = function () {
-        (proto.$constructor || superClass).apply(this, arguments);
-      };
-      inherits(ExtendedClass, this);
-    }
-    extend(ExtendedClass.prototype, proto);
-    ExtendedClass[IS_EXTENDED_CLASS] = true;
-    ExtendedClass.extend = this.extend;
-    ExtendedClass.superCall = superCall;
-    ExtendedClass.superApply = superApply;
-    ExtendedClass.superClass = superClass;
-    return ExtendedClass;
-  };
-}
-function isESClass(fn) {
-  return isFunction(fn) && /^class\s/.test(Function.prototype.toString.call(fn));
-}
-/**
- * A work around to both support ts extend and this extend mechanism.
- * on sub-class.
- * @usage
- * ```ts
- * class Component { ... }
- * classUtil.enableClassExtend(Component);
- * classUtil.enableClassManagement(Component, {registerWhenExtend: true});
- *
- * class Series extends Component { ... }
- * // Without calling `markExtend`, `registerWhenExtend` will not work.
- * Component.markExtend(Series);
- * ```
- */
-function mountExtend(SubClz, SupperClz) {
-  SubClz.extend = SupperClz.extend;
-}
-// A random offset.
-var classBase = Math.round(Math.random() * 10);
-/**
- * Implements `CheckableConstructor` for `target`.
- * Can not use instanceof, consider different scope by
- * cross domain or es module import in ec extensions.
- * Mount a method "isInstance()" to Clz.
- *
- * @usage
- * ```ts
- * class Xxx {}
- * type XxxConstructor = typeof Xxx & CheckableConstructor;
- * enableClassCheck(Xxx as XxxConstructor)
- * ```
- */
-function enableClassCheck(target) {
-  var classAttr = ['__\0is_clz', classBase++].join('_');
-  target.prototype[classAttr] = true;
-  if (process.env.NODE_ENV !== 'production') {
-    assert(!target.isInstance, 'The method "is" can not be defined.');
-  }
-  target.isInstance = function (obj) {
-    return !!(obj && obj[classAttr]);
-  };
-}
-// superCall should have class info, which can not be fetched from 'this'.
-// Consider this case:
-// class A has method f,
-// class B inherits class A, overrides method f, f call superApply('f'),
-// class C inherits class B, does not override method f,
-// then when method of class C is called, dead loop occurred.
-function superCall(context, methodName) {
-  var args = [];
-  for (var _i = 2; _i < arguments.length; _i++) {
-    args[_i - 2] = arguments[_i];
-  }
-  return this.superClass.prototype[methodName].apply(context, args);
-}
-function superApply(context, methodName, args) {
-  return this.superClass.prototype[methodName].apply(context, args);
-}
-/**
- * Implements `ClassManager` for `target`
- *
- * @usage
- * ```ts
- * class Xxx {}
- * type XxxConstructor = typeof Xxx & ClassManager
- * enableClassManagement(Xxx as XxxConstructor);
- * ```
- */
-function enableClassManagement(target) {
-  /**
-   * Component model classes
-   * key: componentType,
-   * value:
-   *     componentClass, when componentType is 'a'
-   *     or Object.<subKey, componentClass>, when componentType is 'a.b'
-   */
-  var storage = {};
-  target.registerClass = function (clz) {
-    // `type` should not be a "instance member".
-    // If using TS class, should better declared as `static type = 'series.pie'`.
-    // otherwise users have to mount `type` on prototype manually.
-    // For backward compat and enable instance visit type via `this.type`,
-    // we still support fetch `type` from prototype.
-    var componentFullType = clz.type || clz.prototype.type;
-    if (componentFullType) {
-      checkClassType(componentFullType);
-      // If only static type declared, we assign it to prototype mandatorily.
-      clz.prototype.type = componentFullType;
-      var componentTypeInfo = parseClassType(componentFullType);
-      if (!componentTypeInfo.sub) {
-        if (process.env.NODE_ENV !== 'production') {
-          if (storage[componentTypeInfo.main]) {
-            console.warn(componentTypeInfo.main + ' exists.');
-          }
-        }
-        storage[componentTypeInfo.main] = clz;
-      } else if (componentTypeInfo.sub !== IS_CONTAINER) {
-        var container = makeContainer(componentTypeInfo);
-        container[componentTypeInfo.sub] = clz;
-      }
-    }
-    return clz;
-  };
-  target.getClass = function (mainType, subType, throwWhenNotFound) {
-    var clz = storage[mainType];
-    if (clz && clz[IS_CONTAINER]) {
-      clz = subType ? clz[subType] : null;
-    }
-    if (throwWhenNotFound && !clz) {
-      throw new Error(!subType ? mainType + '.' + 'type should be specified.' : 'Component ' + mainType + '.' + (subType || '') + ' is used but not imported.');
-    }
-    return clz;
-  };
-  target.getClassesByMainType = function (componentType) {
-    var componentTypeInfo = parseClassType(componentType);
-    var result = [];
-    var obj = storage[componentTypeInfo.main];
-    if (obj && obj[IS_CONTAINER]) {
-      each(obj, function (o, type) {
-        type !== IS_CONTAINER && result.push(o);
-      });
-    } else {
-      result.push(obj);
-    }
-    return result;
-  };
-  target.hasClass = function (componentType) {
-    // Just consider componentType.main.
-    var componentTypeInfo = parseClassType(componentType);
-    return !!storage[componentTypeInfo.main];
-  };
-  /**
-   * @return Like ['aa', 'bb'], but can not be ['aa.xx']
-   */
-  target.getAllClassMainTypes = function () {
-    var types = [];
-    each(storage, function (obj, type) {
-      types.push(type);
-    });
-    return types;
-  };
-  /**
-   * If a main type is container and has sub types
-   */
-  target.hasSubTypes = function (componentType) {
-    var componentTypeInfo = parseClassType(componentType);
-    var obj = storage[componentTypeInfo.main];
-    return obj && obj[IS_CONTAINER];
-  };
-  function makeContainer(componentTypeInfo) {
-    var container = storage[componentTypeInfo.main];
-    if (!container || !container[IS_CONTAINER]) {
-      container = storage[componentTypeInfo.main] = {};
-      container[IS_CONTAINER] = true;
-    }
-    return container;
-  }
-}
-// /**
-//  * @param {string|Array.<string>} properties
-//  */
-// export function setReadOnly(obj, properties) {
-// FIXME It seems broken in IE8 simulation of IE11
-// if (!zrUtil.isArray(properties)) {
-//     properties = properties != null ? [properties] : [];
-// }
-// zrUtil.each(properties, function (prop) {
-//     let value = obj[prop];
-//     Object.defineProperty
-//         && Object.defineProperty(obj, prop, {
-//             value: value, writable: false
-//         });
-//     zrUtil.isArray(obj[prop])
-//         && Object.freeze
-//         && Object.freeze(obj[prop]);
-// });
-// }
-
-export { enableClassCheck, enableClassExtend, enableClassManagement, isExtendedClass, mountExtend, parseClassType };

package/esm/node_modules/echarts/lib/util/component.js

@@ -1,146 +0,0 @@
-import { each, indexOf, merge } from '../../../zrender/lib/core/util.js';
-import { parseClassType } from './clazz.js';
-import { makePrintable } from './log.js';
-
-// A random offset
-var base = Math.round(Math.random() * 10);
-/**
- * @public
- * @param {string} type
- * @return {string}
- */
-function getUID(type) {
-  // Considering the case of crossing js context,
-  // use Math.random to make id as unique as possible.
-  return [type || '', base++].join('_');
-}
-/**
- * Implements `SubTypeDefaulterManager` for `target`.
- */
-function enableSubTypeDefaulter(target) {
-  var subTypeDefaulters = {};
-  target.registerSubTypeDefaulter = function (componentType, defaulter) {
-    var componentTypeInfo = parseClassType(componentType);
-    subTypeDefaulters[componentTypeInfo.main] = defaulter;
-  };
-  target.determineSubType = function (componentType, option) {
-    var type = option.type;
-    if (!type) {
-      var componentTypeMain = parseClassType(componentType).main;
-      if (target.hasSubTypes(componentType) && subTypeDefaulters[componentTypeMain]) {
-        type = subTypeDefaulters[componentTypeMain](option);
-      }
-    }
-    return type;
-  };
-}
-/**
- * Implements `TopologicalTravelable<any>` for `entity`.
- *
- * Topological travel on Activity Network (Activity On Vertices).
- * Dependencies is defined in Model.prototype.dependencies, like ['xAxis', 'yAxis'].
- * If 'xAxis' or 'yAxis' is absent in componentTypeList, just ignore it in topology.
- * If there is circular dependencey, Error will be thrown.
- */
-function enableTopologicalTravel(entity, dependencyGetter) {
-  /**
-   * @param targetNameList Target Component type list.
-   *                       Can be ['aa', 'bb', 'aa.xx']
-   * @param fullNameList By which we can build dependency graph.
-   * @param callback Params: componentType, dependencies.
-   * @param context Scope of callback.
-   */
-  entity.topologicalTravel = function (targetNameList, fullNameList, callback, context) {
-    if (!targetNameList.length) {
-      return;
-    }
-    var result = makeDepndencyGraph(fullNameList);
-    var graph = result.graph;
-    var noEntryList = result.noEntryList;
-    var targetNameSet = {};
-    each(targetNameList, function (name) {
-      targetNameSet[name] = true;
-    });
-    while (noEntryList.length) {
-      var currComponentType = noEntryList.pop();
-      var currVertex = graph[currComponentType];
-      var isInTargetNameSet = !!targetNameSet[currComponentType];
-      if (isInTargetNameSet) {
-        callback.call(context, currComponentType, currVertex.originalDeps.slice());
-        delete targetNameSet[currComponentType];
-      }
-      each(currVertex.successor, isInTargetNameSet ? removeEdgeAndAdd : removeEdge);
-    }
-    each(targetNameSet, function () {
-      var errMsg = '';
-      if (process.env.NODE_ENV !== 'production') {
-        errMsg = makePrintable('Circular dependency may exists: ', targetNameSet, targetNameList, fullNameList);
-      }
-      throw new Error(errMsg);
-    });
-    function removeEdge(succComponentType) {
-      graph[succComponentType].entryCount--;
-      if (graph[succComponentType].entryCount === 0) {
-        noEntryList.push(succComponentType);
-      }
-    }
-    // Consider this case: legend depends on series, and we call
-    // chart.setOption({series: [...]}), where only series is in option.
-    // If we do not have 'removeEdgeAndAdd', legendModel.mergeOption will
-    // not be called, but only sereis.mergeOption is called. Thus legend
-    // have no chance to update its local record about series (like which
-    // name of series is available in legend).
-    function removeEdgeAndAdd(succComponentType) {
-      targetNameSet[succComponentType] = true;
-      removeEdge(succComponentType);
-    }
-  };
-  function makeDepndencyGraph(fullNameList) {
-    var graph = {};
-    var noEntryList = [];
-    each(fullNameList, function (name) {
-      var thisItem = createDependencyGraphItem(graph, name);
-      var originalDeps = thisItem.originalDeps = dependencyGetter(name);
-      var availableDeps = getAvailableDependencies(originalDeps, fullNameList);
-      thisItem.entryCount = availableDeps.length;
-      if (thisItem.entryCount === 0) {
-        noEntryList.push(name);
-      }
-      each(availableDeps, function (dependentName) {
-        if (indexOf(thisItem.predecessor, dependentName) < 0) {
-          thisItem.predecessor.push(dependentName);
-        }
-        var thatItem = createDependencyGraphItem(graph, dependentName);
-        if (indexOf(thatItem.successor, dependentName) < 0) {
-          thatItem.successor.push(name);
-        }
-      });
-    });
-    return {
-      graph: graph,
-      noEntryList: noEntryList
-    };
-  }
-  function createDependencyGraphItem(graph, name) {
-    if (!graph[name]) {
-      graph[name] = {
-        predecessor: [],
-        successor: []
-      };
-    }
-    return graph[name];
-  }
-  function getAvailableDependencies(originalDeps, fullNameList) {
-    var availableDeps = [];
-    each(originalDeps, function (dep) {
-      indexOf(fullNameList, dep) >= 0 && availableDeps.push(dep);
-    });
-    return availableDeps;
-  }
-}
-function inheritDefaultOption(superOption, subOption) {
-  // See also `model/Component.ts#getDefaultOption`
-  return merge(merge({}, superOption, true), subOption, true);
-}
-
-export { enableSubTypeDefaulter, enableTopologicalTravel, getUID, inheritDefaultOption };

package/esm/node_modules/echarts/lib/util/conditionalExpression.js

@@ -1,215 +0,0 @@
-import { isArray, map, keys, hasOwn, isObject, isArrayLike, isString, isRegExp, isNumber } from '../../../zrender/lib/core/util.js';
-import { makePrintable, throwError } from './log.js';
-import { getRawValueParser, createFilterComparator } from '../data/helper/dataValueHelper.js';
-
-var RELATIONAL_EXPRESSION_OP_ALIAS_MAP = {
-  value: 'eq',
-  // PENDING: not good for literal semantic?
-  '<': 'lt',
-  '<=': 'lte',
-  '>': 'gt',
-  '>=': 'gte',
-  '=': 'eq',
-  '!=': 'ne',
-  '<>': 'ne'
-  // Might be misleading for sake of the difference between '==' and '===',
-  // so don't support them.
-  // '==': 'eq',
-  // '===': 'seq',
-  // '!==': 'sne'
-  // PENDING: Whether support some common alias "ge", "le", "neq"?
-  // ge: 'gte',
-  // le: 'lte',
-  // neq: 'ne',
-};
-// type RelationalExpressionOpEvaluate = (tarVal: unknown, condVal: unknown) => boolean;
-var RegExpEvaluator = /** @class */function () {
-  function RegExpEvaluator(rVal) {
-    // Support condVal: RegExp | string
-    var condValue = this._condVal = isString(rVal) ? new RegExp(rVal) : isRegExp(rVal) ? rVal : null;
-    if (condValue == null) {
-      var errMsg = '';
-      if (process.env.NODE_ENV !== 'production') {
-        errMsg = makePrintable('Illegal regexp', rVal, 'in');
-      }
-      throwError(errMsg);
-    }
-  }
-  RegExpEvaluator.prototype.evaluate = function (lVal) {
-    var type = typeof lVal;
-    return isString(type) ? this._condVal.test(lVal) : isNumber(type) ? this._condVal.test(lVal + '') : false;
-  };
-  return RegExpEvaluator;
-}();
-var ConstConditionInternal = /** @class */function () {
-  function ConstConditionInternal() {}
-  ConstConditionInternal.prototype.evaluate = function () {
-    return this.value;
-  };
-  return ConstConditionInternal;
-}();
-var AndConditionInternal = /** @class */function () {
-  function AndConditionInternal() {}
-  AndConditionInternal.prototype.evaluate = function () {
-    var children = this.children;
-    for (var i = 0; i < children.length; i++) {
-      if (!children[i].evaluate()) {
-        return false;
-      }
-    }
-    return true;
-  };
-  return AndConditionInternal;
-}();
-var OrConditionInternal = /** @class */function () {
-  function OrConditionInternal() {}
-  OrConditionInternal.prototype.evaluate = function () {
-    var children = this.children;
-    for (var i = 0; i < children.length; i++) {
-      if (children[i].evaluate()) {
-        return true;
-      }
-    }
-    return false;
-  };
-  return OrConditionInternal;
-}();
-var NotConditionInternal = /** @class */function () {
-  function NotConditionInternal() {}
-  NotConditionInternal.prototype.evaluate = function () {
-    return !this.child.evaluate();
-  };
-  return NotConditionInternal;
-}();
-var RelationalConditionInternal = /** @class */function () {
-  function RelationalConditionInternal() {}
-  RelationalConditionInternal.prototype.evaluate = function () {
-    var needParse = !!this.valueParser;
-    // Call getValue with no `this`.
-    var getValue = this.getValue;
-    var tarValRaw = getValue(this.valueGetterParam);
-    var tarValParsed = needParse ? this.valueParser(tarValRaw) : null;
-    // Relational cond follow "and" logic internally.
-    for (var i = 0; i < this.subCondList.length; i++) {
-      if (!this.subCondList[i].evaluate(needParse ? tarValParsed : tarValRaw)) {
-        return false;
-      }
-    }
-    return true;
-  };
-  return RelationalConditionInternal;
-}();
-function parseOption(exprOption, getters) {
-  if (exprOption === true || exprOption === false) {
-    var cond = new ConstConditionInternal();
-    cond.value = exprOption;
-    return cond;
-  }
-  var errMsg = '';
-  if (!isObjectNotArray(exprOption)) {
-    if (process.env.NODE_ENV !== 'production') {
-      errMsg = makePrintable('Illegal config. Expect a plain object but actually', exprOption);
-    }
-    throwError(errMsg);
-  }
-  if (exprOption.and) {
-    return parseAndOrOption('and', exprOption, getters);
-  } else if (exprOption.or) {
-    return parseAndOrOption('or', exprOption, getters);
-  } else if (exprOption.not) {
-    return parseNotOption(exprOption, getters);
-  }
-  return parseRelationalOption(exprOption, getters);
-}
-function parseAndOrOption(op, exprOption, getters) {
-  var subOptionArr = exprOption[op];
-  var errMsg = '';
-  if (process.env.NODE_ENV !== 'production') {
-    errMsg = makePrintable('"and"/"or" condition should only be `' + op + ': [...]` and must not be empty array.', 'Illegal condition:', exprOption);
-  }
-  if (!isArray(subOptionArr)) {
-    throwError(errMsg);
-  }
-  if (!subOptionArr.length) {
-    throwError(errMsg);
-  }
-  var cond = op === 'and' ? new AndConditionInternal() : new OrConditionInternal();
-  cond.children = map(subOptionArr, function (subOption) {
-    return parseOption(subOption, getters);
-  });
-  if (!cond.children.length) {
-    throwError(errMsg);
-  }
-  return cond;
-}
-function parseNotOption(exprOption, getters) {
-  var subOption = exprOption.not;
-  var errMsg = '';
-  if (process.env.NODE_ENV !== 'production') {
-    errMsg = makePrintable('"not" condition should only be `not: {}`.', 'Illegal condition:', exprOption);
-  }
-  if (!isObjectNotArray(subOption)) {
-    throwError(errMsg);
-  }
-  var cond = new NotConditionInternal();
-  cond.child = parseOption(subOption, getters);
-  if (!cond.child) {
-    throwError(errMsg);
-  }
-  return cond;
-}
-function parseRelationalOption(exprOption, getters) {
-  var errMsg = '';
-  var valueGetterParam = getters.prepareGetValue(exprOption);
-  var subCondList = [];
-  var exprKeys = keys(exprOption);
-  var parserName = exprOption.parser;
-  var valueParser = parserName ? getRawValueParser(parserName) : null;
-  for (var i = 0; i < exprKeys.length; i++) {
-    var keyRaw = exprKeys[i];
-    if (keyRaw === 'parser' || getters.valueGetterAttrMap.get(keyRaw)) {
-      continue;
-    }
-    var op = hasOwn(RELATIONAL_EXPRESSION_OP_ALIAS_MAP, keyRaw) ? RELATIONAL_EXPRESSION_OP_ALIAS_MAP[keyRaw] : keyRaw;
-    var condValueRaw = exprOption[keyRaw];
-    var condValueParsed = valueParser ? valueParser(condValueRaw) : condValueRaw;
-    var evaluator = createFilterComparator(op, condValueParsed) || op === 'reg' && new RegExpEvaluator(condValueParsed);
-    if (!evaluator) {
-      if (process.env.NODE_ENV !== 'production') {
-        errMsg = makePrintable('Illegal relational operation: "' + keyRaw + '" in condition:', exprOption);
-      }
-      throwError(errMsg);
-    }
-    subCondList.push(evaluator);
-  }
-  if (!subCondList.length) {
-    if (process.env.NODE_ENV !== 'production') {
-      errMsg = makePrintable('Relational condition must have at least one operator.', 'Illegal condition:', exprOption);
-    }
-    // No relational operator always disabled in case of dangers result.
-    throwError(errMsg);
-  }
-  var cond = new RelationalConditionInternal();
-  cond.valueGetterParam = valueGetterParam;
-  cond.valueParser = valueParser;
-  cond.getValue = getters.getValue;
-  cond.subCondList = subCondList;
-  return cond;
-}
-function isObjectNotArray(val) {
-  return isObject(val) && !isArrayLike(val);
-}
-var ConditionalExpressionParsed = /** @class */function () {
-  function ConditionalExpressionParsed(exprOption, getters) {
-    this._cond = parseOption(exprOption, getters);
-  }
-  ConditionalExpressionParsed.prototype.evaluate = function () {
-    return this._cond.evaluate();
-  };
-  return ConditionalExpressionParsed;
-}();
-function parseConditionalExpression(exprOption, getters) {
-  return new ConditionalExpressionParsed(exprOption, getters);
-}
-
-export { parseConditionalExpression };