@fmdevui/fm-dev 1.0.113 → 1.0.114

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/axisAlignTicks.js

@@ -0,0 +1,99 @@
+'use strict';
+
+var number = require('../util/number.js');
+var Interval = require('../scale/Interval.js');
+var axisHelper = require('./axisHelper.js');
+var log = require('../util/log.js');
+var helper = require('../scale/helper.js');
+
+function alignScaleTicks(scale, axisModel, alignToScale) {
+  var _a;
+  var intervalScaleProto = Interval.default.prototype;
+  // NOTE: There is a precondition for log scale  here:
+  // In log scale we store _interval and _extent of exponent value.
+  // So if we use the method of InternalScale to set/get these data.
+  // It process the exponent value, which is linear and what we want here.
+  var alignToTicks = intervalScaleProto.getTicks.call(alignToScale);
+  var alignToNicedTicks = intervalScaleProto.getTicks.call(alignToScale, {
+    expandToNicedExtent: true
+  });
+  var alignToSplitNumber = alignToTicks.length - 1;
+  var alignToInterval = intervalScaleProto.getInterval.call(alignToScale);
+  var scaleExtent = axisHelper.getScaleExtent(scale, axisModel);
+  var rawExtent = scaleExtent.extent;
+  var isMinFixed = scaleExtent.fixMin;
+  var isMaxFixed = scaleExtent.fixMax;
+  if (scale.type === 'log') {
+    rawExtent = helper.logTransform(scale.base, rawExtent, true);
+  }
+  scale.setBreaksFromOption(axisHelper.retrieveAxisBreaksOption(axisModel));
+  scale.setExtent(rawExtent[0], rawExtent[1]);
+  scale.calcNiceExtent({
+    splitNumber: alignToSplitNumber,
+    fixMin: isMinFixed,
+    fixMax: isMaxFixed
+  });
+  var extent = intervalScaleProto.getExtent.call(scale);
+  // Need to update the rawExtent.
+  // Because value in rawExtent may be not parsed. e.g. 'dataMin', 'dataMax'
+  if (isMinFixed) {
+    rawExtent[0] = extent[0];
+  }
+  if (isMaxFixed) {
+    rawExtent[1] = extent[1];
+  }
+  var interval = intervalScaleProto.getInterval.call(scale);
+  var min = rawExtent[0];
+  var max = rawExtent[1];
+  if (isMinFixed && isMaxFixed) {
+    // User set min, max, divide to get new interval
+    interval = (max - min) / alignToSplitNumber;
+  } else if (isMinFixed) {
+    max = rawExtent[0] + interval * alignToSplitNumber;
+    // User set min, expand extent on the other side
+    while (max < rawExtent[1] && isFinite(max) && isFinite(rawExtent[1])) {
+      interval = helper.increaseInterval(interval);
+      max = rawExtent[0] + interval * alignToSplitNumber;
+    }
+  } else if (isMaxFixed) {
+    // User set max, expand extent on the other side
+    min = rawExtent[1] - interval * alignToSplitNumber;
+    while (min > rawExtent[0] && isFinite(min) && isFinite(rawExtent[0])) {
+      interval = helper.increaseInterval(interval);
+      min = rawExtent[1] - interval * alignToSplitNumber;
+    }
+  } else {
+    var nicedSplitNumber = scale.getTicks().length - 1;
+    if (nicedSplitNumber > alignToSplitNumber) {
+      interval = helper.increaseInterval(interval);
+    }
+    var range = interval * alignToSplitNumber;
+    max = Math.ceil(rawExtent[1] / interval) * interval;
+    min = number.round(max - range);
+    // Not change the result that crossing zero.
+    if (min < 0 && rawExtent[0] >= 0) {
+      min = 0;
+      max = number.round(range);
+    } else if (max > 0 && rawExtent[1] <= 0) {
+      max = 0;
+      min = -number.round(range);
+    }
+  }
+  // Adjust min, max based on the extent of alignTo. When min or max is set in alignTo scale
+  var t0 = (alignToTicks[0].value - alignToNicedTicks[0].value) / alignToInterval;
+  var t1 = (alignToTicks[alignToSplitNumber].value - alignToNicedTicks[alignToSplitNumber].value) / alignToInterval;
+  // NOTE: Must in setExtent -> setInterval -> setNiceExtent order.
+  intervalScaleProto.setExtent.call(scale, min + interval * t0, max + interval * t1);
+  intervalScaleProto.setInterval.call(scale, interval);
+  if (t0 || t1) {
+    intervalScaleProto.setNiceExtent.call(scale, min + interval, max - interval);
+  }
+  if (process.env.NODE_ENV !== 'production') {
+    var ticks = intervalScaleProto.getTicks.call(scale);
+    if (ticks[1] && (!helper.isValueNice(interval) || number.getPrecisionSafe(ticks[1].value) > number.getPrecisionSafe(interval))) {
+      log.warn("The ticks may be not readable when set min: " + axisModel.get('min') + ", max: " + axisModel.get('max') + (" and alignTicks: true. (" + ((_a = axisModel.axis) === null || _a === void 0 ? void 0 : _a.dim) + "AxisIndex: " + axisModel.componentIndex + ")"), true);
+    }
+  }
+}
+
+exports.alignScaleTicks = alignScaleTicks;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/axisCommonTypes.js

