office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/coord/axisAlignTicks.js

@@ -0,0 +1,97 @@
+import { round, getPrecisionSafe } from '../util/number.js';
+import IntervalScale from '../scale/Interval.js';
+import { getScaleExtent } from './axisHelper.js';
+import { warn } from '../util/log.js';
+import { increaseInterval, isValueNice } from '../scale/helper.js';
+
+var mathLog = Math.log;
+function alignScaleTicks(scale, axisModel, alignToScale) {
+  var intervalScaleProto = IntervalScale.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, true);
+  var alignToSplitNumber = alignToTicks.length - 1;
+  var alignToInterval = intervalScaleProto.getInterval.call(alignToScale);
+  var scaleExtent = getScaleExtent(scale, axisModel);
+  var rawExtent = scaleExtent.extent;
+  var isMinFixed = scaleExtent.fixMin;
+  var isMaxFixed = scaleExtent.fixMax;
+  if (scale.type === 'log') {
+    var logBase = mathLog(scale.base);
+    rawExtent = [mathLog(rawExtent[0]) / logBase, mathLog(rawExtent[1]) / logBase];
+  }
+  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 = 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 = increaseInterval(interval);
+      min = rawExtent[1] - interval * alignToSplitNumber;
+    }
+  } else {
+    var nicedSplitNumber = scale.getTicks().length - 1;
+    if (nicedSplitNumber > alignToSplitNumber) {
+      interval = increaseInterval(interval);
+    }
+    var range = interval * alignToSplitNumber;
+    max = Math.ceil(rawExtent[1] / interval) * interval;
+    min = round(max - range);
+    // Not change the result that crossing zero.
+    if (min < 0 && rawExtent[0] >= 0) {
+      min = 0;
+      max = round(range);
+    } else if (max > 0 && rawExtent[1] <= 0) {
+      max = 0;
+      min = -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] && (!isValueNice(interval) || getPrecisionSafe(ticks[1].value) > getPrecisionSafe(interval))) {
+      warn(
+      // eslint-disable-next-line
+      "The ticks may be not readable when set min: " + axisModel.get('min') + ", max: " + axisModel.get('max') + " and alignTicks: true");
+    }
+  }
+}
+
+export { alignScaleTicks };

package/esm/node_modules/echarts/lib/coord/axisCommonTypes.js

