@fmdevui/fm-dev 1.0.113 → 1.0.115

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/calendar/Calendar.js

@@ -0,0 +1,360 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var layout = require('../../util/layout.js');
+var number = require('../../util/number.js');
+var BoundingRect = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/BoundingRect.js');
+var graphic = require('../../util/graphic.js');
+var CoordinateSystem = require('../../core/CoordinateSystem.js');
+
+// (24*60*60*1000)
+var PROXIMATE_ONE_DAY = 86400000;
+var Calendar = /** @class */function () {
+  function Calendar(calendarModel, ecModel, api) {
+    this.type = 'calendar';
+    this.dimensions = Calendar.dimensions;
+    // Required in createListFromData
+    this.getDimensionsInfo = Calendar.getDimensionsInfo;
+    this._model = calendarModel;
+    this._update(ecModel, api);
+  }
+  Calendar.getDimensionsInfo = function () {
+    return [{
+      name: 'time',
+      type: 'time'
+    }, 'value'];
+  };
+  Calendar.prototype.getRangeInfo = function () {
+    return this._rangeInfo;
+  };
+  Calendar.prototype.getModel = function () {
+    return this._model;
+  };
+  Calendar.prototype.getRect = function () {
+    return this._rect;
+  };
+  Calendar.prototype.getCellWidth = function () {
+    return this._sw;
+  };
+  Calendar.prototype.getCellHeight = function () {
+    return this._sh;
+  };
+  Calendar.prototype.getOrient = function () {
+    return this._orient;
+  };
+  /**
+   * getFirstDayOfWeek
+   *
+   * @example
+   *     0 : start at Sunday
+   *     1 : start at Monday
+   *
+   * @return {number}
+   */
+  Calendar.prototype.getFirstDayOfWeek = function () {
+    return this._firstDayOfWeek;
+  };
+  /**
+   * get date info
+   * }
+   */
+  Calendar.prototype.getDateInfo = function (date) {
+    date = number.parseDate(date);
+    var y = date.getFullYear();
+    var m = date.getMonth() + 1;
+    var mStr = m < 10 ? '0' + m : '' + m;
+    var d = date.getDate();
+    var dStr = d < 10 ? '0' + d : '' + d;
+    var day = date.getDay();
+    day = Math.abs((day + 7 - this.getFirstDayOfWeek()) % 7);
+    return {
+      y: y + '',
+      m: mStr,
+      d: dStr,
+      day: day,
+      time: date.getTime(),
+      formatedDate: y + '-' + mStr + '-' + dStr,
+      date: date
+    };
+  };
+  Calendar.prototype.getNextNDay = function (date, n) {
+    n = n || 0;
+    if (n === 0) {
+      return this.getDateInfo(date);
+    }
+    date = new Date(this.getDateInfo(date).time);
+    date.setDate(date.getDate() + n);
+    return this.getDateInfo(date);
+  };
+  Calendar.prototype._update = function (ecModel, api) {
+    this._firstDayOfWeek = +this._model.getModel('dayLabel').get('firstDay');
+    this._orient = this._model.get('orient');
+    this._lineWidth = this._model.getModel('itemStyle').getItemStyle().lineWidth || 0;
+    this._rangeInfo = this._getRangeInfo(this._initRangeOption());
+    var weeks = this._rangeInfo.weeks || 1;
+    var whNames = ['width', 'height'];
+    var cellSize = this._model.getCellSize().slice();
+    var layoutParams = this._model.getBoxLayoutParams();
+    var cellNumbers = this._orient === 'horizontal' ? [weeks, 7] : [7, weeks];
+    util.each([0, 1], function (idx) {
+      if (cellSizeSpecified(cellSize, idx)) {
+        layoutParams[whNames[idx]] = cellSize[idx] * cellNumbers[idx];
+      }
+    });
+    var whGlobal = {
+      width: api.getWidth(),
+      height: api.getHeight()
+    };
+    var calendarRect = this._rect = layout.getLayoutRect(layoutParams, whGlobal);
+    util.each([0, 1], function (idx) {
+      if (!cellSizeSpecified(cellSize, idx)) {
+        cellSize[idx] = calendarRect[whNames[idx]] / cellNumbers[idx];
+      }
+    });
+    function cellSizeSpecified(cellSize, idx) {
+      return cellSize[idx] != null && cellSize[idx] !== 'auto';
+    }
+    // Has been calculated out number.
+    this._sw = cellSize[0];
+    this._sh = cellSize[1];
+  };
+  /**
+   * Convert a time data(time, value) item to (x, y) point.
+   */
+  // TODO Clamp of calendar is not same with cartesian coordinate systems.
+  // It will return NaN if data exceeds.
+  Calendar.prototype.dataToPoint = function (data, clamp, out) {
+    out = out || [];
+    util.isArray(data) && (data = data[0]);
+    clamp == null && (clamp = true);
+    var dayInfo = this.getDateInfo(data);
+    var range = this._rangeInfo;
+    var date = dayInfo.formatedDate;
+    // if not in range return [NaN, NaN]
+    if (clamp && !(dayInfo.time >= range.start.time && dayInfo.time < range.end.time + PROXIMATE_ONE_DAY)) {
+      out[0] = out[1] = NaN;
+      return out;
+    }
+    var week = dayInfo.day;
+    var nthWeek = this._getRangeInfo([range.start.time, date]).nthWeek;
+    if (this._orient === 'vertical') {
+      out[0] = this._rect.x + week * this._sw + this._sw / 2;
+      out[1] = this._rect.y + nthWeek * this._sh + this._sh / 2;
+    } else {
+      out[0] = this._rect.x + nthWeek * this._sw + this._sw / 2;
+      out[1] = this._rect.y + week * this._sh + this._sh / 2;
+    }
+    return out;
+  };
+  /**
+   * Convert a (x, y) point to time data
+   */
+  Calendar.prototype.pointToData = function (point) {
+    var date = this.pointToDate(point);
+    return date && date.time;
+  };
+  Calendar.prototype.dataToLayout = function (data, clamp, out) {
+    out = out || {};
+    var rect = out.rect = out.rect || {};
+    var contentRect = out.contentRect = out.contentRect || {};
+    var point = this.dataToPoint(data, clamp);
+    rect.x = point[0] - this._sw / 2;
+    rect.y = point[1] - this._sh / 2;
+    rect.width = this._sw;
+    rect.height = this._sh;
+    BoundingRect.default.copy(contentRect, rect);
+    graphic.expandOrShrinkRect(contentRect, this._lineWidth / 2, true, true);
+    return out;
+  };
+  /**
+   * Convert a time date item to (x, y) four point.
+   */
+  Calendar.prototype.dataToCalendarLayout = function (data, clamp) {
+    var point = this.dataToPoint(data, clamp);
+    return {
+      center: point,
+      tl: [point[0] - this._sw / 2, point[1] - this._sh / 2],
+      tr: [point[0] + this._sw / 2, point[1] - this._sh / 2],
+      br: [point[0] + this._sw / 2, point[1] + this._sh / 2],
+      bl: [point[0] - this._sw / 2, point[1] + this._sh / 2]
+    };
+  };
+  /**
+   * Convert a (x, y) point to time date
+   *
+   * @param  {Array} point point
+   * @return {Object}       date
+   */
+  Calendar.prototype.pointToDate = function (point) {
+    var nthX = Math.floor((point[0] - this._rect.x) / this._sw) + 1;
+    var nthY = Math.floor((point[1] - this._rect.y) / this._sh) + 1;
+    var range = this._rangeInfo.range;
+    if (this._orient === 'vertical') {
+      return this._getDateByWeeksAndDay(nthY, nthX - 1, range);
+    }
+    return this._getDateByWeeksAndDay(nthX, nthY - 1, range);
+  };
+  Calendar.prototype.convertToPixel = function (ecModel, finder, value) {
+    var coordSys = getCoordSys(finder);
+    return coordSys === this ? coordSys.dataToPoint(value) : null;
+  };
+  Calendar.prototype.convertToLayout = function (ecModel, finder, value) {
+    var coordSys = getCoordSys(finder);
+    return coordSys === this ? coordSys.dataToLayout(value) : null;
+  };
+  Calendar.prototype.convertFromPixel = function (ecModel, finder, pixel) {
+    var coordSys = getCoordSys(finder);
+    return coordSys === this ? coordSys.pointToData(pixel) : null;
+  };
+  Calendar.prototype.containPoint = function (point) {
+    console.warn('Not implemented.');
+    return false;
+  };
+  /**
+   * initRange
+   * Normalize to an [start, end] array
+   */
+  Calendar.prototype._initRangeOption = function () {
+    var range = this._model.get('range');
+    var normalizedRange;
+    // Convert [1990] to 1990
+    if (util.isArray(range) && range.length === 1) {
+      range = range[0];
+    }
+    if (!util.isArray(range)) {
+      var rangeStr = range.toString();
+      // One year.
+      if (/^\d{4}$/.test(rangeStr)) {
+        normalizedRange = [rangeStr + '-01-01', rangeStr + '-12-31'];
+      }
+      // One month
+      if (/^\d{4}[\/|-]\d{1,2}$/.test(rangeStr)) {
+        var start = this.getDateInfo(rangeStr);
+        var firstDay = start.date;
+        firstDay.setMonth(firstDay.getMonth() + 1);
+        var end = this.getNextNDay(firstDay, -1);
+        normalizedRange = [start.formatedDate, end.formatedDate];
+      }
+      // One day
+      if (/^\d{4}[\/|-]\d{1,2}[\/|-]\d{1,2}$/.test(rangeStr)) {
+        normalizedRange = [rangeStr, rangeStr];
+      }
+    } else {
+      normalizedRange = range;
+    }
+    if (!normalizedRange) {
+      if (process.env.NODE_ENV !== 'production') {
+        util.logError('Invalid date range.');
+      }
+      // Not handling it.
+      return range;
+    }
+    var tmp = this._getRangeInfo(normalizedRange);
+    if (tmp.start.time > tmp.end.time) {
+      normalizedRange.reverse();
+    }
+    return normalizedRange;
+  };
+  /**
+   * range info
+   *
+   * @private
+   * @param  {Array} range range ['2017-01-01', '2017-07-08']
+   *  If range[0] > range[1], they will not be reversed.
+   * @return {Object}       obj
+   */
+  Calendar.prototype._getRangeInfo = function (range) {
+    var parsedRange = [this.getDateInfo(range[0]), this.getDateInfo(range[1])];
+    var reversed;
+    if (parsedRange[0].time > parsedRange[1].time) {
+      reversed = true;
+      parsedRange.reverse();
+    }
+    var allDay = Math.floor(parsedRange[1].time / PROXIMATE_ONE_DAY) - Math.floor(parsedRange[0].time / PROXIMATE_ONE_DAY) + 1;
+    // Consider case1 (#11677 #10430):
+    // Set the system timezone as "UK", set the range to `['2016-07-01', '2016-12-31']`
+    // Consider case2:
+    // Firstly set system timezone as "Time Zone: America/Toronto",
+    // ```
+    // let first = new Date(1478412000000 - 3600 * 1000 * 2.5);
+    // let second = new Date(1478412000000);
+    // let allDays = Math.floor(second / ONE_DAY) - Math.floor(first / ONE_DAY) + 1;
+    // ```
+    // will get wrong result because of DST. So we should fix it.
+    var date = new Date(parsedRange[0].time);
+    var startDateNum = date.getDate();
+    var endDateNum = parsedRange[1].date.getDate();
+    date.setDate(startDateNum + allDay - 1);
+    // The bias can not over a month, so just compare date.
+    var dateNum = date.getDate();
+    if (dateNum !== endDateNum) {
+      var sign = date.getTime() - parsedRange[1].time > 0 ? 1 : -1;
+      while ((dateNum = date.getDate()) !== endDateNum && (date.getTime() - parsedRange[1].time) * sign > 0) {
+        allDay -= sign;
+        date.setDate(dateNum - sign);
+      }
+    }
+    var weeks = Math.floor((allDay + parsedRange[0].day + 6) / 7);
+    var nthWeek = reversed ? -weeks + 1 : weeks - 1;
+    reversed && parsedRange.reverse();
+    return {
+      range: [parsedRange[0].formatedDate, parsedRange[1].formatedDate],
+      start: parsedRange[0],
+      end: parsedRange[1],
+      allDay: allDay,
+      weeks: weeks,
+      // From 0.
+      nthWeek: nthWeek,
+      fweek: parsedRange[0].day,
+      lweek: parsedRange[1].day
+    };
+  };
+  /**
+   * get date by nthWeeks and week day in range
+   *
+   * @private
+   * @param  {number} nthWeek the week
+   * @param  {number} day   the week day
+   * @param  {Array} range [d1, d2]
+   * @return {Object}
+   */
+  Calendar.prototype._getDateByWeeksAndDay = function (nthWeek, day, range) {
+    var rangeInfo = this._getRangeInfo(range);
+    if (nthWeek > rangeInfo.weeks || nthWeek === 0 && day < rangeInfo.fweek || nthWeek === rangeInfo.weeks && day > rangeInfo.lweek) {
+      return null;
+    }
+    var nthDay = (nthWeek - 1) * 7 - rangeInfo.fweek + day;
+    var date = new Date(rangeInfo.start.time);
+    date.setDate(+rangeInfo.start.d + nthDay);
+    return this.getDateInfo(date);
+  };
+  Calendar.create = function (ecModel, api) {
+    var calendarList = [];
+    ecModel.eachComponent('calendar', function (calendarModel) {
+      var calendar = new Calendar(calendarModel, ecModel, api);
+      calendarList.push(calendar);
+      calendarModel.coordinateSystem = calendar;
+    });
+    // Inject coordinate system
+    ecModel.eachComponent(function (mainType, componentModel) {
+      CoordinateSystem.injectCoordSysByOption({
+        targetModel: componentModel,
+        coordSysType: 'calendar',
+        coordSysProvider: CoordinateSystem.simpleCoordSysInjectionProvider
+      });
+    });
+    return calendarList;
+  };
+  Calendar.dimensions = ['time', 'value'];
+  return Calendar;
+}();
+function getCoordSys(finder) {
+  var calendarModel = finder.calendarModel;
+  var seriesModel = finder.seriesModel;
+  var coordSys = calendarModel ? calendarModel.coordinateSystem : seriesModel ? seriesModel.coordinateSystem : null;
+  return coordSys;
+}
+
+exports.default = Calendar;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/calendar/CalendarModel.js