@@ -0,0 +1,52 @@
+'use strict';
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+
+/**
+ * AUTO-GENERATED FILE. DO NOT MODIFY.
+ */
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+var AXIS_TYPES = {
+  value: 1,
+  category: 1,
+  time: 1,
+  log: 1
+};
+
+exports.AXIS_TYPES = AXIS_TYPES;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/axisDefault.js

@@ -0,0 +1,203 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var tokens = require('../visual/tokens.js');
+
+var defaultOption = {
+  show: true,
+  // zlevel: 0,
+  z: 0,
+  // Inverse the axis.
+  inverse: false,
+  // Axis name displayed.
+  name: '',
+  // 'start' | 'middle' | 'end'
+  nameLocation: 'end',
+  // By degree. By default auto rotate by nameLocation.
+  nameRotate: null,
+  nameTruncate: {
+    maxWidth: null,
+    ellipsis: '...',
+    placeholder: '.'
+  },
+  // Use global text style by default.
+  nameTextStyle: {
+    // textMargin: never, // The default value will be specified based on `nameLocation`.
+  },
+  // The gap between axisName and axisLine.
+  nameGap: 15,
+  // Default `false` to support tooltip.
+  silent: false,
+  // Default `false` to avoid legacy user event listener fail.
+  triggerEvent: false,
+  tooltip: {
+    show: false
+  },
+  axisPointer: {},
+  axisLine: {
+    show: true,
+    onZero: true,
+    onZeroAxisIndex: null,
+    lineStyle: {
+      color: tokens.default.color.axisLine,
+      width: 1,
+      type: 'solid'
+    },
+    // The arrow at both ends the the axis.
+    symbol: ['none', 'none'],
+    symbolSize: [10, 15],
+    breakLine: true
+  },
+  axisTick: {
+    show: true,
+    // Whether axisTick is inside the grid or outside the grid.
+    inside: false,
+    // The length of axisTick.
+    length: 5,
+    lineStyle: {
+      width: 1
+    }
+  },
+  axisLabel: {
+    show: true,
+    // Whether axisLabel is inside the grid or outside the grid.
+    inside: false,
+    rotate: 0,
+    // true | false | null/undefined (auto)
+    showMinLabel: null,
+    // true | false | null/undefined (auto)
+    showMaxLabel: null,
+    margin: 8,
+    // formatter: null,
+    fontSize: 12,
+    color: tokens.default.color.axisLabel,
+    // In scenarios like axis labels, when labels text's progression direction matches the label
+    // layout direction (e.g., when all letters are in a single line), extra start/end margin is
+    // needed to prevent the text from appearing visually joined. In the other case, when lables
+    // are stacked (e.g., having rotation or horizontal labels on yAxis), the layout needs to be
+    // compact, so NO extra top/bottom margin should be applied.
+    textMargin: [0, 3]
+  },
+  splitLine: {
+    show: true,
+    showMinLine: true,
+    showMaxLine: true,
+    lineStyle: {
+      color: tokens.default.color.axisSplitLine,
+      width: 1,
+      type: 'solid'
+    }
+  },
+  splitArea: {
+    show: false,
+    areaStyle: {
+      color: [tokens.default.color.backgroundTint, tokens.default.color.backgroundTransparent]
+    }
+  },
+  breakArea: {
+    show: true,
+    itemStyle: {
+      color: tokens.default.color.neutral00,
+      // Break border color should be darker than the splitLine
+      // because it has opacity and should be more prominent
+      borderColor: tokens.default.color.border,
+      borderWidth: 1,
+      borderType: [3, 3],
+      opacity: 0.6
+    },
+    zigzagAmplitude: 4,
+    zigzagMinSpan: 4,
+    zigzagMaxSpan: 20,
+    zigzagZ: 100,
+    expandOnClick: true
+  },
+  breakLabelLayout: {
+    moveOverlap: 'auto'
+  }
+};
+var categoryAxis = util.merge({
+  // The gap at both ends of the axis. For categoryAxis, boolean.
+  boundaryGap: true,
+  // Set false to faster category collection.
+  deduplication: null,
+  jitter: 0,
+  jitterOverlap: true,
+  jitterMargin: 2,
+  // splitArea: {
+  // show: false
+  // },
+  splitLine: {
+    show: false
+  },
+  axisTick: {
+    // If tick is align with label when boundaryGap is true
+    alignWithLabel: false,
+    interval: 'auto',
+    show: 'auto'
+  },
+  axisLabel: {
+    interval: 'auto'
+  }
+}, defaultOption);
+var valueAxis = util.merge({
+  boundaryGap: [0, 0],
+  axisLine: {
+    // Not shown when other axis is categoryAxis in cartesian
+    show: 'auto'
+  },
+  axisTick: {
+    // Not shown when other axis is categoryAxis in cartesian
+    show: 'auto'
+  },
+  // TODO
+  // min/max: [30, datamin, 60] or [20, datamin] or [datamin, 60]
+  splitNumber: 5,
+  minorTick: {
+    // Minor tick, not available for cateogry axis.
+    show: false,
+    // Split number of minor ticks. The value should be in range of (0, 100)
+    splitNumber: 5,
+    // Length of minor tick
+    length: 3,
+    // Line style
+    lineStyle: {
+      // Default to be same with axisTick
+    }
+  },
+  minorSplitLine: {
+    show: false,
+    lineStyle: {
+      color: tokens.default.color.axisMinorSplitLine,
+      width: 1
+    }
+  }
+}, defaultOption);
+var timeAxis = util.merge({
+  splitNumber: 6,
+  axisLabel: {
+    // To eliminate labels that are not nice
+    showMinLabel: false,
+    showMaxLabel: false,
+    rich: {
+      primary: {
+        fontWeight: 'bold'
+      }
+    }
+  },
+  splitLine: {
+    show: false
+  }
+}, valueAxis);
+var logAxis = util.defaults({
+  logBase: 10
+}, valueAxis);
+var axisDefault = {
+  category: categoryAxis,
+  value: valueAxis,
+  time: timeAxis,
+  log: logAxis
+};
+
+exports.default = axisDefault;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/axisHelper.js