@@ -0,0 +1,50 @@
+/*
+* 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
+};
+
+export { AXIS_TYPES };

package/esm/node_modules/echarts/lib/coord/axisDefault.js

@@ -0,0 +1,162 @@
+import { merge, defaults } from '../../../zrender/lib/core/util.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: {},
+  // 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: '#6E7079',
+      width: 1,
+      type: 'solid'
+    },
+    // The arrow at both ends the the axis.
+    symbol: ['none', 'none'],
+    symbolSize: [10, 15]
+  },
+  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
+  },
+  splitLine: {
+    show: true,
+    lineStyle: {
+      color: ['#E0E6F1'],
+      width: 1,
+      type: 'solid'
+    }
+  },
+  splitArea: {
+    show: false,
+    areaStyle: {
+      color: ['rgba(250,250,250,0.2)', 'rgba(210,219,238,0.2)']
+    }
+  }
+};
+var categoryAxis = merge({
+  // The gap at both ends of the axis. For categoryAxis, boolean.
+  boundaryGap: true,
+  // Set false to faster category collection.
+  deduplication: null,
+  // splitArea: {
+  // show: false
+  // },
+  splitLine: {
+    show: false
+  },
+  axisTick: {
+    // If tick is align with label when boundaryGap is true
+    alignWithLabel: false,
+    interval: 'auto'
+  },
+  axisLabel: {
+    interval: 'auto'
+  }
+}, defaultOption);
+var valueAxis = 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: '#F4F7FD',
+      width: 1
+    }
+  }
+}, defaultOption);
+var timeAxis = 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 = defaults({
+  logBase: 10
+}, valueAxis);
+var axisDefault = {
+  category: categoryAxis,
+  value: valueAxis,
+  time: timeAxis,
+  log: logAxis
+};
+
+export { axisDefault as default };

package/esm/node_modules/echarts/lib/coord/axisHelper.js

@@ -0,0 +1,308 @@
+import { each, isString, isFunction, keys } from '../../../zrender/lib/core/util.js';
+import OrdinalScale from '../scale/Ordinal.js';
+import IntervalScale from '../scale/Interval.js';
+import Scale from '../scale/Scale.js';
+import { prepareLayoutBarSeries, makeColumnLayout, retrieveColumnLayout } from '../layout/barGrid.js';
+import BoundingRect from '../../../zrender/lib/core/BoundingRect.js';
+import TimeScale from '../scale/Time.js';
+import LogScale from '../scale/Log.js';
+import { getStackedDimension } from '../data/helper/dataStackHelper.js';
+import { ensureScaleRawExtentInfo } from './scaleRawExtentInfo.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 = 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 = prepareLayoutBarSeries('bar', ecModel);
+    var isBaseAxisAndHasBarSeries_1 = false;
+    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 = 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 = axisExtent[1] - axisExtent[0];
+  // Get bars on current base axis and calculate min and max overflow
+  var barsOnCurrentAxis = retrieveColumnLayout(barWidthAndOffset, model.axis);
+  if (barsOnCurrentAxis === undefined) {
+    return {
+      min: min,
+      max: max
+    };
+  }
+  var minOverflow = Infinity;
+  each(barsOnCurrentAxis, function (item) {
+    minOverflow = Math.min(item.offset, minOverflow);
+  });
+  var maxOverflow = -Infinity;
+  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 LogScale) {
+    scale.base = model.get('logBase');
+  }
+  var scaleType = scale.type;
+  var interval = model.get('interval');
+  var isIntervalOrTime = scaleType === 'interval' || scaleType === 'time';
+  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 OrdinalScale({
+          ordinalMeta: model.getOrdinalMeta ? model.getOrdinalMeta() : model.getCategories(),
+          extent: [Infinity, -Infinity]
+        });
+      case 'time':
+        return new TimeScale({
+          locale: model.ecModel.getLocaleModel(),
+          useUTC: model.ecModel.get('useUTC')
+        });
+      default:
+        // case 'value'/'interval', 'log', or others.
+        return new (Scale.getClass(axisType) || IntervalScale)();
+    }
+  }
+}
+/**
+ * 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');
+  var categoryTickStart = axis.type === 'category' ? axis.scale.getExtent()[0] : null;
+  if (axis.scale.type === 'time') {
+    return function (tpl) {
+      return function (tick, idx) {
+        return axis.scale.getFormattedLabel(tick, idx, tpl);
+      };
+    }(labelFormatter);
+  } else if (isString(labelFormatter)) {
+    return function (tpl) {
+      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 = tpl.replace('{value}', label != null ? label : '');
+        return text;
+      };
+    }(labelFormatter);
+  } else if (isFunction(labelFormatter)) {
+    return function (cb) {
+      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.
+        if (categoryTickStart != null) {
+          idx = tick.value - categoryTickStart;
+        }
+        return cb(getAxisRawValue(axis, tick), idx, tick.level != null ? {
+          level: tick.level
+        } : null);
+      };
+    }(labelFormatter);
+  } 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 axis
+ * @return Be null/undefined if no labels.
+ */
+function estimateLabelUnionRect(axis) {
+  var axisModel = axis.model;
+  var scale = axis.scale;
+  if (!axisModel.get(['axisLabel', 'show']) || scale.isBlank()) {
+    return;
+  }
+  var realNumberScaleTicks;
+  var tickCount;
+  var categoryScaleExtent = scale.getExtent();
+  // Optimize for large category data, avoid call `getTicks()`.
+  if (scale instanceof OrdinalScale) {
+    tickCount = scale.count();
+  } else {
+    realNumberScaleTicks = scale.getTicks();
+    tickCount = realNumberScaleTicks.length;
+  }
+  var axisLabelModel = axis.getLabelModel();
+  var labelFormatter = makeLabelFormatter(axis);
+  var rect;
+  var step = 1;
+  // Simple optimization for large amount of labels
+  if (tickCount > 40) {
+    step = Math.ceil(tickCount / 40);
+  }
+  for (var i = 0; i < tickCount; i += step) {
+    var tick = realNumberScaleTicks ? realNumberScaleTicks[i] : {
+      value: categoryScaleExtent[0] + i
+    };
+    var label = labelFormatter(tick, i);
+    var unrotatedSingleRect = axisLabelModel.getTextRect(label);
+    var singleRect = rotateTextRect(unrotatedSingleRect, axisLabelModel.get('rotate') || 0);
+    rect ? rect.union(singleRect) : rect = singleRect;
+  }
+  return rect;
+}
+function rotateTextRect(textRect, rotate) {
+  var rotateRadians = rotate * Math.PI / 180;
+  var beforeWidth = textRect.width;
+  var beforeHeight = textRect.height;
+  var afterWidth = beforeWidth * Math.abs(Math.cos(rotateRadians)) + Math.abs(beforeHeight * Math.sin(rotateRadians));
+  var afterHeight = beforeWidth * Math.abs(Math.sin(rotateRadians)) + Math.abs(beforeHeight * Math.cos(rotateRadians));
+  var rotatedRect = new BoundingRect(textRect.x, textRect.y, afterWidth, afterHeight);
+  return rotatedRect;
+}
+/**
+ * @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?
+  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[getStackedDimension(data, dataDim)] = true;
+  });
+  return keys(dataDimMap);
+}
+function unionAxisExtentFromData(dataExtent, data, axisDim) {
+  if (data) {
+    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]);
+    });
+  }
+}
+
+export { createScaleByModel, estimateLabelUnionRect, getAxisRawValue, getDataDimensionsOnAxis, getOptionCategoryInterval, getScaleExtent, ifAxisCrossZero, makeLabelFormatter, niceScaleExtent, shouldShowAllLabels, unionAxisExtentFromData };

package/esm/node_modules/echarts/lib/coord/axisModelCommonMixin.js

@@ -0,0 +1,60 @@
+/*
+* 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.
+*/
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+var AxisModelCommonMixin = /** @class */function () {
+  function AxisModelCommonMixin() {}
+  AxisModelCommonMixin.prototype.getNeedCrossZero = function () {
+    var option = this.option;
+    return !option.scale;
+  };
+  /**
+   * Should be implemented by each axis model if necessary.
+   * @return coordinate system model
+   */
+  AxisModelCommonMixin.prototype.getCoordSysModel = function () {
+    return;
+  };
+  return AxisModelCommonMixin;
+}();
+
+export { AxisModelCommonMixin };