@fmdevui/fm-dev 1.0.113 → 1.0.115

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/data/SeriesDimensionDefine.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+var SeriesDimensionDefine = /** @class */function () {
+  /**
+   * @param opt All of the fields will be shallow copied.
+   */
+  function SeriesDimensionDefine(opt) {
+    /**
+     * The format of `otherDims` is:
+     * ```js
+     * {
+     *     tooltip?: number
+     *     label?: number
+     *     itemName?: number
+     *     seriesName?: number
+     * }
+     * ```
+     *
+     * A `series.encode` can specified these fields:
+     * ```js
+     * encode: {
+     *     // "3, 1, 5" is the index of data dimension.
+     *     tooltip: [3, 1, 5],
+     *     label: [0, 3],
+     *     ...
+     * }
+     * ```
+     * `otherDims` is the parse result of the `series.encode` above, like:
+     * ```js
+     * // Suppose the index of this data dimension is `3`.
+     * this.otherDims = {
+     *     // `3` is at the index `0` of the `encode.tooltip`
+     *     tooltip: 0,
+     *     // `3` is at the index `1` of the `encode.label`
+     *     label: 1
+     * };
+     * ```
+     *
+     * This prop should never be `null`/`undefined` after initialized.
+     */
+    this.otherDims = {};
+    if (opt != null) {
+      util.extend(this, opt);
+    }
+  }
+  return SeriesDimensionDefine;
+}();
+;
+
+exports.default = SeriesDimensionDefine;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/data/Source.js

