@fmdevui/fm-dev 1.0.112 → 1.0.114

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/data/helper/dataValueHelper.js

@@ -0,0 +1,202 @@
+'use strict';
+
+var number = require('../../util/number.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var log = require('../../util/log.js');
+
+/**
+ * Convert raw the value in to inner value in List.
+ *
+ * [Performance sensitive]
+ *
+ * [Caution]: this is the key logic of user value parser.
+ * For backward compatibility, do not modify it until you have to!
+ */
+function parseDataValue(value,
+// For high performance, do not omit the second param.
+opt) {
+  // Performance sensitive.
+  var dimType = opt && opt.type;
+  if (dimType === 'ordinal') {
+    // If given value is a category string
+    return value;
+  }
+  if (dimType === 'time'
+  // spead up when using timestamp
+  && !util.isNumber(value) && value != null && value !== '-') {
+    value = +number.parseDate(value);
+  }
+  // dimType defaults 'number'.
+  // If dimType is not ordinal and value is null or undefined or NaN or '-',
+  // parse to NaN.
+  // number-like string (like ' 123 ') can be converted to a number.
+  // where null/undefined or other string will be converted to NaN.
+  return value == null || value === '' ? NaN
+  // If string (like '-'), using '+' parse to NaN
+  // If object, also parse to NaN
+  : Number(value);
+}
+;
+var valueParserMap = util.createHashMap({
+  'number': function (val) {
+    // Do not use `numericToNumber` here. We have `numericToNumber` by default.
+    // Here the number parser can have loose rule:
+    // enable to cut suffix: "120px" => 120, "14%" => 14.
+    return parseFloat(val);
+  },
+  'time': function (val) {
+    // return timestamp.
+    return +number.parseDate(val);
+  },
+  'trim': function (val) {
+    return util.isString(val) ? util.trim(val) : val;
+  }
+});
+function getRawValueParser(type) {
+  return valueParserMap.get(type);
+}
+var ORDER_COMPARISON_OP_MAP = {
+  lt: function (lval, rval) {
+    return lval < rval;
+  },
+  lte: function (lval, rval) {
+    return lval <= rval;
+  },
+  gt: function (lval, rval) {
+    return lval > rval;
+  },
+  gte: function (lval, rval) {
+    return lval >= rval;
+  }
+};
+var FilterOrderComparator = /** @class */function () {
+  function FilterOrderComparator(op, rval) {
+    if (!util.isNumber(rval)) {
+      var errMsg = '';
+      if (process.env.NODE_ENV !== 'production') {
+        errMsg = 'rvalue of "<", ">", "<=", ">=" can only be number in filter.';
+      }
+      log.throwError(errMsg);
+    }
+    this._opFn = ORDER_COMPARISON_OP_MAP[op];
+    this._rvalFloat = number.numericToNumber(rval);
+  }
+  // Performance sensitive.
+  FilterOrderComparator.prototype.evaluate = function (lval) {
+    // Most cases is 'number', and typeof maybe 10 times faseter than parseFloat.
+    return util.isNumber(lval) ? this._opFn(lval, this._rvalFloat) : this._opFn(number.numericToNumber(lval), this._rvalFloat);
+  };
+  return FilterOrderComparator;
+}();
+var SortOrderComparator = /** @class */function () {
+  /**
+   * @param order by default: 'asc'
+   * @param incomparable by default: Always on the tail.
+   *        That is, if 'asc' => 'max', if 'desc' => 'min'
+   *        See the definition of "incomparable" in [SORT_COMPARISON_RULE].
+   */
+  function SortOrderComparator(order, incomparable) {
+    var isDesc = order === 'desc';
+    this._resultLT = isDesc ? 1 : -1;
+    if (incomparable == null) {
+      incomparable = isDesc ? 'min' : 'max';
+    }
+    this._incomparable = incomparable === 'min' ? -Infinity : Infinity;
+  }
+  // See [SORT_COMPARISON_RULE].
+  // Performance sensitive.
+  SortOrderComparator.prototype.evaluate = function (lval, rval) {
+    // Most cases is 'number', and typeof maybe 10 times faseter than parseFloat.
+    var lvalFloat = util.isNumber(lval) ? lval : number.numericToNumber(lval);
+    var rvalFloat = util.isNumber(rval) ? rval : number.numericToNumber(rval);
+    var lvalNotNumeric = isNaN(lvalFloat);
+    var rvalNotNumeric = isNaN(rvalFloat);
+    if (lvalNotNumeric) {
+      lvalFloat = this._incomparable;
+    }
+    if (rvalNotNumeric) {
+      rvalFloat = this._incomparable;
+    }
+    if (lvalNotNumeric && rvalNotNumeric) {
+      var lvalIsStr = util.isString(lval);
+      var rvalIsStr = util.isString(rval);
+      if (lvalIsStr) {
+        lvalFloat = rvalIsStr ? lval : 0;
+      }
+      if (rvalIsStr) {
+        rvalFloat = lvalIsStr ? rval : 0;
+      }
+    }
+    return lvalFloat < rvalFloat ? this._resultLT : lvalFloat > rvalFloat ? -this._resultLT : 0;
+  };
+  return SortOrderComparator;
+}();
+var FilterEqualityComparator = /** @class */function () {
+  function FilterEqualityComparator(isEq, rval) {
+    this._rval = rval;
+    this._isEQ = isEq;
+    this._rvalTypeof = typeof rval;
+    this._rvalFloat = number.numericToNumber(rval);
+  }
+  // Performance sensitive.
+  FilterEqualityComparator.prototype.evaluate = function (lval) {
+    var eqResult = lval === this._rval;
+    if (!eqResult) {
+      var lvalTypeof = typeof lval;
+      if (lvalTypeof !== this._rvalTypeof && (lvalTypeof === 'number' || this._rvalTypeof === 'number')) {
+        eqResult = number.numericToNumber(lval) === this._rvalFloat;
+      }
+    }
+    return this._isEQ ? eqResult : !eqResult;
+  };
+  return FilterEqualityComparator;
+}();
+/**
+ * [FILTER_COMPARISON_RULE]
+ * `lt`|`lte`|`gt`|`gte`:
+ * + rval must be a number. And lval will be converted to number (`numericToNumber`) to compare.
+ * `eq`:
+ * + If same type, compare with `===`.
+ * + If there is one number, convert to number (`numericToNumber`) to compare.
+ * + Else return `false`.
+ * `ne`:
+ * + Not `eq`.
+ *
+ *
+ * [SORT_COMPARISON_RULE]
+ * All the values are grouped into three categories:
+ * + "numeric" (number and numeric string)
+ * + "non-numeric-string" (string that excluding numeric string)
+ * + "others"
+ * "numeric" vs "numeric": values are ordered by number order.
+ * "non-numeric-string" vs "non-numeric-string": values are ordered by ES spec (#sec-abstract-relational-comparison).
+ * "others" vs "others": do not change order (always return 0).
+ * "numeric" vs "non-numeric-string": "non-numeric-string" is treated as "incomparable".
+ * "number" vs "others": "others" is treated as "incomparable".
+ * "non-numeric-string" vs "others": "others" is treated as "incomparable".
+ * "incomparable" will be seen as -Infinity or Infinity (depends on the settings).
+ * MEMO:
+ *   Non-numeric string sort makes sense when we need to put the items with the same tag together.
+ *   But if we support string sort, we still need to avoid the misleading like `'2' > '12'`,
+ *   So we treat "numeric-string" sorted by number order rather than string comparison.
+ *
+ *
+ * [CHECK_LIST_OF_THE_RULE_DESIGN]
+ * + Do not support string comparison until required. And also need to
+ *   avoid the misleading of "2" > "12".
+ * + Should avoid the misleading case:
+ *   `" 22 " gte "22"` is `true` but `" 22 " eq "22"` is `false`.
+ * + JS bad case should be avoided: null <= 0, [] <= 0, ' ' <= 0, ...
+ * + Only "numeric" can be converted to comparable number, otherwise converted to NaN.
+ *   See `util/number.ts#numericToNumber`.
+ *
+ * @return If `op` is not `RelationalOperator`, return null;
+ */
+function createFilterComparator(op, rval) {
+  return op === 'eq' || op === 'ne' ? new FilterEqualityComparator(op === 'eq', rval) : util.hasOwn(ORDER_COMPARISON_OP_MAP, op) ? new FilterOrderComparator(op, rval) : null;
+}
+
+exports.SortOrderComparator = SortOrderComparator;
+exports.createFilterComparator = createFilterComparator;
+exports.getRawValueParser = getRawValueParser;
+exports.parseDataValue = parseDataValue;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/data/helper/dimensionHelper.js

@@ -0,0 +1,135 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var types = require('../../util/types.js');
+
+var DimensionUserOuput = /** @class */function () {
+  function DimensionUserOuput(encode, dimRequest) {
+    this._encode = encode;
+    this._schema = dimRequest;
+  }
+  DimensionUserOuput.prototype.get = function () {
+    return {
+      // Do not generate full dimension name until fist used.
+      fullDimensions: this._getFullDimensionNames(),
+      encode: this._encode
+    };
+  };
+  /**
+   * Get all data store dimension names.
+   * Theoretically a series data store is defined both by series and used dataset (if any).
+   * If some dimensions are omitted for performance reason in `this.dimensions`,
+   * the dimension name may not be auto-generated if user does not specify a dimension name.
+   * In this case, the dimension name is `null`/`undefined`.
+   */
+  DimensionUserOuput.prototype._getFullDimensionNames = function () {
+    if (!this._cachedDimNames) {
+      this._cachedDimNames = this._schema ? this._schema.makeOutputDimensionNames() : [];
+    }
+    return this._cachedDimNames;
+  };
+  return DimensionUserOuput;
+}();
+;
+function summarizeDimensions(data, schema) {
+  var summary = {};
+  var encode = summary.encode = {};
+  var notExtraCoordDimMap = util.createHashMap();
+  var defaultedLabel = [];
+  var defaultedTooltip = [];
+  var userOutputEncode = {};
+  util.each(data.dimensions, function (dimName) {
+    var dimItem = data.getDimensionInfo(dimName);
+    var coordDim = dimItem.coordDim;
+    if (coordDim) {
+      if (process.env.NODE_ENV !== 'production') {
+        util.assert(types.VISUAL_DIMENSIONS.get(coordDim) == null);
+      }
+      var coordDimIndex = dimItem.coordDimIndex;
+      getOrCreateEncodeArr(encode, coordDim)[coordDimIndex] = dimName;
+      if (!dimItem.isExtraCoord) {
+        notExtraCoordDimMap.set(coordDim, 1);
+        // Use the last coord dim (and label friendly) as default label,
+        // because when dataset is used, it is hard to guess which dimension
+        // can be value dimension. If both show x, y on label is not look good,
+        // and conventionally y axis is focused more.
+        if (mayLabelDimType(dimItem.type)) {
+          defaultedLabel[0] = dimName;
+        }
+        // User output encode do not contain generated coords.
+        // And it only has index. User can use index to retrieve value from the raw item array.
+        getOrCreateEncodeArr(userOutputEncode, coordDim)[coordDimIndex] = data.getDimensionIndex(dimItem.name);
+      }
+      if (dimItem.defaultTooltip) {
+        defaultedTooltip.push(dimName);
+      }
+    }
+    types.VISUAL_DIMENSIONS.each(function (v, otherDim) {
+      var encodeArr = getOrCreateEncodeArr(encode, otherDim);
+      var dimIndex = dimItem.otherDims[otherDim];
+      if (dimIndex != null && dimIndex !== false) {
+        encodeArr[dimIndex] = dimItem.name;
+      }
+    });
+  });
+  var dataDimsOnCoord = [];
+  var encodeFirstDimNotExtra = {};
+  notExtraCoordDimMap.each(function (v, coordDim) {
+    var dimArr = encode[coordDim];
+    encodeFirstDimNotExtra[coordDim] = dimArr[0];
+    // Not necessary to remove duplicate, because a data
+    // dim canot on more than one coordDim.
+    dataDimsOnCoord = dataDimsOnCoord.concat(dimArr);
+  });
+  summary.dataDimsOnCoord = dataDimsOnCoord;
+  summary.dataDimIndicesOnCoord = util.map(dataDimsOnCoord, function (dimName) {
+    return data.getDimensionInfo(dimName).storeDimIndex;
+  });
+  summary.encodeFirstDimNotExtra = encodeFirstDimNotExtra;
+  var encodeLabel = encode.label;
+  // FIXME `encode.label` is not recommended, because formatter cannot be set
+  // in this way. Use label.formatter instead. Maybe remove this approach someday.
+  if (encodeLabel && encodeLabel.length) {
+    defaultedLabel = encodeLabel.slice();
+  }
+  var encodeTooltip = encode.tooltip;
+  if (encodeTooltip && encodeTooltip.length) {
+    defaultedTooltip = encodeTooltip.slice();
+  } else if (!defaultedTooltip.length) {
+    defaultedTooltip = defaultedLabel.slice();
+  }
+  encode.defaultedLabel = defaultedLabel;
+  encode.defaultedTooltip = defaultedTooltip;
+  summary.userOutput = new DimensionUserOuput(userOutputEncode, schema);
+  return summary;
+}
+function getOrCreateEncodeArr(encode, dim) {
+  if (!encode.hasOwnProperty(dim)) {
+    encode[dim] = [];
+  }
+  return encode[dim];
+}
+// FIXME:TS should be type `AxisType`
+function getDimensionTypeByAxis(axisType) {
+  return axisType === 'category' ? 'ordinal' : axisType === 'time' ? 'time' : 'float';
+}
+function mayLabelDimType(dimType) {
+  // In most cases, ordinal and time do not suitable for label.
+  // Ordinal info can be displayed on axis. Time is too long.
+  return !(dimType === 'ordinal' || dimType === 'time');
+}
+// function findTheLastDimMayLabel(data) {
+//     // Get last value dim
+//     let dimensions = data.dimensions.slice();
+//     let valueType;
+//     let valueDim;
+//     while (dimensions.length && (
+//         valueDim = dimensions.pop(),
+//         valueType = data.getDimensionInfo(valueDim).type,
+//         valueType === 'ordinal' || valueType === 'time'
+//     )) {} // jshint ignore:line
+//     return valueDim;
+// }
+
+exports.getDimensionTypeByAxis = getDimensionTypeByAxis;
+exports.summarizeDimensions = summarizeDimensions;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/data/helper/linkSeriesData.js

@@ -0,0 +1,110 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var model = require('../../util/model.js');
+
+var inner = model.makeInner();
+function linkSeriesData(opt) {
+  var mainData = opt.mainData;
+  var datas = opt.datas;
+  if (!datas) {
+    datas = {
+      main: mainData
+    };
+    opt.datasAttr = {
+      main: 'data'
+    };
+  }
+  opt.datas = opt.mainData = null;
+  linkAll(mainData, datas, opt);
+  // Porxy data original methods.
+  util.each(datas, function (data) {
+    util.each(mainData.TRANSFERABLE_METHODS, function (methodName) {
+      data.wrapMethod(methodName, util.curry(transferInjection, opt));
+    });
+  });
+  // Beyond transfer, additional features should be added to `cloneShallow`.
+  mainData.wrapMethod('cloneShallow', util.curry(cloneShallowInjection, opt));
+  // Only mainData trigger change, because struct.update may trigger
+  // another changable methods, which may bring about dead lock.
+  util.each(mainData.CHANGABLE_METHODS, function (methodName) {
+    mainData.wrapMethod(methodName, util.curry(changeInjection, opt));
+  });
+  // Make sure datas contains mainData.
+  util.assert(datas[mainData.dataType] === mainData);
+}
+function transferInjection(opt, res) {
+  if (isMainData(this)) {
+    // Transfer datas to new main data.
+    var datas = util.extend({}, inner(this).datas);
+    datas[this.dataType] = res;
+    linkAll(res, datas, opt);
+  } else {
+    // Modify the reference in main data to point newData.
+    linkSingle(res, this.dataType, inner(this).mainData, opt);
+  }
+  return res;
+}
+function changeInjection(opt, res) {
+  opt.struct && opt.struct.update();
+  return res;
+}
+function cloneShallowInjection(opt, res) {
+  // cloneShallow, which brings about some fragilities, may be inappropriate
+  // to be exposed as an API. So for implementation simplicity we can make
+  // the restriction that cloneShallow of not-mainData should not be invoked
+  // outside, but only be invoked here.
+  util.each(inner(res).datas, function (data, dataType) {
+    data !== res && linkSingle(data.cloneShallow(), dataType, res, opt);
+  });
+  return res;
+}
+/**
+ * Supplement method to List.
+ *
+ * @public
+ * @param [dataType] If not specified, return mainData.
+ */
+function getLinkedData(dataType) {
+  var mainData = inner(this).mainData;
+  return dataType == null || mainData == null ? mainData : inner(mainData).datas[dataType];
+}
+/**
+ * Get list of all linked data
+ */
+function getLinkedDataAll() {
+  var mainData = inner(this).mainData;
+  return mainData == null ? [{
+    data: mainData
+  }] : util.map(util.keys(inner(mainData).datas), function (type) {
+    return {
+      type: type,
+      data: inner(mainData).datas[type]
+    };
+  });
+}
+function isMainData(data) {
+  return inner(data).mainData === data;
+}
+function linkAll(mainData, datas, opt) {
+  inner(mainData).datas = {};
+  util.each(datas, function (data, dataType) {
+    linkSingle(data, dataType, mainData, opt);
+  });
+}
+function linkSingle(data, dataType, mainData, opt) {
+  inner(mainData).datas[dataType] = data;
+  inner(data).mainData = mainData;
+  data.dataType = dataType;
+  if (opt.struct) {
+    data[opt.structAttr] = opt.struct;
+    opt.struct[opt.datasAttr[dataType]] = data;
+  }
+  // Supplement method.
+  data.getLinkedData = getLinkedData;
+  data.getLinkedDataAll = getLinkedDataAll;
+}
+
+exports.default = linkSeriesData;