@fmdevui/fm-dev 1.0.112 → 1.0.114

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/radar/RadarModel.mjs

@@ -0,0 +1,119 @@
+import { __extends } from '../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import { defaults, map, merge, clone, isString, isFunction, mixin } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import axisDefault from '../axisDefault.mjs';
+import Model from '../../model/Model.mjs';
+import { AxisModelCommonMixin } from '../axisModelCommonMixin.mjs';
+import ComponentModel from '../../model/Component.mjs';
+import tokens from '../../visual/tokens.mjs';
+
+var valueAxisDefault = axisDefault.value;
+function defaultsShow(opt, show) {
+  return defaults({
+    show: show
+  }, opt);
+}
+var RadarModel = /** @class */function (_super) {
+  __extends(RadarModel, _super);
+  function RadarModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = RadarModel.type;
+    return _this;
+  }
+  RadarModel.prototype.optionUpdated = function () {
+    var boundaryGap = this.get('boundaryGap');
+    var splitNumber = this.get('splitNumber');
+    var scale = this.get('scale');
+    var axisLine = this.get('axisLine');
+    var axisTick = this.get('axisTick');
+    // let axisType = this.get('axisType');
+    var axisLabel = this.get('axisLabel');
+    var nameTextStyle = this.get('axisName');
+    var showName = this.get(['axisName', 'show']);
+    var nameFormatter = this.get(['axisName', 'formatter']);
+    var nameGap = this.get('axisNameGap');
+    var triggerEvent = this.get('triggerEvent');
+    var indicatorModels = map(this.get('indicator') || [], function (indicatorOpt) {
+      // PENDING
+      if (indicatorOpt.max != null && indicatorOpt.max > 0 && !indicatorOpt.min) {
+        indicatorOpt.min = 0;
+      } else if (indicatorOpt.min != null && indicatorOpt.min < 0 && !indicatorOpt.max) {
+        indicatorOpt.max = 0;
+      }
+      var iNameTextStyle = nameTextStyle;
+      if (indicatorOpt.color != null) {
+        iNameTextStyle = defaults({
+          color: indicatorOpt.color
+        }, nameTextStyle);
+      }
+      // Use same configuration
+      var innerIndicatorOpt = merge(clone(indicatorOpt), {
+        boundaryGap: boundaryGap,
+        splitNumber: splitNumber,
+        scale: scale,
+        axisLine: axisLine,
+        axisTick: axisTick,
+        // axisType: axisType,
+        axisLabel: axisLabel,
+        // Compatible with 2 and use text
+        name: indicatorOpt.text,
+        showName: showName,
+        nameLocation: 'end',
+        nameGap: nameGap,
+        // min: 0,
+        nameTextStyle: iNameTextStyle,
+        triggerEvent: triggerEvent
+      }, false);
+      if (isString(nameFormatter)) {
+        var indName = innerIndicatorOpt.name;
+        innerIndicatorOpt.name = nameFormatter.replace('{value}', indName != null ? indName : '');
+      } else if (isFunction(nameFormatter)) {
+        innerIndicatorOpt.name = nameFormatter(innerIndicatorOpt.name, innerIndicatorOpt);
+      }
+      var model = new Model(innerIndicatorOpt, null, this.ecModel);
+      mixin(model, AxisModelCommonMixin.prototype);
+      // For triggerEvent.
+      model.mainType = 'radar';
+      model.componentIndex = this.componentIndex;
+      return model;
+    }, this);
+    this._indicatorModels = indicatorModels;
+  };
+  RadarModel.prototype.getIndicatorModels = function () {
+    return this._indicatorModels;
+  };
+  RadarModel.type = 'radar';
+  RadarModel.defaultOption = {
+    // zlevel: 0,
+    z: 0,
+    center: ['50%', '50%'],
+    radius: '50%',
+    startAngle: 90,
+    axisName: {
+      show: true,
+      color: tokens.color.axisLabel
+      // formatter: null
+      // textStyle: {}
+    },
+    boundaryGap: [0, 0],
+    splitNumber: 5,
+    axisNameGap: 15,
+    scale: false,
+    // Polygon or circle
+    shape: 'polygon',
+    axisLine: merge({
+      lineStyle: {
+        color: tokens.color.neutral20
+      }
+    }, valueAxisDefault.axisLine),
+    axisLabel: defaultsShow(valueAxisDefault.axisLabel, false),
+    axisTick: defaultsShow(valueAxisDefault.axisTick, false),
+    // axisType: 'value',
+    splitLine: defaultsShow(valueAxisDefault.splitLine, true),
+    splitArea: defaultsShow(valueAxisDefault.splitArea, true),
+    // {text, min, max}
+    indicator: []
+  };
+  return RadarModel;
+}(ComponentModel);
+
+export { RadarModel as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/scaleRawExtentInfo.mjs

@@ -0,0 +1,202 @@
+import { isFunction, isArray, eqNaN, assert } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { parsePercent } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/contain/text.mjs';
+
+var ScaleRawExtentInfo = /** @class */function () {
+  function ScaleRawExtentInfo(scale, model,
+  // Usually: data extent from all series on this axis.
+  originalExtent) {
+    this._prepareParams(scale, model, originalExtent);
+  }
+  /**
+   * Parameters depending on outside (like model, user callback)
+   * are prepared and fixed here.
+   */
+  ScaleRawExtentInfo.prototype._prepareParams = function (scale, model,
+  // Usually: data extent from all series on this axis.
+  dataExtent) {
+    if (dataExtent[1] < dataExtent[0]) {
+      dataExtent = [NaN, NaN];
+    }
+    this._dataMin = dataExtent[0];
+    this._dataMax = dataExtent[1];
+    var isOrdinal = this._isOrdinal = scale.type === 'ordinal';
+    this._needCrossZero = scale.type === 'interval' && model.getNeedCrossZero && model.getNeedCrossZero();
+    var axisMinValue = model.get('min', true);
+    if (axisMinValue == null) {
+      axisMinValue = model.get('startValue', true);
+    }
+    var modelMinRaw = this._modelMinRaw = axisMinValue;
+    if (isFunction(modelMinRaw)) {
+      // This callback always provides users the full data extent (before data is filtered).
+      this._modelMinNum = parseAxisModelMinMax(scale, modelMinRaw({
+        min: dataExtent[0],
+        max: dataExtent[1]
+      }));
+    } else if (modelMinRaw !== 'dataMin') {
+      this._modelMinNum = parseAxisModelMinMax(scale, modelMinRaw);
+    }
+    var modelMaxRaw = this._modelMaxRaw = model.get('max', true);
+    if (isFunction(modelMaxRaw)) {
+      // This callback always provides users the full data extent (before data is filtered).
+      this._modelMaxNum = parseAxisModelMinMax(scale, modelMaxRaw({
+        min: dataExtent[0],
+        max: dataExtent[1]
+      }));
+    } else if (modelMaxRaw !== 'dataMax') {
+      this._modelMaxNum = parseAxisModelMinMax(scale, modelMaxRaw);
+    }
+    if (isOrdinal) {
+      // FIXME: there is a flaw here: if there is no "block" data processor like `dataZoom`,
+      // and progressive rendering is using, here the category result might just only contain
+      // the processed chunk rather than the entire result.
+      this._axisDataLen = model.getCategories().length;
+    } else {
+      var boundaryGap = model.get('boundaryGap');
+      var boundaryGapArr = isArray(boundaryGap) ? boundaryGap : [boundaryGap || 0, boundaryGap || 0];
+      if (typeof boundaryGapArr[0] === 'boolean' || typeof boundaryGapArr[1] === 'boolean') {
+        if (process.env.NODE_ENV !== 'production') {
+          console.warn('Boolean type for boundaryGap is only ' + 'allowed for ordinal axis. Please use string in ' + 'percentage instead, e.g., "20%". Currently, ' + 'boundaryGap is set to be 0.');
+        }
+        this._boundaryGapInner = [0, 0];
+      } else {
+        this._boundaryGapInner = [parsePercent(boundaryGapArr[0], 1), parsePercent(boundaryGapArr[1], 1)];
+      }
+    }
+  };
+  /**
+   * Calculate extent by prepared parameters.
+   * This method has no external dependency and can be called duplicatedly,
+   * getting the same result.
+   * If parameters changed, should call this method to recalcuate.
+   */
+  ScaleRawExtentInfo.prototype.calculate = function () {
+    // Notice: When min/max is not set (that is, when there are null/undefined,
+    // which is the most common case), these cases should be ensured:
+    // (1) For 'ordinal', show all axis.data.
+    // (2) For others:
+    //      + `boundaryGap` is applied (if min/max set, boundaryGap is
+    //      disabled).
+    //      + If `needCrossZero`, min/max should be zero, otherwise, min/max should
+    //      be the result that originalExtent enlarged by boundaryGap.
+    // (3) If no data, it should be ensured that `scale.setBlank` is set.
+    var isOrdinal = this._isOrdinal;
+    var dataMin = this._dataMin;
+    var dataMax = this._dataMax;
+    var axisDataLen = this._axisDataLen;
+    var boundaryGapInner = this._boundaryGapInner;
+    var span = !isOrdinal ? dataMax - dataMin || Math.abs(dataMin) : null;
+    // Currently if a `'value'` axis model min is specified as 'dataMin'/'dataMax',
+    // `boundaryGap` will not be used. It's the different from specifying as `null`/`undefined`.
+    var min = this._modelMinRaw === 'dataMin' ? dataMin : this._modelMinNum;
+    var max = this._modelMaxRaw === 'dataMax' ? dataMax : this._modelMaxNum;
+    // If `_modelMinNum`/`_modelMaxNum` is `null`/`undefined`, should not be fixed.
+    var minFixed = min != null;
+    var maxFixed = max != null;
+    if (min == null) {
+      min = isOrdinal ? axisDataLen ? 0 : NaN : dataMin - boundaryGapInner[0] * span;
+    }
+    if (max == null) {
+      max = isOrdinal ? axisDataLen ? axisDataLen - 1 : NaN : dataMax + boundaryGapInner[1] * span;
+    }
+    (min == null || !isFinite(min)) && (min = NaN);
+    (max == null || !isFinite(max)) && (max = NaN);
+    var isBlank = eqNaN(min) || eqNaN(max) || isOrdinal && !axisDataLen;
+    // If data extent modified, need to recalculated to ensure cross zero.
+    if (this._needCrossZero) {
+      // Axis is over zero and min is not set
+      if (min > 0 && max > 0 && !minFixed) {
+        min = 0;
+        // minFixed = true;
+      }
+      // Axis is under zero and max is not set
+      if (min < 0 && max < 0 && !maxFixed) {
+        max = 0;
+        // maxFixed = true;
+      }
+      // PENDING:
+      // When `needCrossZero` and all data is positive/negative, should it be ensured
+      // that the results processed by boundaryGap are positive/negative?
+      // If so, here `minFixed`/`maxFixed` need to be set.
+    }
+    var determinedMin = this._determinedMin;
+    var determinedMax = this._determinedMax;
+    if (determinedMin != null) {
+      min = determinedMin;
+      minFixed = true;
+    }
+    if (determinedMax != null) {
+      max = determinedMax;
+      maxFixed = true;
+    }
+    // Ensure min/max be finite number or NaN here. (not to be null/undefined)
+    // `NaN` means min/max axis is blank.
+    return {
+      min: min,
+      max: max,
+      minFixed: minFixed,
+      maxFixed: maxFixed,
+      isBlank: isBlank
+    };
+  };
+  ScaleRawExtentInfo.prototype.modifyDataMinMax = function (minMaxName, val) {
+    if (process.env.NODE_ENV !== 'production') {
+      assert(!this.frozen);
+    }
+    this[DATA_MIN_MAX_ATTR[minMaxName]] = val;
+  };
+  ScaleRawExtentInfo.prototype.setDeterminedMinMax = function (minMaxName, val) {
+    var attr = DETERMINED_MIN_MAX_ATTR[minMaxName];
+    if (process.env.NODE_ENV !== 'production') {
+      assert(!this.frozen
+      // Earse them usually means logic flaw.
+      && this[attr] == null);
+    }
+    this[attr] = val;
+  };
+  ScaleRawExtentInfo.prototype.freeze = function () {
+    // @ts-ignore
+    this.frozen = true;
+  };
+  return ScaleRawExtentInfo;
+}();
+var DETERMINED_MIN_MAX_ATTR = {
+  min: '_determinedMin',
+  max: '_determinedMax'
+};
+var DATA_MIN_MAX_ATTR = {
+  min: '_dataMin',
+  max: '_dataMax'
+};
+/**
+ * Get scale min max and related info only depends on model settings.
+ * This method can be called after coordinate system created.
+ * For example, in data processing stage.
+ *
+ * Scale extent info probably be required multiple times during a workflow.
+ * For example:
+ * (1) `dataZoom` depends it to get the axis extent in "100%" state.
+ * (2) `processor/extentCalculator` depends it to make sure whether axis extent is specified.
+ * (3) `coordSys.update` use it to finally decide the scale extent.
+ * But the callback of `min`/`max` should not be called multiple times.
+ * The code below should not be implemented repeatedly either.
+ * So we cache the result in the scale instance, which will be recreated at the beginning
+ * of the workflow (because `scale` instance will be recreated each round of the workflow).
+ */
+function ensureScaleRawExtentInfo(scale, model,
+// Usually: data extent from all series on this axis.
+originalExtent) {
+  // Do not permit to recreate.
+  var rawExtentInfo = scale.rawExtentInfo;
+  if (rawExtentInfo) {
+    return rawExtentInfo;
+  }
+  rawExtentInfo = new ScaleRawExtentInfo(scale, model, originalExtent);
+  // @ts-ignore
+  scale.rawExtentInfo = rawExtentInfo;
+  return rawExtentInfo;
+}
+function parseAxisModelMinMax(scale, minMax) {
+  return minMax == null ? null : eqNaN(minMax) ? NaN : scale.parse(minMax);
+}
+
+export { ScaleRawExtentInfo, ensureScaleRawExtentInfo, parseAxisModelMinMax };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/single/AxisModel.mjs

@@ -0,0 +1,65 @@
+import { __extends } from '../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import ComponentModel from '../../model/Component.mjs';
+import { AxisModelCommonMixin } from '../axisModelCommonMixin.mjs';
+import { mixin } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+var SingleAxisModel = /** @class */function (_super) {
+  __extends(SingleAxisModel, _super);
+  function SingleAxisModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = SingleAxisModel.type;
+    return _this;
+  }
+  SingleAxisModel.prototype.getCoordSysModel = function () {
+    return this;
+  };
+  SingleAxisModel.type = 'singleAxis';
+  SingleAxisModel.layoutMode = 'box';
+  SingleAxisModel.defaultOption = {
+    left: '5%',
+    top: '5%',
+    right: '5%',
+    bottom: '5%',
+    type: 'value',
+    position: 'bottom',
+    orient: 'horizontal',
+    axisLine: {
+      show: true,
+      lineStyle: {
+        width: 1,
+        type: 'solid'
+      }
+    },
+    // Single coordinate system and single axis is the,
+    // which is used as the parent tooltip model.
+    // same model, so we set default tooltip show as true.
+    tooltip: {
+      show: true
+    },
+    axisTick: {
+      show: true,
+      length: 6,
+      lineStyle: {
+        width: 1
+      }
+    },
+    axisLabel: {
+      show: true,
+      interval: 'auto'
+    },
+    splitLine: {
+      show: true,
+      lineStyle: {
+        type: 'dashed',
+        opacity: 0.2
+      }
+    },
+    jitter: 0,
+    jitterOverlap: true,
+    jitterMargin: 2
+  };
+  return SingleAxisModel;
+}(ComponentModel);
+mixin(SingleAxisModel, AxisModelCommonMixin.prototype);
+
+export { SingleAxisModel as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/single/Single.mjs

@@ -0,0 +1,159 @@
+import SingleAxis from './SingleAxis.mjs';
+import { createScaleByModel, niceScaleExtent } from '../axisHelper.mjs';
+import { createBoxLayoutReference, getLayoutRect } from '../../util/layout.mjs';
+import { each } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+var singleDimensions = ['single'];
+/**
+ * Create a single coordinates system.
+ */
+var Single = /** @class */function () {
+  function Single(axisModel, ecModel, api) {
+    this.type = 'single';
+    this.dimension = 'single';
+    /**
+     * Add it just for draw tooltip.
+     */
+    this.dimensions = singleDimensions;
+    this.axisPointerEnabled = true;
+    this.model = axisModel;
+    this._init(axisModel, ecModel, api);
+  }
+  /**
+   * Initialize single coordinate system.
+   */
+  Single.prototype._init = function (axisModel, ecModel, api) {
+    var dim = this.dimension;
+    var axis = new SingleAxis(dim, createScaleByModel(axisModel), [0, 0], axisModel.get('type'), axisModel.get('position'));
+    var isCategory = axis.type === 'category';
+    axis.onBand = isCategory && axisModel.get('boundaryGap');
+    axis.inverse = axisModel.get('inverse');
+    axis.orient = axisModel.get('orient');
+    axisModel.axis = axis;
+    axis.model = axisModel;
+    axis.coordinateSystem = this;
+    this._axis = axis;
+  };
+  /**
+   * Update axis scale after data processed
+   */
+  Single.prototype.update = function (ecModel, api) {
+    ecModel.eachSeries(function (seriesModel) {
+      if (seriesModel.coordinateSystem === this) {
+        var data_1 = seriesModel.getData();
+        each(data_1.mapDimensionsAll(this.dimension), function (dim) {
+          this._axis.scale.unionExtentFromData(data_1, dim);
+        }, this);
+        niceScaleExtent(this._axis.scale, this._axis.model);
+      }
+    }, this);
+  };
+  /**
+   * Resize the single coordinate system.
+   */
+  Single.prototype.resize = function (axisModel, api) {
+    var refContainer = createBoxLayoutReference(axisModel, api).refContainer;
+    this._rect = getLayoutRect(axisModel.getBoxLayoutParams(), refContainer);
+    this._adjustAxis();
+  };
+  Single.prototype.getRect = function () {
+    return this._rect;
+  };
+  Single.prototype._adjustAxis = function () {
+    var rect = this._rect;
+    var axis = this._axis;
+    var isHorizontal = axis.isHorizontal();
+    var extent = isHorizontal ? [0, rect.width] : [0, rect.height];
+    var idx = axis.inverse ? 1 : 0;
+    axis.setExtent(extent[idx], extent[1 - idx]);
+    this._updateAxisTransform(axis, isHorizontal ? rect.x : rect.y);
+  };
+  Single.prototype._updateAxisTransform = function (axis, coordBase) {
+    var axisExtent = axis.getExtent();
+    var extentSum = axisExtent[0] + axisExtent[1];
+    var isHorizontal = axis.isHorizontal();
+    axis.toGlobalCoord = isHorizontal ? function (coord) {
+      return coord + coordBase;
+    } : function (coord) {
+      return extentSum - coord + coordBase;
+    };
+    axis.toLocalCoord = isHorizontal ? function (coord) {
+      return coord - coordBase;
+    } : function (coord) {
+      return extentSum - coord + coordBase;
+    };
+  };
+  /**
+   * Get axis.
+   */
+  Single.prototype.getAxis = function () {
+    return this._axis;
+  };
+  /**
+   * Get axis, add it just for draw tooltip.
+   */
+  Single.prototype.getBaseAxis = function () {
+    return this._axis;
+  };
+  Single.prototype.getAxes = function () {
+    return [this._axis];
+  };
+  Single.prototype.getTooltipAxes = function () {
+    return {
+      baseAxes: [this.getAxis()],
+      // Empty otherAxes
+      otherAxes: []
+    };
+  };
+  /**
+   * If contain point.
+   */
+  Single.prototype.containPoint = function (point) {
+    var rect = this.getRect();
+    var axis = this.getAxis();
+    var orient = axis.orient;
+    if (orient === 'horizontal') {
+      return axis.contain(axis.toLocalCoord(point[0])) && point[1] >= rect.y && point[1] <= rect.y + rect.height;
+    } else {
+      return axis.contain(axis.toLocalCoord(point[1])) && point[0] >= rect.y && point[0] <= rect.y + rect.height;
+    }
+  };
+  Single.prototype.pointToData = function (point, reserved, out) {
+    out = out || [];
+    var axis = this.getAxis();
+    out[0] = axis.coordToData(axis.toLocalCoord(point[axis.orient === 'horizontal' ? 0 : 1]));
+    return out;
+  };
+  /**
+   * Convert the series data to concrete point.
+   * Can be [val] | val
+   */
+  Single.prototype.dataToPoint = function (val, reserved, out) {
+    var axis = this.getAxis();
+    var rect = this.getRect();
+    out = out || [];
+    var idx = axis.orient === 'horizontal' ? 0 : 1;
+    if (val instanceof Array) {
+      val = val[0];
+    }
+    out[idx] = axis.toGlobalCoord(axis.dataToCoord(+val));
+    out[1 - idx] = idx === 0 ? rect.y + rect.height / 2 : rect.x + rect.width / 2;
+    return out;
+  };
+  Single.prototype.convertToPixel = function (ecModel, finder, value) {
+    var coordSys = getCoordSys(finder);
+    return coordSys === this ? this.dataToPoint(value) : null;
+  };
+  Single.prototype.convertFromPixel = function (ecModel, finder, pixel) {
+    var coordSys = getCoordSys(finder);
+    return coordSys === this ? this.pointToData(pixel) : null;
+  };
+  return Single;
+}();
+function getCoordSys(finder) {
+  var seriesModel = finder.seriesModel;
+  var singleModel = finder.singleAxisModel;
+  return singleModel && singleModel.coordinateSystem || seriesModel && seriesModel.coordinateSystem;
+}
+
+export { Single as default, singleDimensions };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/single/SingleAxis.mjs

@@ -0,0 +1,25 @@
+import { __extends } from '../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs';
+import Axis from '../Axis.mjs';
+
+var SingleAxis = /** @class */function (_super) {
+  __extends(SingleAxis, _super);
+  function SingleAxis(dim, scale, coordExtent, axisType, position) {
+    var _this = _super.call(this, dim, scale, coordExtent) || this;
+    _this.type = axisType || 'value';
+    _this.position = position || 'bottom';
+    return _this;
+  }
+  /**
+   * Judge the orient of the axis.
+   */
+  SingleAxis.prototype.isHorizontal = function () {
+    var position = this.position;
+    return position === 'top' || position === 'bottom';
+  };
+  SingleAxis.prototype.pointToData = function (point, clamp) {
+    return this.coordinateSystem.pointToData(point)[0];
+  };
+  return SingleAxis;
+}(Axis);
+
+export { SingleAxis as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/single/prepareCustom.mjs

@@ -0,0 +1,30 @@
+import { bind } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+function dataToCoordSize(dataSize, dataItem) {
+  // dataItem is necessary in log axis.
+  var axis = this.getAxis();
+  var val = dataItem instanceof Array ? dataItem[0] : dataItem;
+  var halfSize = (dataSize instanceof Array ? dataSize[0] : dataSize) / 2;
+  return axis.type === 'category' ? axis.getBandWidth() : Math.abs(axis.dataToCoord(val - halfSize) - axis.dataToCoord(val + halfSize));
+}
+function singlePrepareCustom(coordSys) {
+  var rect = coordSys.getRect();
+  return {
+    coordSys: {
+      type: 'singleAxis',
+      x: rect.x,
+      y: rect.y,
+      width: rect.width,
+      height: rect.height
+    },
+    api: {
+      coord: function (val) {
+        // do not provide "out" param
+        return coordSys.dataToPoint(val);
+      },
+      size: bind(dataToCoordSize, coordSys)
+    }
+  };
+}
+
+export { singlePrepareCustom as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/single/singleAxisHelper.mjs

@@ -0,0 +1,47 @@
+import { retrieve } from '../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+function layout(axisModel, opt) {
+  opt = opt || {};
+  var single = axisModel.coordinateSystem;
+  var axis = axisModel.axis;
+  var layout = {};
+  var axisPosition = axis.position;
+  var orient = axis.orient;
+  var rect = single.getRect();
+  var rectBound = [rect.x, rect.x + rect.width, rect.y, rect.y + rect.height];
+  var positionMap = {
+    horizontal: {
+      top: rectBound[2],
+      bottom: rectBound[3]
+    },
+    vertical: {
+      left: rectBound[0],
+      right: rectBound[1]
+    }
+  };
+  layout.position = [orient === 'vertical' ? positionMap.vertical[axisPosition] : rectBound[0], orient === 'horizontal' ? positionMap.horizontal[axisPosition] : rectBound[3]];
+  var r = {
+    horizontal: 0,
+    vertical: 1
+  };
+  layout.rotation = Math.PI / 2 * r[orient];
+  var directionMap = {
+    top: -1,
+    bottom: 1,
+    right: 1,
+    left: -1
+  };
+  layout.labelDirection = layout.tickDirection = layout.nameDirection = directionMap[axisPosition];
+  if (axisModel.get(['axisTick', 'inside'])) {
+    layout.tickDirection = -layout.tickDirection;
+  }
+  if (retrieve(opt.labelInside, axisModel.get(['axisLabel', 'inside']))) {
+    layout.labelDirection = -layout.labelDirection;
+  }
+  var labelRotate = axisModel.get(['axisLabel', 'rotate']);
+  layout.labelRotate = axisPosition === 'top' ? -labelRotate : labelRotate;
+  layout.z2 = 1;
+  return layout;
+}
+
+export { layout };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/single/singleCreator.mjs

@@ -0,0 +1,29 @@
+import Single, { singleDimensions } from './Single.mjs';
+import { SINGLE_REFERRING } from '../../util/model.mjs';
+
+/**
+ * Create single coordinate system and inject it into seriesModel.
+ */
+function create(ecModel, api) {
+  var singles = [];
+  ecModel.eachComponent('singleAxis', function (axisModel, idx) {
+    var single = new Single(axisModel, ecModel, api);
+    single.name = 'single_' + idx;
+    single.resize(axisModel, api);
+    axisModel.coordinateSystem = single;
+    singles.push(single);
+  });
+  ecModel.eachSeries(function (seriesModel) {
+    if (seriesModel.get('coordinateSystem') === 'singleAxis') {
+      var singleAxisModel = seriesModel.getReferringComponents('singleAxis', SINGLE_REFERRING).models[0];
+      seriesModel.coordinateSystem = singleAxisModel && singleAxisModel.coordinateSystem;
+    }
+  });
+  return singles;
+}
+var singleCreator = {
+  create: create,
+  dimensions: singleDimensions
+};
+
+export { singleCreator as default };