@fmdevui/fm-dev 1.0.112 → 1.0.114

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/clazz.mjs

@@ -0,0 +1,265 @@
+import { __extends } from '../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import { assert, each, inherits, extend, isFunction } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+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/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/component.mjs

@@ -0,0 +1,146 @@
+import { each, indexOf, merge } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { parseClassType } from './clazz.mjs';
+import { makePrintable } from './log.mjs';
+
+// 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/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/conditionalExpression.mjs

@@ -0,0 +1,217 @@
+import { isString, isRegExp, isNumber, isArray, map, keys, hasOwn, isObject, isArrayLike } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { makePrintable, throwError } from './log.mjs';
+import { getRawValueParser, createFilterComparator } from '../data/helper/dataValueHelper.mjs';
+
+;
+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 };