@@ -0,0 +1,266 @@
+'use strict';
+
+var util = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var types = require('../util/types.js');
+var model = require('../util/model.js');
+var sourceHelper = require('./helper/sourceHelper.js');
+
+;
+// @inner
+var SourceImpl = /** @class */function () {
+  function SourceImpl(fields) {
+    this.data = fields.data || (fields.sourceFormat === types.SOURCE_FORMAT_KEYED_COLUMNS ? {} : []);
+    this.sourceFormat = fields.sourceFormat || types.SOURCE_FORMAT_UNKNOWN;
+    // Visit config
+    this.seriesLayoutBy = fields.seriesLayoutBy || types.SERIES_LAYOUT_BY_COLUMN;
+    this.startIndex = fields.startIndex || 0;
+    this.dimensionsDetectedCount = fields.dimensionsDetectedCount;
+    this.metaRawOption = fields.metaRawOption;
+    var dimensionsDefine = this.dimensionsDefine = fields.dimensionsDefine;
+    if (dimensionsDefine) {
+      for (var i = 0; i < dimensionsDefine.length; i++) {
+        var dim = dimensionsDefine[i];
+        if (dim.type == null) {
+          if (sourceHelper.guessOrdinal(this, i) === sourceHelper.BE_ORDINAL.Must) {
+            dim.type = 'ordinal';
+          }
+        }
+      }
+    }
+  }
+  return SourceImpl;
+}();
+function isSourceInstance(val) {
+  return val instanceof SourceImpl;
+}
+/**
+ * Create a source from option.
+ * NOTE: Created source is immutable. Don't change any properties in it.
+ */
+function createSource(sourceData, thisMetaRawOption,
+// can be null. If not provided, auto detect it from `sourceData`.
+sourceFormat) {
+  sourceFormat = sourceFormat || detectSourceFormat(sourceData);
+  var seriesLayoutBy = thisMetaRawOption.seriesLayoutBy;
+  var determined = determineSourceDimensions(sourceData, sourceFormat, seriesLayoutBy, thisMetaRawOption.sourceHeader, thisMetaRawOption.dimensions);
+  var source = new SourceImpl({
+    data: sourceData,
+    sourceFormat: sourceFormat,
+    seriesLayoutBy: seriesLayoutBy,
+    dimensionsDefine: determined.dimensionsDefine,
+    startIndex: determined.startIndex,
+    dimensionsDetectedCount: determined.dimensionsDetectedCount,
+    metaRawOption: util.clone(thisMetaRawOption)
+  });
+  return source;
+}
+/**
+ * Wrap original series data for some compatibility cases.
+ */
+function createSourceFromSeriesDataOption(data) {
+  return new SourceImpl({
+    data: data,
+    sourceFormat: util.isTypedArray(data) ? types.SOURCE_FORMAT_TYPED_ARRAY : types.SOURCE_FORMAT_ORIGINAL
+  });
+}
+/**
+ * Clone source but excludes source data.
+ */
+function cloneSourceShallow(source) {
+  return new SourceImpl({
+    data: source.data,
+    sourceFormat: source.sourceFormat,
+    seriesLayoutBy: source.seriesLayoutBy,
+    dimensionsDefine: util.clone(source.dimensionsDefine),
+    startIndex: source.startIndex,
+    dimensionsDetectedCount: source.dimensionsDetectedCount
+  });
+}
+/**
+ * Note: An empty array will be detected as `SOURCE_FORMAT_ARRAY_ROWS`.
+ */
+function detectSourceFormat(data) {
+  var sourceFormat = types.SOURCE_FORMAT_UNKNOWN;
+  if (util.isTypedArray(data)) {
+    sourceFormat = types.SOURCE_FORMAT_TYPED_ARRAY;
+  } else if (util.isArray(data)) {
+    // FIXME Whether tolerate null in top level array?
+    if (data.length === 0) {
+      sourceFormat = types.SOURCE_FORMAT_ARRAY_ROWS;
+    }
+    for (var i = 0, len = data.length; i < len; i++) {
+      var item = data[i];
+      if (item == null) {
+        continue;
+      } else if (util.isArray(item) || util.isTypedArray(item)) {
+        sourceFormat = types.SOURCE_FORMAT_ARRAY_ROWS;
+        break;
+      } else if (util.isObject(item)) {
+        sourceFormat = types.SOURCE_FORMAT_OBJECT_ROWS;
+        break;
+      }
+    }
+  } else if (util.isObject(data)) {
+    for (var key in data) {
+      if (util.hasOwn(data, key) && util.isArrayLike(data[key])) {
+        sourceFormat = types.SOURCE_FORMAT_KEYED_COLUMNS;
+        break;
+      }
+    }
+  }
+  return sourceFormat;
+}
+/**
+ * Determine the source definitions from data standalone dimensions definitions
+ * are not specified.
+ */
+function determineSourceDimensions(data, sourceFormat, seriesLayoutBy, sourceHeader,
+// standalone raw dimensions definition, like:
+// {
+//     dimensions: ['aa', 'bb', { name: 'cc', type: 'time' }]
+// }
+// in `dataset` or `series`
+dimensionsDefine) {
+  var dimensionsDetectedCount;
+  var startIndex;
+  // PENDING: Could data be null/undefined here?
+  // currently, if `dataset.source` not specified, error thrown.
+  // if `series.data` not specified, nothing rendered without error thrown.
+  // Should test these cases.
+  if (!data) {
+    return {
+      dimensionsDefine: normalizeDimensionsOption(dimensionsDefine),
+      startIndex: startIndex,
+      dimensionsDetectedCount: dimensionsDetectedCount
+    };
+  }
+  if (sourceFormat === types.SOURCE_FORMAT_ARRAY_ROWS) {
+    var dataArrayRows = data;
+    // Rule: Most of the first line are string: it is header.
+    // Caution: consider a line with 5 string and 1 number,
+    // it still can not be sure it is a head, because the
+    // 5 string may be 5 values of category columns.
+    if (sourceHeader === 'auto' || sourceHeader == null) {
+      arrayRowsTravelFirst(function (val) {
+        // '-' is regarded as null/undefined.
+        if (val != null && val !== '-') {
+          if (util.isString(val)) {
+            startIndex == null && (startIndex = 1);
+          } else {
+            startIndex = 0;
+          }
+        }
+        // 10 is an experience number, avoid long loop.
+      }, seriesLayoutBy, dataArrayRows, 10);
+    } else {
+      startIndex = util.isNumber(sourceHeader) ? sourceHeader : sourceHeader ? 1 : 0;
+    }
+    if (!dimensionsDefine && startIndex === 1) {
+      dimensionsDefine = [];
+      arrayRowsTravelFirst(function (val, index) {
+        dimensionsDefine[index] = val != null ? val + '' : '';
+      }, seriesLayoutBy, dataArrayRows, Infinity);
+    }
+    dimensionsDetectedCount = dimensionsDefine ? dimensionsDefine.length : seriesLayoutBy === types.SERIES_LAYOUT_BY_ROW ? dataArrayRows.length : dataArrayRows[0] ? dataArrayRows[0].length : null;
+  } else if (sourceFormat === types.SOURCE_FORMAT_OBJECT_ROWS) {
+    if (!dimensionsDefine) {
+      dimensionsDefine = objectRowsCollectDimensions(data);
+    }
+  } else if (sourceFormat === types.SOURCE_FORMAT_KEYED_COLUMNS) {
+    if (!dimensionsDefine) {
+      dimensionsDefine = [];
+      util.each(data, function (colArr, key) {
+        dimensionsDefine.push(key);
+      });
+    }
+  } else if (sourceFormat === types.SOURCE_FORMAT_ORIGINAL) {
+    var value0 = model.getDataItemValue(data[0]);
+    dimensionsDetectedCount = util.isArray(value0) && value0.length || 1;
+  } else if (sourceFormat === types.SOURCE_FORMAT_TYPED_ARRAY) {
+    if (process.env.NODE_ENV !== 'production') {
+      util.assert(!!dimensionsDefine, 'dimensions must be given if data is TypedArray.');
+    }
+  }
+  return {
+    startIndex: startIndex,
+    dimensionsDefine: normalizeDimensionsOption(dimensionsDefine),
+    dimensionsDetectedCount: dimensionsDetectedCount
+  };
+}
+function objectRowsCollectDimensions(data) {
+  var firstIndex = 0;
+  var obj;
+  while (firstIndex < data.length && !(obj = data[firstIndex++])) {} // jshint ignore: line
+  if (obj) {
+    return util.keys(obj);
+  }
+}
+// Consider dimensions defined like ['A', 'price', 'B', 'price', 'C', 'price'],
+// which is reasonable. But dimension name is duplicated.
+// Returns undefined or an array contains only object without null/undefined or string.
+function normalizeDimensionsOption(dimensionsDefine) {
+  if (!dimensionsDefine) {
+    // The meaning of null/undefined is different from empty array.
+    return;
+  }
+  var nameMap = util.createHashMap();
+  return util.map(dimensionsDefine, function (rawItem, index) {
+    rawItem = util.isObject(rawItem) ? rawItem : {
+      name: rawItem
+    };
+    // Other fields will be discarded.
+    var item = {
+      name: rawItem.name,
+      displayName: rawItem.displayName,
+      type: rawItem.type
+    };
+    // User can set null in dimensions.
+    // We don't auto specify name, otherwise a given name may
+    // cause it to be referred unexpectedly.
+    if (item.name == null) {
+      return item;
+    }
+    // Also consider number form like 2012.
+    item.name += '';
+    // User may also specify displayName.
+    // displayName will always exists except user not
+    // specified or dim name is not specified or detected.
+    // (A auto generated dim name will not be used as
+    // displayName).
+    if (item.displayName == null) {
+      item.displayName = item.name;
+    }
+    var exist = nameMap.get(item.name);
+    if (!exist) {
+      nameMap.set(item.name, {
+        count: 1
+      });
+    } else {
+      item.name += '-' + exist.count++;
+    }
+    return item;
+  });
+}
+function arrayRowsTravelFirst(cb, seriesLayoutBy, data, maxLoop) {
+  if (seriesLayoutBy === types.SERIES_LAYOUT_BY_ROW) {
+    for (var i = 0; i < data.length && i < maxLoop; i++) {
+      cb(data[i] ? data[i][0] : null, i);
+    }
+  } else {
+    var value0 = data[0] || [];
+    for (var i = 0; i < value0.length && i < maxLoop; i++) {
+      cb(value0[i], i);
+    }
+  }
+}
+function shouldRetrieveDataByName(source) {
+  var sourceFormat = source.sourceFormat;
+  return sourceFormat === types.SOURCE_FORMAT_OBJECT_ROWS || sourceFormat === types.SOURCE_FORMAT_KEYED_COLUMNS;
+}
+
+exports.cloneSourceShallow = cloneSourceShallow;
+exports.createSource = createSource;
+exports.createSourceFromSeriesDataOption = createSourceFromSeriesDataOption;
+exports.detectSourceFormat = detectSourceFormat;
+exports.isSourceInstance = isSourceInstance;
+exports.shouldRetrieveDataByName = shouldRetrieveDataByName;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/data/Tree.js

