@fecp/mobile 1.0.79 → 1.1.1

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/animation/universalTransition.mjs

@@ -0,0 +1,499 @@
+import { SERIES_UNIVERSAL_TRANSITION_PROP } from "../model/Series.mjs";
+import { each, createHashMap, isArray, filter, map, extend } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { applyMorphAnimation, getPathList } from "./morphTransitionHelper.mjs";
+import Path from "../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Path.mjs";
+import "../util/graphic.mjs";
+import DataDiffer from "../data/DataDiffer.mjs";
+import { makeInner, normalizeToArray } from "../util/model.mjs";
+import { getAnimationConfig, initProps, getOldStyle } from "./basicTransition.mjs";
+import Displayable from "../../../../../zrender@5.6.1/node_modules/zrender/lib/graphic/Displayable.mjs";
+var DATA_COUNT_THRESHOLD = 1e4;
+var TRANSITION_NONE = 0;
+var TRANSITION_P2C = 1;
+var TRANSITION_C2P = 2;
+var getUniversalTransitionGlobalStore = makeInner();
+function getDimension(data, visualDimension) {
+  var dimensions = data.dimensions;
+  for (var i = 0; i < dimensions.length; i++) {
+    var dimInfo = data.getDimensionInfo(dimensions[i]);
+    if (dimInfo && dimInfo.otherDims[visualDimension] === 0) {
+      return dimensions[i];
+    }
+  }
+}
+function getValueByDimension(data, dataIndex, dimension) {
+  var dimInfo = data.getDimensionInfo(dimension);
+  var dimOrdinalMeta = dimInfo && dimInfo.ordinalMeta;
+  if (dimInfo) {
+    var value = data.get(dimInfo.name, dataIndex);
+    if (dimOrdinalMeta) {
+      return dimOrdinalMeta.categories[value] || value + "";
+    }
+    return value + "";
+  }
+}
+function getGroupId(data, dataIndex, dataGroupId, isChild) {
+  var visualDimension = isChild ? "itemChildGroupId" : "itemGroupId";
+  var groupIdDim = getDimension(data, visualDimension);
+  if (groupIdDim) {
+    var groupId = getValueByDimension(data, dataIndex, groupIdDim);
+    return groupId;
+  }
+  var rawDataItem = data.getRawDataItem(dataIndex);
+  var property = isChild ? "childGroupId" : "groupId";
+  if (rawDataItem && rawDataItem[property]) {
+    return rawDataItem[property] + "";
+  }
+  if (isChild) {
+    return;
+  }
+  return dataGroupId || data.getId(dataIndex);
+}
+function flattenDataDiffItems(list) {
+  var items = [];
+  each(list, function(seriesInfo) {
+    var data = seriesInfo.data;
+    var dataGroupId = seriesInfo.dataGroupId;
+    if (data.count() > DATA_COUNT_THRESHOLD) {
+      return;
+    }
+    var indices = data.getIndices();
+    for (var dataIndex = 0; dataIndex < indices.length; dataIndex++) {
+      items.push({
+        data,
+        groupId: getGroupId(data, dataIndex, dataGroupId, false),
+        childGroupId: getGroupId(data, dataIndex, dataGroupId, true),
+        divide: seriesInfo.divide,
+        dataIndex
+      });
+    }
+  });
+  return items;
+}
+function fadeInElement(newEl, newSeries, newIndex) {
+  newEl.traverse(function(el) {
+    if (el instanceof Path) {
+      initProps(el, {
+        style: {
+          opacity: 0
+        }
+      }, newSeries, {
+        dataIndex: newIndex,
+        isFrom: true
+      });
+    }
+  });
+}
+function removeEl(el) {
+  if (el.parent) {
+    var computedTransform = el.getComputedTransform();
+    el.setLocalTransform(computedTransform);
+    el.parent.remove(el);
+  }
+}
+function stopAnimation(el) {
+  el.stopAnimation();
+  if (el.isGroup) {
+    el.traverse(function(child) {
+      child.stopAnimation();
+    });
+  }
+}
+function animateElementStyles(el, dataIndex, seriesModel) {
+  var animationConfig = getAnimationConfig("update", seriesModel, dataIndex);
+  animationConfig && el.traverse(function(child) {
+    if (child instanceof Displayable) {
+      var oldStyle = getOldStyle(child);
+      if (oldStyle) {
+        child.animateFrom({
+          style: oldStyle
+        }, animationConfig);
+      }
+    }
+  });
+}
+function isAllIdSame(oldDiffItems, newDiffItems) {
+  var len = oldDiffItems.length;
+  if (len !== newDiffItems.length) {
+    return false;
+  }
+  for (var i = 0; i < len; i++) {
+    var oldItem = oldDiffItems[i];
+    var newItem = newDiffItems[i];
+    if (oldItem.data.getId(oldItem.dataIndex) !== newItem.data.getId(newItem.dataIndex)) {
+      return false;
+    }
+  }
+  return true;
+}
+function transitionBetween(oldList, newList, api) {
+  var oldDiffItems = flattenDataDiffItems(oldList);
+  var newDiffItems = flattenDataDiffItems(newList);
+  function updateMorphingPathProps(from, to, rawFrom, rawTo, animationCfg) {
+    if (rawFrom || from) {
+      to.animateFrom({
+        style: rawFrom && rawFrom !== from ? extend(extend({}, rawFrom.style), from.style) : from.style
+      }, animationCfg);
+    }
+  }
+  var hasMorphAnimation = false;
+  var direction = TRANSITION_NONE;
+  var oldGroupIds = createHashMap();
+  var oldChildGroupIds = createHashMap();
+  oldDiffItems.forEach(function(item) {
+    item.groupId && oldGroupIds.set(item.groupId, true);
+    item.childGroupId && oldChildGroupIds.set(item.childGroupId, true);
+  });
+  for (var i = 0; i < newDiffItems.length; i++) {
+    var newGroupId = newDiffItems[i].groupId;
+    if (oldChildGroupIds.get(newGroupId)) {
+      direction = TRANSITION_P2C;
+      break;
+    }
+    var newChildGroupId = newDiffItems[i].childGroupId;
+    if (newChildGroupId && oldGroupIds.get(newChildGroupId)) {
+      direction = TRANSITION_C2P;
+      break;
+    }
+  }
+  function createKeyGetter(isOld, onlyGetId) {
+    return function(diffItem) {
+      var data = diffItem.data;
+      var dataIndex = diffItem.dataIndex;
+      if (onlyGetId) {
+        return data.getId(dataIndex);
+      }
+      if (isOld) {
+        return direction === TRANSITION_P2C ? diffItem.childGroupId : diffItem.groupId;
+      } else {
+        return direction === TRANSITION_C2P ? diffItem.childGroupId : diffItem.groupId;
+      }
+    };
+  }
+  var useId = isAllIdSame(oldDiffItems, newDiffItems);
+  var isElementStillInChart = {};
+  if (!useId) {
+    for (var i = 0; i < newDiffItems.length; i++) {
+      var newItem = newDiffItems[i];
+      var el = newItem.data.getItemGraphicEl(newItem.dataIndex);
+      if (el) {
+        isElementStillInChart[el.id] = true;
+      }
+    }
+  }
+  function updateOneToOne(newIndex, oldIndex) {
+    var oldItem = oldDiffItems[oldIndex];
+    var newItem2 = newDiffItems[newIndex];
+    var newSeries = newItem2.data.hostModel;
+    var oldEl = oldItem.data.getItemGraphicEl(oldItem.dataIndex);
+    var newEl = newItem2.data.getItemGraphicEl(newItem2.dataIndex);
+    if (oldEl === newEl) {
+      newEl && animateElementStyles(newEl, newItem2.dataIndex, newSeries);
+      return;
+    }
+    if (
+      // We can't use the elements that already being morphed
+      oldEl && isElementStillInChart[oldEl.id]
+    ) {
+      return;
+    }
+    if (newEl) {
+      stopAnimation(newEl);
+      if (oldEl) {
+        stopAnimation(oldEl);
+        removeEl(oldEl);
+        hasMorphAnimation = true;
+        applyMorphAnimation(getPathList(oldEl), getPathList(newEl), newItem2.divide, newSeries, newIndex, updateMorphingPathProps);
+      } else {
+        fadeInElement(newEl, newSeries, newIndex);
+      }
+    }
+  }
+  new DataDiffer(oldDiffItems, newDiffItems, createKeyGetter(true, useId), createKeyGetter(false, useId), null, "multiple").update(updateOneToOne).updateManyToOne(function(newIndex, oldIndices) {
+    var newItem2 = newDiffItems[newIndex];
+    var newData = newItem2.data;
+    var newSeries = newData.hostModel;
+    var newEl = newData.getItemGraphicEl(newItem2.dataIndex);
+    var oldElsList = filter(map(oldIndices, function(idx) {
+      return oldDiffItems[idx].data.getItemGraphicEl(oldDiffItems[idx].dataIndex);
+    }), function(oldEl) {
+      return oldEl && oldEl !== newEl && !isElementStillInChart[oldEl.id];
+    });
+    if (newEl) {
+      stopAnimation(newEl);
+      if (oldElsList.length) {
+        each(oldElsList, function(oldEl) {
+          stopAnimation(oldEl);
+          removeEl(oldEl);
+        });
+        hasMorphAnimation = true;
+        applyMorphAnimation(getPathList(oldElsList), getPathList(newEl), newItem2.divide, newSeries, newIndex, updateMorphingPathProps);
+      } else {
+        fadeInElement(newEl, newSeries, newItem2.dataIndex);
+      }
+    }
+  }).updateOneToMany(function(newIndices, oldIndex) {
+    var oldItem = oldDiffItems[oldIndex];
+    var oldEl = oldItem.data.getItemGraphicEl(oldItem.dataIndex);
+    if (oldEl && isElementStillInChart[oldEl.id]) {
+      return;
+    }
+    var newElsList = filter(map(newIndices, function(idx) {
+      return newDiffItems[idx].data.getItemGraphicEl(newDiffItems[idx].dataIndex);
+    }), function(el2) {
+      return el2 && el2 !== oldEl;
+    });
+    var newSeris = newDiffItems[newIndices[0]].data.hostModel;
+    if (newElsList.length) {
+      each(newElsList, function(newEl) {
+        return stopAnimation(newEl);
+      });
+      if (oldEl) {
+        stopAnimation(oldEl);
+        removeEl(oldEl);
+        hasMorphAnimation = true;
+        applyMorphAnimation(
+          getPathList(oldEl),
+          getPathList(newElsList),
+          oldItem.divide,
+          // Use divide on old.
+          newSeris,
+          newIndices[0],
+          updateMorphingPathProps
+        );
+      } else {
+        each(newElsList, function(newEl) {
+          return fadeInElement(newEl, newSeris, newIndices[0]);
+        });
+      }
+    }
+  }).updateManyToMany(function(newIndices, oldIndices) {
+    new DataDiffer(oldIndices, newIndices, function(rawIdx) {
+      return oldDiffItems[rawIdx].data.getId(oldDiffItems[rawIdx].dataIndex);
+    }, function(rawIdx) {
+      return newDiffItems[rawIdx].data.getId(newDiffItems[rawIdx].dataIndex);
+    }).update(function(newIndex, oldIndex) {
+      updateOneToOne(newIndices[newIndex], oldIndices[oldIndex]);
+    }).execute();
+  }).execute();
+  if (hasMorphAnimation) {
+    each(newList, function(_a) {
+      var data = _a.data;
+      var seriesModel = data.hostModel;
+      var view = seriesModel && api.getViewOfSeriesModel(seriesModel);
+      var animationCfg = getAnimationConfig("update", seriesModel, 0);
+      if (view && seriesModel.isAnimationEnabled() && animationCfg && animationCfg.duration > 0) {
+        view.group.traverse(function(el2) {
+          if (el2 instanceof Path && !el2.animators.length) {
+            el2.animateFrom({
+              style: {
+                opacity: 0
+              }
+            }, animationCfg);
+          }
+        });
+      }
+    });
+  }
+}
+function getSeriesTransitionKey(series) {
+  var seriesKey = series.getModel("universalTransition").get("seriesKey");
+  if (!seriesKey) {
+    return series.id;
+  }
+  return seriesKey;
+}
+function convertArraySeriesKeyToString(seriesKey) {
+  if (isArray(seriesKey)) {
+    return seriesKey.sort().join(",");
+  }
+  return seriesKey;
+}
+function getDivideShapeFromData(data) {
+  if (data.hostModel) {
+    return data.hostModel.getModel("universalTransition").get("divideShape");
+  }
+}
+function findTransitionSeriesBatches(globalStore, params) {
+  var updateBatches = createHashMap();
+  var oldDataMap = createHashMap();
+  var oldDataMapForSplit = createHashMap();
+  each(globalStore.oldSeries, function(series, idx) {
+    var oldDataGroupId = globalStore.oldDataGroupIds[idx];
+    var oldData = globalStore.oldData[idx];
+    var transitionKey = getSeriesTransitionKey(series);
+    var transitionKeyStr = convertArraySeriesKeyToString(transitionKey);
+    oldDataMap.set(transitionKeyStr, {
+      dataGroupId: oldDataGroupId,
+      data: oldData
+    });
+    if (isArray(transitionKey)) {
+      each(transitionKey, function(key) {
+        oldDataMapForSplit.set(key, {
+          key: transitionKeyStr,
+          dataGroupId: oldDataGroupId,
+          data: oldData
+        });
+      });
+    }
+  });
+  each(params.updatedSeries, function(series) {
+    if (series.isUniversalTransitionEnabled() && series.isAnimationEnabled()) {
+      var newDataGroupId = series.get("dataGroupId");
+      var newData = series.getData();
+      var transitionKey = getSeriesTransitionKey(series);
+      var transitionKeyStr = convertArraySeriesKeyToString(transitionKey);
+      var oldData = oldDataMap.get(transitionKeyStr);
+      if (oldData) {
+        updateBatches.set(transitionKeyStr, {
+          oldSeries: [{
+            dataGroupId: oldData.dataGroupId,
+            divide: getDivideShapeFromData(oldData.data),
+            data: oldData.data
+          }],
+          newSeries: [{
+            dataGroupId: newDataGroupId,
+            divide: getDivideShapeFromData(newData),
+            data: newData
+          }]
+        });
+      } else {
+        if (isArray(transitionKey)) {
+          var oldSeries_1 = [];
+          each(transitionKey, function(key) {
+            var oldData2 = oldDataMap.get(key);
+            if (oldData2.data) {
+              oldSeries_1.push({
+                dataGroupId: oldData2.dataGroupId,
+                divide: getDivideShapeFromData(oldData2.data),
+                data: oldData2.data
+              });
+            }
+          });
+          if (oldSeries_1.length) {
+            updateBatches.set(transitionKeyStr, {
+              oldSeries: oldSeries_1,
+              newSeries: [{
+                dataGroupId: newDataGroupId,
+                data: newData,
+                divide: getDivideShapeFromData(newData)
+              }]
+            });
+          }
+        } else {
+          var oldData_1 = oldDataMapForSplit.get(transitionKey);
+          if (oldData_1) {
+            var batch = updateBatches.get(oldData_1.key);
+            if (!batch) {
+              batch = {
+                oldSeries: [{
+                  dataGroupId: oldData_1.dataGroupId,
+                  data: oldData_1.data,
+                  divide: getDivideShapeFromData(oldData_1.data)
+                }],
+                newSeries: []
+              };
+              updateBatches.set(oldData_1.key, batch);
+            }
+            batch.newSeries.push({
+              dataGroupId: newDataGroupId,
+              data: newData,
+              divide: getDivideShapeFromData(newData)
+            });
+          }
+        }
+      }
+    }
+  });
+  return updateBatches;
+}
+function querySeries(series, finder) {
+  for (var i = 0; i < series.length; i++) {
+    var found = finder.seriesIndex != null && finder.seriesIndex === series[i].seriesIndex || finder.seriesId != null && finder.seriesId === series[i].id;
+    if (found) {
+      return i;
+    }
+  }
+}
+function transitionSeriesFromOpt(transitionOpt, globalStore, params, api) {
+  var from = [];
+  var to = [];
+  each(normalizeToArray(transitionOpt.from), function(finder) {
+    var idx = querySeries(globalStore.oldSeries, finder);
+    if (idx >= 0) {
+      from.push({
+        dataGroupId: globalStore.oldDataGroupIds[idx],
+        data: globalStore.oldData[idx],
+        // TODO can specify divideShape in transition.
+        divide: getDivideShapeFromData(globalStore.oldData[idx]),
+        groupIdDim: finder.dimension
+      });
+    }
+  });
+  each(normalizeToArray(transitionOpt.to), function(finder) {
+    var idx = querySeries(params.updatedSeries, finder);
+    if (idx >= 0) {
+      var data = params.updatedSeries[idx].getData();
+      to.push({
+        dataGroupId: globalStore.oldDataGroupIds[idx],
+        data,
+        divide: getDivideShapeFromData(data),
+        groupIdDim: finder.dimension
+      });
+    }
+  });
+  if (from.length > 0 && to.length > 0) {
+    transitionBetween(from, to, api);
+  }
+}
+function installUniversalTransition(registers) {
+  registers.registerUpdateLifecycle("series:beforeupdate", function(ecMOdel, api, params) {
+    each(normalizeToArray(params.seriesTransition), function(transOpt) {
+      each(normalizeToArray(transOpt.to), function(finder) {
+        var series = params.updatedSeries;
+        for (var i = 0; i < series.length; i++) {
+          if (finder.seriesIndex != null && finder.seriesIndex === series[i].seriesIndex || finder.seriesId != null && finder.seriesId === series[i].id) {
+            series[i][SERIES_UNIVERSAL_TRANSITION_PROP] = true;
+          }
+        }
+      });
+    });
+  });
+  registers.registerUpdateLifecycle("series:transition", function(ecModel, api, params) {
+    var globalStore = getUniversalTransitionGlobalStore(api);
+    if (globalStore.oldSeries && params.updatedSeries && params.optionChanged) {
+      var transitionOpt = params.seriesTransition;
+      if (transitionOpt) {
+        each(normalizeToArray(transitionOpt), function(opt) {
+          transitionSeriesFromOpt(opt, globalStore, params, api);
+        });
+      } else {
+        var updateBatches_1 = findTransitionSeriesBatches(globalStore, params);
+        each(updateBatches_1.keys(), function(key) {
+          var batch = updateBatches_1.get(key);
+          transitionBetween(batch.oldSeries, batch.newSeries, api);
+        });
+      }
+      each(params.updatedSeries, function(series) {
+        if (series[SERIES_UNIVERSAL_TRANSITION_PROP]) {
+          series[SERIES_UNIVERSAL_TRANSITION_PROP] = false;
+        }
+      });
+    }
+    var allSeries = ecModel.getSeries();
+    var savedSeries = globalStore.oldSeries = [];
+    var savedDataGroupIds = globalStore.oldDataGroupIds = [];
+    var savedData = globalStore.oldData = [];
+    for (var i = 0; i < allSeries.length; i++) {
+      var data = allSeries[i].getData();
+      if (data.count() < DATA_COUNT_THRESHOLD) {
+        savedSeries.push(allSeries[i]);
+        savedDataGroupIds.push(allSeries[i].get("dataGroupId"));
+        savedData.push(data);
+      }
+    }
+  });
+}
+export {
+  installUniversalTransition
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/chart/bar/BarSeries.mjs

@@ -0,0 +1,66 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import BaseBarSeriesModel from "./BaseBarSeries.mjs";
+import createSeriesData from "../helper/createSeriesData.mjs";
+import { inheritDefaultOption } from "../../util/component.mjs";
+var BarSeriesModel = (
+  /** @class */
+  function(_super) {
+    __extends(BarSeriesModel2, _super);
+    function BarSeriesModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this.type = BarSeriesModel2.type;
+      return _this;
+    }
+    BarSeriesModel2.prototype.getInitialData = function() {
+      return createSeriesData(null, this, {
+        useEncodeDefaulter: true,
+        createInvertedIndices: !!this.get("realtimeSort", true) || null
+      });
+    };
+    BarSeriesModel2.prototype.getProgressive = function() {
+      return this.get("large") ? this.get("progressive") : false;
+    };
+    BarSeriesModel2.prototype.getProgressiveThreshold = function() {
+      var progressiveThreshold = this.get("progressiveThreshold");
+      var largeThreshold = this.get("largeThreshold");
+      if (largeThreshold > progressiveThreshold) {
+        progressiveThreshold = largeThreshold;
+      }
+      return progressiveThreshold;
+    };
+    BarSeriesModel2.prototype.brushSelector = function(dataIndex, data, selectors) {
+      return selectors.rect(data.getItemLayout(dataIndex));
+    };
+    BarSeriesModel2.type = "series.bar";
+    BarSeriesModel2.dependencies = ["grid", "polar"];
+    BarSeriesModel2.defaultOption = inheritDefaultOption(BaseBarSeriesModel.defaultOption, {
+      // If clipped
+      // Only available on cartesian2d
+      clip: true,
+      roundCap: false,
+      showBackground: false,
+      backgroundStyle: {
+        color: "rgba(180, 180, 180, 0.2)",
+        borderColor: null,
+        borderWidth: 0,
+        borderType: "solid",
+        borderRadius: 0,
+        shadowBlur: 0,
+        shadowColor: null,
+        shadowOffsetX: 0,
+        shadowOffsetY: 0,
+        opacity: 1
+      },
+      select: {
+        itemStyle: {
+          borderColor: "#212121"
+        }
+      },
+      realtimeSort: false
+    });
+    return BarSeriesModel2;
+  }(BaseBarSeriesModel)
+);
+export {
+  BarSeriesModel as default
+};