@@ -0,0 +1,129 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var Component = require('../../model/Component.js');
+var layout = require('../../util/layout.js');
+var tokens = require('../../visual/tokens.js');
+
+var CalendarModel = /** @class */function (_super) {
+  tslib_es6.__extends(CalendarModel, _super);
+  function CalendarModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = CalendarModel.type;
+    return _this;
+  }
+  /**
+   * @override
+   */
+  CalendarModel.prototype.init = function (option, parentModel, ecModel) {
+    var inputPositionParams = layout.getLayoutParams(option);
+    _super.prototype.init.apply(this, arguments);
+    mergeAndNormalizeLayoutParams(option, inputPositionParams);
+  };
+  /**
+   * @override
+   */
+  CalendarModel.prototype.mergeOption = function (option) {
+    _super.prototype.mergeOption.apply(this, arguments);
+    mergeAndNormalizeLayoutParams(this.option, option);
+  };
+  CalendarModel.prototype.getCellSize = function () {
+    // Has been normalized
+    return this.option.cellSize;
+  };
+  CalendarModel.type = 'calendar';
+  CalendarModel.layoutMode = 'box';
+  CalendarModel.defaultOption = {
+    // zlevel: 0,
+    // TODO: theoretically, the z of the calendar should be lower
+    // than series, but we don't want the series to be displayed
+    // on top of the borders like month split line. To align with
+    // the effect of previous versions, we set the z to 2 for now
+    // until better solution is found.
+    z: 2,
+    left: 80,
+    top: 60,
+    cellSize: 20,
+    // horizontal vertical
+    orient: 'horizontal',
+    // month separate line style
+    splitLine: {
+      show: true,
+      lineStyle: {
+        color: tokens.default.color.axisLine,
+        width: 1,
+        type: 'solid'
+      }
+    },
+    // rect style  temporarily unused emphasis
+    itemStyle: {
+      color: tokens.default.color.neutral00,
+      borderWidth: 1,
+      borderColor: tokens.default.color.neutral10
+    },
+    // week text style
+    dayLabel: {
+      show: true,
+      firstDay: 0,
+      // start end
+      position: 'start',
+      margin: tokens.default.size.s,
+      color: tokens.default.color.secondary
+    },
+    // month text style
+    monthLabel: {
+      show: true,
+      // start end
+      position: 'start',
+      margin: tokens.default.size.s,
+      // center or left
+      align: 'center',
+      formatter: null,
+      color: tokens.default.color.secondary
+    },
+    // year text style
+    yearLabel: {
+      show: true,
+      // top bottom left right
+      position: null,
+      margin: tokens.default.size.xl,
+      formatter: null,
+      color: tokens.default.color.quaternary,
+      fontFamily: 'sans-serif',
+      fontWeight: 'bolder',
+      fontSize: 20
+    }
+  };
+  return CalendarModel;
+}(Component.default);
+function mergeAndNormalizeLayoutParams(target, raw) {
+  // Normalize cellSize
+  var cellSize = target.cellSize;
+  var cellSizeArr;
+  if (!util.isArray(cellSize)) {
+    cellSizeArr = target.cellSize = [cellSize, cellSize];
+  } else {
+    cellSizeArr = cellSize;
+  }
+  if (cellSizeArr.length === 1) {
+    cellSizeArr[1] = cellSizeArr[0];
+  }
+  var ignoreSize = util.map([0, 1], function (hvIdx) {
+    // If user have set `width` or both `left` and `right`, cellSizeArr
+    // will be automatically set to 'auto', otherwise the default
+    // setting of cellSizeArr will make `width` setting not work.
+    if (layout.sizeCalculable(raw, hvIdx)) {
+      cellSizeArr[hvIdx] = 'auto';
+    }
+    return cellSizeArr[hvIdx] != null && cellSizeArr[hvIdx] !== 'auto';
+  });
+  layout.mergeLayoutParam(target, raw, {
+    type: 'box',
+    ignoreSize: ignoreSize
+  });
+}
+
+exports.default = CalendarModel;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/calendar/prepareCustom.js

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/*
+* 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.
+*/
+function calendarPrepareCustom(coordSys) {
+  var rect = coordSys.getRect();
+  var rangeInfo = coordSys.getRangeInfo();
+  return {
+    coordSys: {
+      type: 'calendar',
+      x: rect.x,
+      y: rect.y,
+      width: rect.width,
+      height: rect.height,
+      cellWidth: coordSys.getCellWidth(),
+      cellHeight: coordSys.getCellHeight(),
+      rangeInfo: {
+        start: rangeInfo.start,
+        end: rangeInfo.end,
+        weeks: rangeInfo.weeks,
+        dayCount: rangeInfo.allDay
+      }
+    },
+    api: {
+      coord: function (data, clamp) {
+        return coordSys.dataToPoint(data, clamp);
+      },
+      layout: function (data, clamp) {
+        return coordSys.dataToLayout(data, clamp);
+      }
+    }
+  };
+}
+
+exports.default = calendarPrepareCustom;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/cartesian/Axis2D.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var Axis = require('../Axis.js');
+
+var Axis2D = /** @class */function (_super) {
+  tslib_es6.__extends(Axis2D, _super);
+  function Axis2D(dim, scale, coordExtent, axisType, position) {
+    var _this = _super.call(this, dim, scale, coordExtent) || this;
+    /**
+     * Index of axis, can be used as key
+     * Injected outside.
+     */
+    _this.index = 0;
+    _this.type = axisType || 'value';
+    _this.position = position || 'bottom';
+    return _this;
+  }
+  Axis2D.prototype.isHorizontal = function () {
+    var position = this.position;
+    return position === 'top' || position === 'bottom';
+  };
+  /**
+   * Each item cooresponds to this.getExtent(), which
+   * means globalExtent[0] may greater than globalExtent[1],
+   * unless `asc` is input.
+   *
+   * @param {boolean} [asc]
+   * @return {Array.<number>}
+   */
+  Axis2D.prototype.getGlobalExtent = function (asc) {
+    var ret = this.getExtent();
+    ret[0] = this.toGlobalCoord(ret[0]);
+    ret[1] = this.toGlobalCoord(ret[1]);
+    asc && ret[0] > ret[1] && ret.reverse();
+    return ret;
+  };
+  Axis2D.prototype.pointToData = function (point, clamp) {
+    return this.coordToData(this.toLocalCoord(point[this.dim === 'x' ? 0 : 1]), clamp);
+  };
+  /**
+   * Set ordinalSortInfo
+   * @param info new OrdinalSortInfo
+   */
+  Axis2D.prototype.setCategorySortInfo = function (info) {
+    if (this.type !== 'category') {
+      return false;
+    }
+    this.model.option.categorySortInfo = info;
+    this.scale.setSortInfo(info);
+  };
+  return Axis2D;
+}(Axis.default);
+
+exports.default = Axis2D;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/cartesian/AxisModel.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var Component = require('../../model/Component.js');
+var axisModelCommonMixin = require('../axisModelCommonMixin.js');
+var model = require('../../util/model.js');
+
+var CartesianAxisModel = /** @class */function (_super) {
+  tslib_es6.__extends(CartesianAxisModel, _super);
+  function CartesianAxisModel() {
+    return _super !== null && _super.apply(this, arguments) || this;
+  }
+  CartesianAxisModel.prototype.getCoordSysModel = function () {
+    return this.getReferringComponents('grid', model.SINGLE_REFERRING).models[0];
+  };
+  CartesianAxisModel.type = 'cartesian2dAxis';
+  return CartesianAxisModel;
+}(Component.default);
+util.mixin(CartesianAxisModel, axisModelCommonMixin.AxisModelCommonMixin);
+
+exports.CartesianAxisModel = CartesianAxisModel;
+exports.default = CartesianAxisModel;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/coord/cartesian/Cartesian.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+var Cartesian = /** @class */function () {
+  function Cartesian(name) {
+    this.type = 'cartesian';
+    this._dimList = [];
+    this._axes = {};
+    this.name = name || '';
+  }
+  Cartesian.prototype.getAxis = function (dim) {
+    return this._axes[dim];
+  };
+  Cartesian.prototype.getAxes = function () {
+    return util.map(this._dimList, function (dim) {
+      return this._axes[dim];
+    }, this);
+  };
+  Cartesian.prototype.getAxesByScale = function (scaleType) {
+    scaleType = scaleType.toLowerCase();
+    return util.filter(this.getAxes(), function (axis) {
+      return axis.scale.type === scaleType;
+    });
+  };
+  Cartesian.prototype.addAxis = function (axis) {
+    var dim = axis.dim;
+    this._axes[dim] = axis;
+    this._dimList.push(dim);
+  };
+  return Cartesian;
+}();
+;
+
+exports.default = Cartesian;