@@ -0,0 +1,313 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var linkSeriesData = require('./helper/linkSeriesData.js');
+var SeriesData = require('./SeriesData.js');
+var createDimensions = require('./helper/createDimensions.js');
+var model = require('../util/model.js');
+
+var TreeNode = /** @class */function () {
+  function TreeNode(name, hostTree) {
+    this.depth = 0;
+    this.height = 0;
+    /**
+     * Reference to list item.
+     * Do not persistent dataIndex outside,
+     * besause it may be changed by list.
+     * If dataIndex -1,
+     * this node is logical deleted (filtered) in list.
+     */
+    this.dataIndex = -1;
+    this.children = [];
+    this.viewChildren = [];
+    this.isExpand = false;
+    this.name = name || '';
+    this.hostTree = hostTree;
+  }
+  /**
+   * The node is removed.
+   */
+  TreeNode.prototype.isRemoved = function () {
+    return this.dataIndex < 0;
+  };
+  TreeNode.prototype.eachNode = function (options, cb, context) {
+    if (util.isFunction(options)) {
+      context = cb;
+      cb = options;
+      options = null;
+    }
+    options = options || {};
+    if (util.isString(options)) {
+      options = {
+        order: options
+      };
+    }
+    var order = options.order || 'preorder';
+    var children = this[options.attr || 'children'];
+    var suppressVisitSub;
+    order === 'preorder' && (suppressVisitSub = cb.call(context, this));
+    for (var i = 0; !suppressVisitSub && i < children.length; i++) {
+      children[i].eachNode(options, cb, context);
+    }
+    order === 'postorder' && cb.call(context, this);
+  };
+  /**
+   * Update depth and height of this subtree.
+   */
+  TreeNode.prototype.updateDepthAndHeight = function (depth) {
+    var height = 0;
+    this.depth = depth;
+    for (var i = 0; i < this.children.length; i++) {
+      var child = this.children[i];
+      child.updateDepthAndHeight(depth + 1);
+      if (child.height > height) {
+        height = child.height;
+      }
+    }
+    this.height = height + 1;
+  };
+  TreeNode.prototype.getNodeById = function (id) {
+    if (this.getId() === id) {
+      return this;
+    }
+    for (var i = 0, children = this.children, len = children.length; i < len; i++) {
+      var res = children[i].getNodeById(id);
+      if (res) {
+        return res;
+      }
+    }
+  };
+  TreeNode.prototype.contains = function (node) {
+    if (node === this) {
+      return true;
+    }
+    for (var i = 0, children = this.children, len = children.length; i < len; i++) {
+      var res = children[i].contains(node);
+      if (res) {
+        return res;
+      }
+    }
+  };
+  /**
+   * @param includeSelf Default false.
+   * @return order: [root, child, grandchild, ...]
+   */
+  TreeNode.prototype.getAncestors = function (includeSelf) {
+    var ancestors = [];
+    var node = includeSelf ? this : this.parentNode;
+    while (node) {
+      ancestors.push(node);
+      node = node.parentNode;
+    }
+    ancestors.reverse();
+    return ancestors;
+  };
+  TreeNode.prototype.getAncestorsIndices = function () {
+    var indices = [];
+    var currNode = this;
+    while (currNode) {
+      indices.push(currNode.dataIndex);
+      currNode = currNode.parentNode;
+    }
+    indices.reverse();
+    return indices;
+  };
+  TreeNode.prototype.getDescendantIndices = function () {
+    var indices = [];
+    this.eachNode(function (childNode) {
+      indices.push(childNode.dataIndex);
+    });
+    return indices;
+  };
+  TreeNode.prototype.getValue = function (dimension) {
+    var data = this.hostTree.data;
+    return data.getStore().get(data.getDimensionIndex(dimension || 'value'), this.dataIndex);
+  };
+  TreeNode.prototype.setLayout = function (layout, merge) {
+    this.dataIndex >= 0 && this.hostTree.data.setItemLayout(this.dataIndex, layout, merge);
+  };
+  /**
+   * @return {Object} layout
+   */
+  TreeNode.prototype.getLayout = function () {
+    return this.hostTree.data.getItemLayout(this.dataIndex);
+  };
+  // @depcrecated
+  // getModel<T = unknown, S extends keyof T = keyof T>(path: S): Model<T[S]>
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  TreeNode.prototype.getModel = function (path) {
+    if (this.dataIndex < 0) {
+      return;
+    }
+    var hostTree = this.hostTree;
+    var itemModel = hostTree.data.getItemModel(this.dataIndex);
+    return itemModel.getModel(path);
+  };
+  // TODO: TYPE More specific model
+  TreeNode.prototype.getLevelModel = function () {
+    return (this.hostTree.levelModels || [])[this.depth];
+  };
+  TreeNode.prototype.setVisual = function (key, value) {
+    this.dataIndex >= 0 && this.hostTree.data.setItemVisual(this.dataIndex, key, value);
+  };
+  /**
+   * Get item visual
+   * FIXME: make return type better
+   */
+  TreeNode.prototype.getVisual = function (key) {
+    return this.hostTree.data.getItemVisual(this.dataIndex, key);
+  };
+  TreeNode.prototype.getRawIndex = function () {
+    return this.hostTree.data.getRawIndex(this.dataIndex);
+  };
+  TreeNode.prototype.getId = function () {
+    return this.hostTree.data.getId(this.dataIndex);
+  };
+  /**
+   * index in parent's children
+   */
+  TreeNode.prototype.getChildIndex = function () {
+    if (this.parentNode) {
+      var children = this.parentNode.children;
+      for (var i = 0; i < children.length; ++i) {
+        if (children[i] === this) {
+          return i;
+        }
+      }
+      return -1;
+    }
+    return -1;
+  };
+  /**
+   * if this is an ancestor of another node
+   *
+   * @param node another node
+   * @return if is ancestor
+   */
+  TreeNode.prototype.isAncestorOf = function (node) {
+    var parent = node.parentNode;
+    while (parent) {
+      if (parent === this) {
+        return true;
+      }
+      parent = parent.parentNode;
+    }
+    return false;
+  };
+  /**
+   * if this is an descendant of another node
+   *
+   * @param node another node
+   * @return if is descendant
+   */
+  TreeNode.prototype.isDescendantOf = function (node) {
+    return node !== this && node.isAncestorOf(this);
+  };
+  return TreeNode;
+}();
+;
+var Tree = /** @class */function () {
+  function Tree(hostModel) {
+    this.type = 'tree';
+    this._nodes = [];
+    this.hostModel = hostModel;
+  }
+  Tree.prototype.eachNode = function (options, cb, context) {
+    this.root.eachNode(options, cb, context);
+  };
+  Tree.prototype.getNodeByDataIndex = function (dataIndex) {
+    var rawIndex = this.data.getRawIndex(dataIndex);
+    return this._nodes[rawIndex];
+  };
+  Tree.prototype.getNodeById = function (name) {
+    return this.root.getNodeById(name);
+  };
+  /**
+   * Update item available by list,
+   * when list has been performed options like 'filterSelf' or 'map'.
+   */
+  Tree.prototype.update = function () {
+    var data = this.data;
+    var nodes = this._nodes;
+    for (var i = 0, len = nodes.length; i < len; i++) {
+      nodes[i].dataIndex = -1;
+    }
+    for (var i = 0, len = data.count(); i < len; i++) {
+      nodes[data.getRawIndex(i)].dataIndex = i;
+    }
+  };
+  /**
+   * Clear all layouts
+   */
+  Tree.prototype.clearLayouts = function () {
+    this.data.clearItemLayouts();
+  };
+  /**
+   * data node format:
+   * {
+   *     name: ...
+   *     value: ...
+   *     children: [
+   *         {
+   *             name: ...
+   *             value: ...
+   *             children: ...
+   *         },
+   *         ...
+   *     ]
+   * }
+   */
+  Tree.createTree = function (dataRoot, hostModel, beforeLink) {
+    var tree = new Tree(hostModel);
+    var listData = [];
+    var dimMax = 1;
+    buildHierarchy(dataRoot);
+    function buildHierarchy(dataNode, parentNode) {
+      var value = dataNode.value;
+      dimMax = Math.max(dimMax, util.isArray(value) ? value.length : 1);
+      listData.push(dataNode);
+      var node = new TreeNode(model.convertOptionIdName(dataNode.name, ''), tree);
+      parentNode ? addChild(node, parentNode) : tree.root = node;
+      tree._nodes.push(node);
+      var children = dataNode.children;
+      if (children) {
+        for (var i = 0; i < children.length; i++) {
+          buildHierarchy(children[i], node);
+        }
+      }
+    }
+    tree.root.updateDepthAndHeight(0);
+    var dimensions = createDimensions.default(listData, {
+      coordDimensions: ['value'],
+      dimensionsCount: dimMax
+    }).dimensions;
+    var list = new SeriesData.default(dimensions, hostModel);
+    list.initData(listData);
+    beforeLink && beforeLink(list);
+    linkSeriesData.default({
+      mainData: list,
+      struct: tree,
+      structAttr: 'tree'
+    });
+    tree.update();
+    return tree;
+  };
+  return Tree;
+}();
+/**
+ * It is needed to consider the mess of 'list', 'hostModel' when creating a TreeNote,
+ * so this function is not ready and not necessary to be public.
+ */
+function addChild(child, node) {
+  var children = node.children;
+  if (child.parentNode === node) {
+    return;
+  }
+  children.push(child);
+  child.parentNode = node;
+}
+
+exports.TreeNode = TreeNode;
+exports.default = Tree;