@@ -0,0 +1,308 @@
+'use strict';
+
+var util = require('../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var Ordinal = require('../scale/Ordinal.js');
+var Interval = require('../scale/Interval.js');
+var Scale = require('../scale/Scale.js');
+var barGrid = require('../layout/barGrid.js');
+var Time = require('../scale/Time.js');
+var Log = require('../scale/Log.js');
+var dataStackHelper = require('../data/helper/dataStackHelper.js');
+var scaleRawExtentInfo = require('./scaleRawExtentInfo.js');
+var time = require('../util/time.js');
+var _break = require('../scale/break.js');
+var log = require('../util/log.js');
+
+/**
+ * Get axis scale extent before niced.
+ * Item of returned array can only be number (including Infinity and NaN).
+ *
+ * Caution:
+ * Precondition of calling this method:
+ * The scale extent has been initialized using series data extent via
+ * `scale.setExtent` or `scale.unionExtentFromData`;
+ */
+function getScaleExtent(scale, model) {
+  var scaleType = scale.type;
+  var rawExtentResult = scaleRawExtentInfo.ensureScaleRawExtentInfo(scale, model, scale.getExtent()).calculate();
+  scale.setBlank(rawExtentResult.isBlank);
+  var min = rawExtentResult.min;
+  var max = rawExtentResult.max;
+  // If bars are placed on a base axis of type time or interval account for axis boundary overflow and current axis
+  // is base axis
+  // FIXME
+  // (1) Consider support value axis, where below zero and axis `onZero` should be handled properly.
+  // (2) Refactor the logic with `barGrid`. Is it not need to `makeBarWidthAndOffsetInfo` twice with different extent?
+  //     Should not depend on series type `bar`?
+  // (3) Fix that might overlap when using dataZoom.
+  // (4) Consider other chart types using `barGrid`?
+  // See #6728, #4862, `test/bar-overflow-time-plot.html`
+  var ecModel = model.ecModel;
+  if (ecModel && scaleType === 'time' /* || scaleType === 'interval' */) {
+    var barSeriesModels = barGrid.prepareLayoutBarSeries('bar', ecModel);
+    var isBaseAxisAndHasBarSeries_1 = false;
+    util.each(barSeriesModels, function (seriesModel) {
+      isBaseAxisAndHasBarSeries_1 = isBaseAxisAndHasBarSeries_1 || seriesModel.getBaseAxis() === model.axis;
+    });
+    if (isBaseAxisAndHasBarSeries_1) {
+      // Calculate placement of bars on axis. TODO should be decoupled
+      // with barLayout
+      var barWidthAndOffset = barGrid.makeColumnLayout(barSeriesModels);
+      // Adjust axis min and max to account for overflow
+      var adjustedScale = adjustScaleForOverflow(min, max, model, barWidthAndOffset);
+      min = adjustedScale.min;
+      max = adjustedScale.max;
+    }
+  }
+  return {
+    extent: [min, max],
+    // "fix" means "fixed", the value should not be
+    // changed in the subsequent steps.
+    fixMin: rawExtentResult.minFixed,
+    fixMax: rawExtentResult.maxFixed
+  };
+}
+function adjustScaleForOverflow(min, max, model,
+// Only support cartesian coord yet.
+barWidthAndOffset) {
+  // Get Axis Length
+  var axisExtent = model.axis.getExtent();
+  var axisLength = Math.abs(axisExtent[1] - axisExtent[0]);
+  // Get bars on current base axis and calculate min and max overflow
+  var barsOnCurrentAxis = barGrid.retrieveColumnLayout(barWidthAndOffset, model.axis);
+  if (barsOnCurrentAxis === undefined) {
+    return {
+      min: min,
+      max: max
+    };
+  }
+  var minOverflow = Infinity;
+  util.each(barsOnCurrentAxis, function (item) {
+    minOverflow = Math.min(item.offset, minOverflow);
+  });
+  var maxOverflow = -Infinity;
+  util.each(barsOnCurrentAxis, function (item) {
+    maxOverflow = Math.max(item.offset + item.width, maxOverflow);
+  });
+  minOverflow = Math.abs(minOverflow);
+  maxOverflow = Math.abs(maxOverflow);
+  var totalOverFlow = minOverflow + maxOverflow;
+  // Calculate required buffer based on old range and overflow
+  var oldRange = max - min;
+  var oldRangePercentOfNew = 1 - (minOverflow + maxOverflow) / axisLength;
+  var overflowBuffer = oldRange / oldRangePercentOfNew - oldRange;
+  max += overflowBuffer * (maxOverflow / totalOverFlow);
+  min -= overflowBuffer * (minOverflow / totalOverFlow);
+  return {
+    min: min,
+    max: max
+  };
+}
+// Precondition of calling this method:
+// The scale extent has been initialized using series data extent via
+// `scale.setExtent` or `scale.unionExtentFromData`;
+function niceScaleExtent(scale, inModel) {
+  var model = inModel;
+  var extentInfo = getScaleExtent(scale, model);
+  var extent = extentInfo.extent;
+  var splitNumber = model.get('splitNumber');
+  if (scale instanceof Log.default) {
+    scale.base = model.get('logBase');
+  }
+  var scaleType = scale.type;
+  var interval = model.get('interval');
+  var isIntervalOrTime = scaleType === 'interval' || scaleType === 'time';
+  scale.setBreaksFromOption(retrieveAxisBreaksOption(model));
+  scale.setExtent(extent[0], extent[1]);
+  scale.calcNiceExtent({
+    splitNumber: splitNumber,
+    fixMin: extentInfo.fixMin,
+    fixMax: extentInfo.fixMax,
+    minInterval: isIntervalOrTime ? model.get('minInterval') : null,
+    maxInterval: isIntervalOrTime ? model.get('maxInterval') : null
+  });
+  // If some one specified the min, max. And the default calculated interval
+  // is not good enough. He can specify the interval. It is often appeared
+  // in angle axis with angle 0 - 360. Interval calculated in interval scale is hard
+  // to be 60.
+  // FIXME
+  if (interval != null) {
+    scale.setInterval && scale.setInterval(interval);
+  }
+}
+/**
+ * @param axisType Default retrieve from model.type
+ */
+function createScaleByModel(model, axisType) {
+  axisType = axisType || model.get('type');
+  if (axisType) {
+    switch (axisType) {
+      // Buildin scale
+      case 'category':
+        return new Ordinal.default({
+          ordinalMeta: model.getOrdinalMeta ? model.getOrdinalMeta() : model.getCategories(),
+          extent: [Infinity, -Infinity]
+        });
+      case 'time':
+        return new Time.default({
+          locale: model.ecModel.getLocaleModel(),
+          useUTC: model.ecModel.get('useUTC')
+        });
+      default:
+        // case 'value'/'interval', 'log', or others.
+        return new (Scale.default.getClass(axisType) || Interval.default)();
+    }
+  }
+}
+/**
+ * Check if the axis cross 0
+ */
+function ifAxisCrossZero(axis) {
+  var dataExtent = axis.scale.getExtent();
+  var min = dataExtent[0];
+  var max = dataExtent[1];
+  return !(min > 0 && max > 0 || min < 0 && max < 0);
+}
+/**
+ * @param axis
+ * @return Label formatter function.
+ *         param: {number} tickValue,
+ *         param: {number} idx, the index in all ticks.
+ *                         If category axis, this param is not required.
+ *         return: {string} label string.
+ */
+function makeLabelFormatter(axis) {
+  var labelFormatter = axis.getLabelModel().get('formatter');
+  if (axis.type === 'time') {
+    var parsed_1 = time.parseTimeAxisLabelFormatter(labelFormatter);
+    return function (tick, idx) {
+      return axis.scale.getFormattedLabel(tick, idx, parsed_1);
+    };
+  } else if (util.isString(labelFormatter)) {
+    return function (tick) {
+      // For category axis, get raw value; for numeric axis,
+      // get formatted label like '1,333,444'.
+      var label = axis.scale.getLabel(tick);
+      var text = labelFormatter.replace('{value}', label != null ? label : '');
+      return text;
+    };
+  } else if (util.isFunction(labelFormatter)) {
+    if (axis.type === 'category') {
+      return function (tick, idx) {
+        // The original intention of `idx` is "the index of the tick in all ticks".
+        // But the previous implementation of category axis do not consider the
+        // `axisLabel.interval`, which cause that, for example, the `interval` is
+        // `1`, then the ticks "name5", "name7", "name9" are displayed, where the
+        // corresponding `idx` are `0`, `2`, `4`, but not `0`, `1`, `2`. So we keep
+        // the definition here for back compatibility.
+        return labelFormatter(getAxisRawValue(axis, tick), tick.value - axis.scale.getExtent()[0], null // Using `null` just for backward compat.
+        );
+      };
+    }
+    var scaleBreakHelper_1 = _break.getScaleBreakHelper();
+    return function (tick, idx) {
+      // Using `null` just for backward compat. It's been found that in the `test/axis-customTicks.html`,
+      // there is a formatter `function (value, index, revers = true) { ... }`. Although the third param
+      // `revers` is incorrect and always `null`, changing it might introduce a breaking change.
+      var extra = null;
+      if (scaleBreakHelper_1) {
+        extra = scaleBreakHelper_1.makeAxisLabelFormatterParamBreak(extra, tick["break"]);
+      }
+      return labelFormatter(getAxisRawValue(axis, tick), idx, extra);
+    };
+  } else {
+    return function (tick) {
+      return axis.scale.getLabel(tick);
+    };
+  }
+}
+function getAxisRawValue(axis, tick) {
+  // In category axis with data zoom, tick is not the original
+  // index of axis.data. So tick should not be exposed to user
+  // in category axis.
+  return axis.type === 'category' ? axis.scale.getLabel(tick) : tick.value;
+}
+/**
+ * @param model axisLabelModel or axisTickModel
+ * @return {number|String} Can be null|'auto'|number|function
+ */
+function getOptionCategoryInterval(model) {
+  var interval = model.get('interval');
+  return interval == null ? 'auto' : interval;
+}
+/**
+ * Set `categoryInterval` as 0 implicitly indicates that
+ * show all labels regardless of overlap.
+ * @param {Object} axis axisModel.axis
+ */
+function shouldShowAllLabels(axis) {
+  return axis.type === 'category' && getOptionCategoryInterval(axis.getLabelModel()) === 0;
+}
+function getDataDimensionsOnAxis(data, axisDim) {
+  // Remove duplicated dat dimensions caused by `getStackedDimension`.
+  var dataDimMap = {};
+  // Currently `mapDimensionsAll` will contain stack result dimension ('__\0ecstackresult').
+  // PENDING: is it reasonable? Do we need to remove the original dim from "coord dim" since
+  // there has been stacked result dim?
+  util.each(data.mapDimensionsAll(axisDim), function (dataDim) {
+    // For example, the extent of the original dimension
+    // is [0.1, 0.5], the extent of the `stackResultDimension`
+    // is [7, 9], the final extent should NOT include [0.1, 0.5],
+    // because there is no graphic corresponding to [0.1, 0.5].
+    // See the case in `test/area-stack.html` `main1`, where area line
+    // stack needs `yAxis` not start from 0.
+    dataDimMap[dataStackHelper.getStackedDimension(data, dataDim)] = true;
+  });
+  return util.keys(dataDimMap);
+}
+function unionAxisExtentFromData(dataExtent, data, axisDim) {
+  if (data) {
+    util.each(getDataDimensionsOnAxis(data, axisDim), function (dim) {
+      var seriesExtent = data.getApproximateExtent(dim);
+      seriesExtent[0] < dataExtent[0] && (dataExtent[0] = seriesExtent[0]);
+      seriesExtent[1] > dataExtent[1] && (dataExtent[1] = seriesExtent[1]);
+    });
+  }
+}
+function isNameLocationCenter(nameLocation) {
+  return nameLocation === 'middle' || nameLocation === 'center';
+}
+function shouldAxisShow(axisModel) {
+  return axisModel.getShallow('show');
+}
+function retrieveAxisBreaksOption(model) {
+  var option = model.get('breaks', true);
+  if (option != null) {
+    if (!_break.getScaleBreakHelper()) {
+      if (process.env.NODE_ENV !== 'production') {
+        log.error('Must `import {AxisBreak} from "echarts/features.js"; use(AxisBreak);` first if using breaks option.');
+      }
+      return undefined;
+    }
+    if (!isSupportAxisBreak(model.axis)) {
+      if (process.env.NODE_ENV !== 'production') {
+        log.error("Axis '" + model.axis.dim + "'-'" + model.axis.type + "' does not support break.");
+      }
+      return undefined;
+    }
+    return option;
+  }
+}
+function isSupportAxisBreak(axis) {
+  // The polar radius axis can also support break feasibly. Do not do it until the requirements are met.
+  return (axis.dim === 'x' || axis.dim === 'y' || axis.dim === 'z' || axis.dim === 'single') && axis.type !== 'category';
+}
+
+exports.createScaleByModel = createScaleByModel;
+exports.getAxisRawValue = getAxisRawValue;
+exports.getDataDimensionsOnAxis = getDataDimensionsOnAxis;
+exports.getOptionCategoryInterval = getOptionCategoryInterval;
+exports.getScaleExtent = getScaleExtent;
+exports.ifAxisCrossZero = ifAxisCrossZero;
+exports.isNameLocationCenter = isNameLocationCenter;
+exports.makeLabelFormatter = makeLabelFormatter;
+exports.niceScaleExtent = niceScaleExtent;
+exports.retrieveAxisBreaksOption = retrieveAxisBreaksOption;
+exports.shouldAxisShow = shouldAxisShow;
+exports.shouldShowAllLabels = shouldShowAllLabels;
+exports.unionAxisExtentFromData = unionAxisExtentFromData;