@fecp/mobile 1.0.78 → 1.1.0

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axisPointer/CartesianAxisPointer.mjs

@@ -0,0 +1,105 @@
+import { __extends } from "../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import BaseAxisPointer from "./BaseAxisPointer.mjs";
+import { buildElStyle, buildCartesianSingleLabelElOption, getTransformedPosition, makeRectShape, makeLineShape } from "./viewHelper.mjs";
+import { layout } from "../../coord/cartesian/cartesianAxisHelper.mjs";
+var CartesianAxisPointer = (
+  /** @class */
+  function(_super) {
+    __extends(CartesianAxisPointer2, _super);
+    function CartesianAxisPointer2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CartesianAxisPointer2.prototype.makeElOption = function(elOption, value, axisModel, axisPointerModel, api) {
+      var axis = axisModel.axis;
+      var grid = axis.grid;
+      var axisPointerType = axisPointerModel.get("type");
+      var otherExtent = getCartesian(grid, axis).getOtherAxis(axis).getGlobalExtent();
+      var pixelValue = axis.toGlobalCoord(axis.dataToCoord(value, true));
+      if (axisPointerType && axisPointerType !== "none") {
+        var elStyle = buildElStyle(axisPointerModel);
+        var pointerOption = pointerShapeBuilder[axisPointerType](axis, pixelValue, otherExtent);
+        pointerOption.style = elStyle;
+        elOption.graphicKey = pointerOption.type;
+        elOption.pointer = pointerOption;
+      }
+      var layoutInfo = layout(grid.model, axisModel);
+      buildCartesianSingleLabelElOption(
+        // @ts-ignore
+        value,
+        elOption,
+        layoutInfo,
+        axisModel,
+        axisPointerModel,
+        api
+      );
+    };
+    CartesianAxisPointer2.prototype.getHandleTransform = function(value, axisModel, axisPointerModel) {
+      var layoutInfo = layout(axisModel.axis.grid.model, axisModel, {
+        labelInside: false
+      });
+      layoutInfo.labelMargin = axisPointerModel.get(["handle", "margin"]);
+      var pos = getTransformedPosition(axisModel.axis, value, layoutInfo);
+      return {
+        x: pos[0],
+        y: pos[1],
+        rotation: layoutInfo.rotation + (layoutInfo.labelDirection < 0 ? Math.PI : 0)
+      };
+    };
+    CartesianAxisPointer2.prototype.updateHandleTransform = function(transform, delta, axisModel, axisPointerModel) {
+      var axis = axisModel.axis;
+      var grid = axis.grid;
+      var axisExtent = axis.getGlobalExtent(true);
+      var otherExtent = getCartesian(grid, axis).getOtherAxis(axis).getGlobalExtent();
+      var dimIndex = axis.dim === "x" ? 0 : 1;
+      var currPosition = [transform.x, transform.y];
+      currPosition[dimIndex] += delta[dimIndex];
+      currPosition[dimIndex] = Math.min(axisExtent[1], currPosition[dimIndex]);
+      currPosition[dimIndex] = Math.max(axisExtent[0], currPosition[dimIndex]);
+      var cursorOtherValue = (otherExtent[1] + otherExtent[0]) / 2;
+      var cursorPoint = [cursorOtherValue, cursorOtherValue];
+      cursorPoint[dimIndex] = currPosition[dimIndex];
+      var tooltipOptions = [{
+        verticalAlign: "middle"
+      }, {
+        align: "center"
+      }];
+      return {
+        x: currPosition[0],
+        y: currPosition[1],
+        rotation: transform.rotation,
+        cursorPoint,
+        tooltipOption: tooltipOptions[dimIndex]
+      };
+    };
+    return CartesianAxisPointer2;
+  }(BaseAxisPointer)
+);
+function getCartesian(grid, axis) {
+  var opt = {};
+  opt[axis.dim + "AxisIndex"] = axis.index;
+  return grid.getCartesian(opt);
+}
+var pointerShapeBuilder = {
+  line: function(axis, pixelValue, otherExtent) {
+    var targetShape = makeLineShape([pixelValue, otherExtent[0]], [pixelValue, otherExtent[1]], getAxisDimIndex(axis));
+    return {
+      type: "Line",
+      subPixelOptimize: true,
+      shape: targetShape
+    };
+  },
+  shadow: function(axis, pixelValue, otherExtent) {
+    var bandWidth = Math.max(1, axis.getBandWidth());
+    var span = otherExtent[1] - otherExtent[0];
+    return {
+      type: "Rect",
+      shape: makeRectShape([pixelValue - bandWidth / 2, otherExtent[0]], [bandWidth, span], getAxisDimIndex(axis))
+    };
+  }
+};
+function getAxisDimIndex(axis) {
+  return axis.dim === "x" ? 0 : 1;
+}
+export {
+  CartesianAxisPointer as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axisPointer/axisTrigger.mjs

@@ -0,0 +1,292 @@
+import { makeInner } from "../../util/model.mjs";
+import { makeKey } from "./modelHelper.mjs";
+import findPointFromSeries from "./findPointFromSeries.mjs";
+import { bind, curry, each, extend } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+var inner = makeInner();
+function axisTrigger(payload, ecModel, api) {
+  var currTrigger = payload.currTrigger;
+  var point = [payload.x, payload.y];
+  var finder = payload;
+  var dispatchAction = payload.dispatchAction || bind(api.dispatchAction, api);
+  var coordSysAxesInfo = ecModel.getComponent("axisPointer").coordSysAxesInfo;
+  if (!coordSysAxesInfo) {
+    return;
+  }
+  if (illegalPoint(point)) {
+    point = findPointFromSeries({
+      seriesIndex: finder.seriesIndex,
+      // Do not use dataIndexInside from other ec instance.
+      // FIXME: auto detect it?
+      dataIndex: finder.dataIndex
+    }, ecModel).point;
+  }
+  var isIllegalPoint = illegalPoint(point);
+  var inputAxesInfo = finder.axesInfo;
+  var axesInfo = coordSysAxesInfo.axesInfo;
+  var shouldHide = currTrigger === "leave" || illegalPoint(point);
+  var outputPayload = {};
+  var showValueMap = {};
+  var dataByCoordSys = {
+    list: [],
+    map: {}
+  };
+  var updaters = {
+    showPointer: curry(showPointer, showValueMap),
+    showTooltip: curry(showTooltip, dataByCoordSys)
+  };
+  each(coordSysAxesInfo.coordSysMap, function(coordSys, coordSysKey) {
+    var coordSysContainsPoint = isIllegalPoint || coordSys.containPoint(point);
+    each(coordSysAxesInfo.coordSysAxesInfo[coordSysKey], function(axisInfo, key) {
+      var axis = axisInfo.axis;
+      var inputAxisInfo = findInputAxisInfo(inputAxesInfo, axisInfo);
+      if (!shouldHide && coordSysContainsPoint && (!inputAxesInfo || inputAxisInfo)) {
+        var val = inputAxisInfo && inputAxisInfo.value;
+        if (val == null && !isIllegalPoint) {
+          val = axis.pointToData(point);
+        }
+        val != null && processOnAxis(axisInfo, val, updaters, false, outputPayload);
+      }
+    });
+  });
+  var linkTriggers = {};
+  each(axesInfo, function(tarAxisInfo, tarKey) {
+    var linkGroup = tarAxisInfo.linkGroup;
+    if (linkGroup && !showValueMap[tarKey]) {
+      each(linkGroup.axesInfo, function(srcAxisInfo, srcKey) {
+        var srcValItem = showValueMap[srcKey];
+        if (srcAxisInfo !== tarAxisInfo && srcValItem) {
+          var val = srcValItem.value;
+          linkGroup.mapper && (val = tarAxisInfo.axis.scale.parse(linkGroup.mapper(val, makeMapperParam(srcAxisInfo), makeMapperParam(tarAxisInfo))));
+          linkTriggers[tarAxisInfo.key] = val;
+        }
+      });
+    }
+  });
+  each(linkTriggers, function(val, tarKey) {
+    processOnAxis(axesInfo[tarKey], val, updaters, true, outputPayload);
+  });
+  updateModelActually(showValueMap, axesInfo, outputPayload);
+  dispatchTooltipActually(dataByCoordSys, point, payload, dispatchAction);
+  dispatchHighDownActually(axesInfo, dispatchAction, api);
+  return outputPayload;
+}
+function processOnAxis(axisInfo, newValue, updaters, noSnap, outputFinder) {
+  var axis = axisInfo.axis;
+  if (axis.scale.isBlank() || !axis.containData(newValue)) {
+    return;
+  }
+  if (!axisInfo.involveSeries) {
+    updaters.showPointer(axisInfo, newValue);
+    return;
+  }
+  var payloadInfo = buildPayloadsBySeries(newValue, axisInfo);
+  var payloadBatch = payloadInfo.payloadBatch;
+  var snapToValue = payloadInfo.snapToValue;
+  if (payloadBatch[0] && outputFinder.seriesIndex == null) {
+    extend(outputFinder, payloadBatch[0]);
+  }
+  if (!noSnap && axisInfo.snap) {
+    if (axis.containData(snapToValue) && snapToValue != null) {
+      newValue = snapToValue;
+    }
+  }
+  updaters.showPointer(axisInfo, newValue, payloadBatch);
+  updaters.showTooltip(axisInfo, payloadInfo, snapToValue);
+}
+function buildPayloadsBySeries(value, axisInfo) {
+  var axis = axisInfo.axis;
+  var dim = axis.dim;
+  var snapToValue = value;
+  var payloadBatch = [];
+  var minDist = Number.MAX_VALUE;
+  var minDiff = -1;
+  each(axisInfo.seriesModels, function(series, idx) {
+    var dataDim = series.getData().mapDimensionsAll(dim);
+    var seriesNestestValue;
+    var dataIndices;
+    if (series.getAxisTooltipData) {
+      var result = series.getAxisTooltipData(dataDim, value, axis);
+      dataIndices = result.dataIndices;
+      seriesNestestValue = result.nestestValue;
+    } else {
+      dataIndices = series.getData().indicesOfNearest(
+        dataDim[0],
+        value,
+        // Add a threshold to avoid find the wrong dataIndex
+        // when data length is not same.
+        // false,
+        axis.type === "category" ? 0.5 : null
+      );
+      if (!dataIndices.length) {
+        return;
+      }
+      seriesNestestValue = series.getData().get(dataDim[0], dataIndices[0]);
+    }
+    if (seriesNestestValue == null || !isFinite(seriesNestestValue)) {
+      return;
+    }
+    var diff = value - seriesNestestValue;
+    var dist = Math.abs(diff);
+    if (dist <= minDist) {
+      if (dist < minDist || diff >= 0 && minDiff < 0) {
+        minDist = dist;
+        minDiff = diff;
+        snapToValue = seriesNestestValue;
+        payloadBatch.length = 0;
+      }
+      each(dataIndices, function(dataIndex) {
+        payloadBatch.push({
+          seriesIndex: series.seriesIndex,
+          dataIndexInside: dataIndex,
+          dataIndex: series.getData().getRawIndex(dataIndex)
+        });
+      });
+    }
+  });
+  return {
+    payloadBatch,
+    snapToValue
+  };
+}
+function showPointer(showValueMap, axisInfo, value, payloadBatch) {
+  showValueMap[axisInfo.key] = {
+    value,
+    payloadBatch
+  };
+}
+function showTooltip(dataByCoordSys, axisInfo, payloadInfo, value) {
+  var payloadBatch = payloadInfo.payloadBatch;
+  var axis = axisInfo.axis;
+  var axisModel = axis.model;
+  var axisPointerModel = axisInfo.axisPointerModel;
+  if (!axisInfo.triggerTooltip || !payloadBatch.length) {
+    return;
+  }
+  var coordSysModel = axisInfo.coordSys.model;
+  var coordSysKey = makeKey(coordSysModel);
+  var coordSysItem = dataByCoordSys.map[coordSysKey];
+  if (!coordSysItem) {
+    coordSysItem = dataByCoordSys.map[coordSysKey] = {
+      coordSysId: coordSysModel.id,
+      coordSysIndex: coordSysModel.componentIndex,
+      coordSysType: coordSysModel.type,
+      coordSysMainType: coordSysModel.mainType,
+      dataByAxis: []
+    };
+    dataByCoordSys.list.push(coordSysItem);
+  }
+  coordSysItem.dataByAxis.push({
+    axisDim: axis.dim,
+    axisIndex: axisModel.componentIndex,
+    axisType: axisModel.type,
+    axisId: axisModel.id,
+    value,
+    // Caustion: viewHelper.getValueLabel is actually on "view stage", which
+    // depends that all models have been updated. So it should not be performed
+    // here. Considering axisPointerModel used here is volatile, which is hard
+    // to be retrieve in TooltipView, we prepare parameters here.
+    valueLabelOpt: {
+      precision: axisPointerModel.get(["label", "precision"]),
+      formatter: axisPointerModel.get(["label", "formatter"])
+    },
+    seriesDataIndices: payloadBatch.slice()
+  });
+}
+function updateModelActually(showValueMap, axesInfo, outputPayload) {
+  var outputAxesInfo = outputPayload.axesInfo = [];
+  each(axesInfo, function(axisInfo, key) {
+    var option = axisInfo.axisPointerModel.option;
+    var valItem = showValueMap[key];
+    if (valItem) {
+      !axisInfo.useHandle && (option.status = "show");
+      option.value = valItem.value;
+      option.seriesDataIndices = (valItem.payloadBatch || []).slice();
+    } else {
+      !axisInfo.useHandle && (option.status = "hide");
+    }
+    option.status === "show" && outputAxesInfo.push({
+      axisDim: axisInfo.axis.dim,
+      axisIndex: axisInfo.axis.model.componentIndex,
+      value: option.value
+    });
+  });
+}
+function dispatchTooltipActually(dataByCoordSys, point, payload, dispatchAction) {
+  if (illegalPoint(point) || !dataByCoordSys.list.length) {
+    dispatchAction({
+      type: "hideTip"
+    });
+    return;
+  }
+  var sampleItem = ((dataByCoordSys.list[0].dataByAxis[0] || {}).seriesDataIndices || [])[0] || {};
+  dispatchAction({
+    type: "showTip",
+    escapeConnect: true,
+    x: point[0],
+    y: point[1],
+    tooltipOption: payload.tooltipOption,
+    position: payload.position,
+    dataIndexInside: sampleItem.dataIndexInside,
+    dataIndex: sampleItem.dataIndex,
+    seriesIndex: sampleItem.seriesIndex,
+    dataByCoordSys: dataByCoordSys.list
+  });
+}
+function dispatchHighDownActually(axesInfo, dispatchAction, api) {
+  var zr = api.getZr();
+  var highDownKey = "axisPointerLastHighlights";
+  var lastHighlights = inner(zr)[highDownKey] || {};
+  var newHighlights = inner(zr)[highDownKey] = {};
+  each(axesInfo, function(axisInfo, key) {
+    var option = axisInfo.axisPointerModel.option;
+    option.status === "show" && axisInfo.triggerEmphasis && each(option.seriesDataIndices, function(batchItem) {
+      var key2 = batchItem.seriesIndex + " | " + batchItem.dataIndex;
+      newHighlights[key2] = batchItem;
+    });
+  });
+  var toHighlight = [];
+  var toDownplay = [];
+  each(lastHighlights, function(batchItem, key) {
+    !newHighlights[key] && toDownplay.push(batchItem);
+  });
+  each(newHighlights, function(batchItem, key) {
+    !lastHighlights[key] && toHighlight.push(batchItem);
+  });
+  toDownplay.length && api.dispatchAction({
+    type: "downplay",
+    escapeConnect: true,
+    // Not blur others when highlight in axisPointer.
+    notBlur: true,
+    batch: toDownplay
+  });
+  toHighlight.length && api.dispatchAction({
+    type: "highlight",
+    escapeConnect: true,
+    // Not blur others when highlight in axisPointer.
+    notBlur: true,
+    batch: toHighlight
+  });
+}
+function findInputAxisInfo(inputAxesInfo, axisInfo) {
+  for (var i = 0; i < (inputAxesInfo || []).length; i++) {
+    var inputAxisInfo = inputAxesInfo[i];
+    if (axisInfo.axis.dim === inputAxisInfo.axisDim && axisInfo.axis.model.componentIndex === inputAxisInfo.axisIndex) {
+      return inputAxisInfo;
+    }
+  }
+}
+function makeMapperParam(axisInfo) {
+  var axisModel = axisInfo.axis.model;
+  var item = {};
+  var dim = item.axisDim = axisInfo.axis.dim;
+  item.axisIndex = item[dim + "AxisIndex"] = axisModel.componentIndex;
+  item.axisName = item[dim + "AxisName"] = axisModel.name;
+  item.axisId = item[dim + "AxisId"] = axisModel.id;
+  return item;
+}
+function illegalPoint(point) {
+  return !point || point[0] == null || isNaN(point[0]) || point[1] == null || isNaN(point[1]);
+}
+export {
+  axisTrigger as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axisPointer/findPointFromSeries.mjs

@@ -0,0 +1,52 @@
+import { isArray, map } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { queryDataIndex } from "../../util/model.mjs";
+function findPointFromSeries(finder, ecModel) {
+  var point = [];
+  var seriesIndex = finder.seriesIndex;
+  var seriesModel;
+  if (seriesIndex == null || !(seriesModel = ecModel.getSeriesByIndex(seriesIndex))) {
+    return {
+      point: []
+    };
+  }
+  var data = seriesModel.getData();
+  var dataIndex = queryDataIndex(data, finder);
+  if (dataIndex == null || dataIndex < 0 || isArray(dataIndex)) {
+    return {
+      point: []
+    };
+  }
+  var el = data.getItemGraphicEl(dataIndex);
+  var coordSys = seriesModel.coordinateSystem;
+  if (seriesModel.getTooltipPosition) {
+    point = seriesModel.getTooltipPosition(dataIndex) || [];
+  } else if (coordSys && coordSys.dataToPoint) {
+    if (finder.isStacked) {
+      var baseAxis = coordSys.getBaseAxis();
+      var valueAxis = coordSys.getOtherAxis(baseAxis);
+      var valueAxisDim = valueAxis.dim;
+      var baseAxisDim = baseAxis.dim;
+      var baseDataOffset = valueAxisDim === "x" || valueAxisDim === "radius" ? 1 : 0;
+      var baseDim = data.mapDimension(baseAxisDim);
+      var stackedData = [];
+      stackedData[baseDataOffset] = data.get(baseDim, dataIndex);
+      stackedData[1 - baseDataOffset] = data.get(data.getCalculationInfo("stackResultDimension"), dataIndex);
+      point = coordSys.dataToPoint(stackedData) || [];
+    } else {
+      point = coordSys.dataToPoint(data.getValues(map(coordSys.dimensions, function(dim) {
+        return data.mapDimension(dim);
+      }), dataIndex)) || [];
+    }
+  } else if (el) {
+    var rect = el.getBoundingRect().clone();
+    rect.applyTransform(el.transform);
+    point = [rect.x + rect.width / 2, rect.y + rect.height / 2];
+  }
+  return {
+    point,
+    el
+  };
+}
+export {
+  findPointFromSeries as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axisPointer/globalListener.mjs

@@ -0,0 +1,86 @@
+import { curry, each as each$1 } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import env from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/env.mjs";
+import { makeInner } from "../../util/model.mjs";
+var inner = makeInner();
+var each = each$1;
+function register(key, api, handler) {
+  if (env.node) {
+    return;
+  }
+  var zr = api.getZr();
+  inner(zr).records || (inner(zr).records = {});
+  initGlobalListeners(zr, api);
+  var record = inner(zr).records[key] || (inner(zr).records[key] = {});
+  record.handler = handler;
+}
+function initGlobalListeners(zr, api) {
+  if (inner(zr).initialized) {
+    return;
+  }
+  inner(zr).initialized = true;
+  useHandler("click", curry(doEnter, "click"));
+  useHandler("mousemove", curry(doEnter, "mousemove"));
+  useHandler("globalout", onLeave);
+  function useHandler(eventType, cb) {
+    zr.on(eventType, function(e) {
+      var dis = makeDispatchAction(api);
+      each(inner(zr).records, function(record) {
+        record && cb(record, e, dis.dispatchAction);
+      });
+      dispatchTooltipFinally(dis.pendings, api);
+    });
+  }
+}
+function dispatchTooltipFinally(pendings, api) {
+  var showLen = pendings.showTip.length;
+  var hideLen = pendings.hideTip.length;
+  var actuallyPayload;
+  if (showLen) {
+    actuallyPayload = pendings.showTip[showLen - 1];
+  } else if (hideLen) {
+    actuallyPayload = pendings.hideTip[hideLen - 1];
+  }
+  if (actuallyPayload) {
+    actuallyPayload.dispatchAction = null;
+    api.dispatchAction(actuallyPayload);
+  }
+}
+function onLeave(record, e, dispatchAction) {
+  record.handler("leave", null, dispatchAction);
+}
+function doEnter(currTrigger, record, e, dispatchAction) {
+  record.handler(currTrigger, e, dispatchAction);
+}
+function makeDispatchAction(api) {
+  var pendings = {
+    showTip: [],
+    hideTip: []
+  };
+  var dispatchAction = function(payload) {
+    var pendingList = pendings[payload.type];
+    if (pendingList) {
+      pendingList.push(payload);
+    } else {
+      payload.dispatchAction = dispatchAction;
+      api.dispatchAction(payload);
+    }
+  };
+  return {
+    dispatchAction,
+    pendings
+  };
+}
+function unregister(key, api) {
+  if (env.node) {
+    return;
+  }
+  var zr = api.getZr();
+  var record = (inner(zr).records || {})[key];
+  if (record) {
+    inner(zr).records[key] = null;
+  }
+}
+export {
+  register,
+  unregister
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/component/axisPointer/install.mjs

@@ -0,0 +1,32 @@
+import AxisView from "../axis/AxisView.mjs";
+import CartesianAxisPointer from "./CartesianAxisPointer.mjs";
+import AxisPointerModel from "./AxisPointerModel.mjs";
+import AxisPointerView from "./AxisPointerView.mjs";
+import { isArray } from "../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { collect } from "./modelHelper.mjs";
+import axisTrigger from "./axisTrigger.mjs";
+function install(registers) {
+  AxisView.registerAxisPointerClass("CartesianAxisPointer", CartesianAxisPointer);
+  registers.registerComponentModel(AxisPointerModel);
+  registers.registerComponentView(AxisPointerView);
+  registers.registerPreprocessor(function(option) {
+    if (option) {
+      (!option.axisPointer || option.axisPointer.length === 0) && (option.axisPointer = {});
+      var link = option.axisPointer.link;
+      if (link && !isArray(link)) {
+        option.axisPointer.link = [link];
+      }
+    }
+  });
+  registers.registerProcessor(registers.PRIORITY.PROCESSOR.STATISTIC, function(ecModel, api) {
+    ecModel.getComponent("axisPointer").coordSysAxesInfo = collect(ecModel, api);
+  });
+  registers.registerAction({
+    type: "updateAxisPointer",
+    event: "updateAxisPointer",
+    update: ":updateAxisPointer"
+  }, axisTrigger);
+}
+export {
+  install
+};