@fmdevui/fm-dev 1.0.113 → 1.0.115

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/dataZoom/dataZoomAction.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helper = require('./helper.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+function installDataZoomAction(registers) {
+  registers.registerAction('dataZoom', function (payload, ecModel) {
+    var effectedModels = helper.findEffectedDataZooms(ecModel, payload);
+    util.each(effectedModels, function (dataZoomModel) {
+      dataZoomModel.setRawRange({
+        start: payload.start,
+        end: payload.end,
+        startValue: payload.startValue,
+        endValue: payload.endValue
+      });
+    });
+  });
+}
+
+exports.default = installDataZoomAction;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/dataZoom/dataZoomProcessor.js

@@ -0,0 +1,93 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var helper = require('./helper.js');
+var AxisProxy = require('./AxisProxy.js');
+
+var dataZoomProcessor = {
+  // `dataZoomProcessor` will only be performed in needed series. Consider if
+  // there is a line series and a pie series, it is better not to update the
+  // line series if only pie series is needed to be updated.
+  getTargetSeries: function (ecModel) {
+    function eachAxisModel(cb) {
+      ecModel.eachComponent('dataZoom', function (dataZoomModel) {
+        dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+          var axisModel = ecModel.getComponent(helper.getAxisMainType(axisDim), axisIndex);
+          cb(axisDim, axisIndex, axisModel, dataZoomModel);
+        });
+      });
+    }
+    // FIXME: it brings side-effect to `getTargetSeries`.
+    // Prepare axis proxies.
+    eachAxisModel(function (axisDim, axisIndex, axisModel, dataZoomModel) {
+      // dispose all last axis proxy, in case that some axis are deleted.
+      axisModel.__dzAxisProxy = null;
+    });
+    var proxyList = [];
+    eachAxisModel(function (axisDim, axisIndex, axisModel, dataZoomModel) {
+      // Different dataZooms may constrol the same axis. In that case,
+      // an axisProxy serves both of them.
+      if (!axisModel.__dzAxisProxy) {
+        // Use the first dataZoomModel as the main model of axisProxy.
+        axisModel.__dzAxisProxy = new AxisProxy.default(axisDim, axisIndex, dataZoomModel, ecModel);
+        proxyList.push(axisModel.__dzAxisProxy);
+      }
+    });
+    var seriesModelMap = util.createHashMap();
+    util.each(proxyList, function (axisProxy) {
+      util.each(axisProxy.getTargetSeriesModels(), function (seriesModel) {
+        seriesModelMap.set(seriesModel.uid, seriesModel);
+      });
+    });
+    return seriesModelMap;
+  },
+  // Consider appendData, where filter should be performed. Because data process is
+  // in block mode currently, it is not need to worry about that the overallProgress
+  // execute every frame.
+  overallReset: function (ecModel, api) {
+    ecModel.eachComponent('dataZoom', function (dataZoomModel) {
+      // We calculate window and reset axis here but not in model
+      // init stage and not after action dispatch handler, because
+      // reset should be called after seriesData.restoreData.
+      dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+        dataZoomModel.getAxisProxy(axisDim, axisIndex).reset(dataZoomModel);
+      });
+      // Caution: data zoom filtering is order sensitive when using
+      // percent range and no min/max/scale set on axis.
+      // For example, we have dataZoom definition:
+      // [
+      //      {xAxisIndex: 0, start: 30, end: 70},
+      //      {yAxisIndex: 0, start: 20, end: 80}
+      // ]
+      // In this case, [20, 80] of y-dataZoom should be based on data
+      // that have filtered by x-dataZoom using range of [30, 70],
+      // but should not be based on full raw data. Thus sliding
+      // x-dataZoom will change both ranges of xAxis and yAxis,
+      // while sliding y-dataZoom will only change the range of yAxis.
+      // So we should filter x-axis after reset x-axis immediately,
+      // and then reset y-axis and filter y-axis.
+      dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+        dataZoomModel.getAxisProxy(axisDim, axisIndex).filterData(dataZoomModel, api);
+      });
+    });
+    ecModel.eachComponent('dataZoom', function (dataZoomModel) {
+      // Fullfill all of the range props so that user
+      // is able to get them from chart.getOption().
+      var axisProxy = dataZoomModel.findRepresentativeAxisProxy();
+      if (axisProxy) {
+        var percentRange = axisProxy.getDataPercentWindow();
+        var valueRange = axisProxy.getDataValueWindow();
+        dataZoomModel.setCalculatedRange({
+          start: percentRange[0],
+          end: percentRange[1],
+          startValue: valueRange[0],
+          endValue: valueRange[1]
+        });
+      }
+    });
+  }
+};
+
+exports.default = dataZoomProcessor;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/dataZoom/helper.js

@@ -0,0 +1,140 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+var DATA_ZOOM_AXIS_DIMENSIONS = ['x', 'y', 'radius', 'angle', 'single'];
+// Supported coords.
+// FIXME: polar has been broken (but rarely used).
+var SERIES_COORDS = ['cartesian2d', 'polar', 'singleAxis'];
+function isCoordSupported(seriesModel) {
+  var coordType = seriesModel.get('coordinateSystem');
+  return util.indexOf(SERIES_COORDS, coordType) >= 0;
+}
+function getAxisMainType(axisDim) {
+  if (process.env.NODE_ENV !== 'production') {
+    util.assert(axisDim);
+  }
+  return axisDim + 'Axis';
+}
+function getAxisIndexPropName(axisDim) {
+  if (process.env.NODE_ENV !== 'production') {
+    util.assert(axisDim);
+  }
+  return axisDim + 'AxisIndex';
+}
+function getAxisIdPropName(axisDim) {
+  if (process.env.NODE_ENV !== 'production') {
+    util.assert(axisDim);
+  }
+  return axisDim + 'AxisId';
+}
+/**
+ * If two dataZoomModels has the same axis controlled, we say that they are 'linked'.
+ * This function finds all linked dataZoomModels start from the given payload.
+ */
+function findEffectedDataZooms(ecModel, payload) {
+  // Key: `DataZoomAxisDimension`
+  var axisRecords = util.createHashMap();
+  var effectedModels = [];
+  // Key: uid of dataZoomModel
+  var effectedModelMap = util.createHashMap();
+  // Find the dataZooms specified by payload.
+  ecModel.eachComponent({
+    mainType: 'dataZoom',
+    query: payload
+  }, function (dataZoomModel) {
+    if (!effectedModelMap.get(dataZoomModel.uid)) {
+      addToEffected(dataZoomModel);
+    }
+  });
+  // Start from the given dataZoomModels, travel the graph to find
+  // all of the linked dataZoom models.
+  var foundNewLink;
+  do {
+    foundNewLink = false;
+    ecModel.eachComponent('dataZoom', processSingle);
+  } while (foundNewLink);
+  function processSingle(dataZoomModel) {
+    if (!effectedModelMap.get(dataZoomModel.uid) && isLinked(dataZoomModel)) {
+      addToEffected(dataZoomModel);
+      foundNewLink = true;
+    }
+  }
+  function addToEffected(dataZoom) {
+    effectedModelMap.set(dataZoom.uid, true);
+    effectedModels.push(dataZoom);
+    markAxisControlled(dataZoom);
+  }
+  function isLinked(dataZoomModel) {
+    var isLink = false;
+    dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+      var axisIdxArr = axisRecords.get(axisDim);
+      if (axisIdxArr && axisIdxArr[axisIndex]) {
+        isLink = true;
+      }
+    });
+    return isLink;
+  }
+  function markAxisControlled(dataZoomModel) {
+    dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+      (axisRecords.get(axisDim) || axisRecords.set(axisDim, []))[axisIndex] = true;
+    });
+  }
+  return effectedModels;
+}
+/**
+ * Find the first target coordinate system.
+ * Available after model built.
+ *
+ * @return Like {
+ *                  grid: [
+ *                      {model: coord0, axisModels: [axis1, axis3], coordIndex: 1},
+ *                      {model: coord1, axisModels: [axis0, axis2], coordIndex: 0},
+ *                      ...
+ *                  ],  // cartesians must not be null/undefined.
+ *                  polar: [
+ *                      {model: coord0, axisModels: [axis4], coordIndex: 0},
+ *                      ...
+ *                  ],  // polars must not be null/undefined.
+ *                  singleAxis: [
+ *                      {model: coord0, axisModels: [], coordIndex: 0}
+ *                  ]
+ *              }
+ */
+function collectReferCoordSysModelInfo(dataZoomModel) {
+  var ecModel = dataZoomModel.ecModel;
+  var coordSysInfoWrap = {
+    infoList: [],
+    infoMap: util.createHashMap()
+  };
+  dataZoomModel.eachTargetAxis(function (axisDim, axisIndex) {
+    var axisModel = ecModel.getComponent(getAxisMainType(axisDim), axisIndex);
+    if (!axisModel) {
+      return;
+    }
+    var coordSysModel = axisModel.getCoordSysModel();
+    if (!coordSysModel) {
+      return;
+    }
+    var coordSysUid = coordSysModel.uid;
+    var coordSysInfo = coordSysInfoWrap.infoMap.get(coordSysUid);
+    if (!coordSysInfo) {
+      coordSysInfo = {
+        model: coordSysModel,
+        axisModels: []
+      };
+      coordSysInfoWrap.infoList.push(coordSysInfo);
+      coordSysInfoWrap.infoMap.set(coordSysUid, coordSysInfo);
+    }
+    coordSysInfo.axisModels.push(axisModel);
+  });
+  return coordSysInfoWrap;
+}
+
+exports.DATA_ZOOM_AXIS_DIMENSIONS = DATA_ZOOM_AXIS_DIMENSIONS;
+exports.collectReferCoordSysModelInfo = collectReferCoordSysModelInfo;
+exports.findEffectedDataZooms = findEffectedDataZooms;
+exports.getAxisIdPropName = getAxisIdPropName;
+exports.getAxisIndexPropName = getAxisIndexPropName;
+exports.getAxisMainType = getAxisMainType;
+exports.isCoordSupported = isCoordSupported;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/dataZoom/history.js

@@ -0,0 +1,81 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var model = require('../../util/model.js');
+
+var each = util.each;
+var inner = model.makeInner();
+/**
+ * @param ecModel
+ * @param newSnapshot key is dataZoomId
+ */
+function push(ecModel, newSnapshot) {
+  var storedSnapshots = getStoreSnapshots(ecModel);
+  // If previous dataZoom can not be found,
+  // complete an range with current range.
+  each(newSnapshot, function (batchItem, dataZoomId) {
+    var i = storedSnapshots.length - 1;
+    for (; i >= 0; i--) {
+      var snapshot = storedSnapshots[i];
+      if (snapshot[dataZoomId]) {
+        break;
+      }
+    }
+    if (i < 0) {
+      // No origin range set, create one by current range.
+      var dataZoomModel = ecModel.queryComponents({
+        mainType: 'dataZoom',
+        subType: 'select',
+        id: dataZoomId
+      })[0];
+      if (dataZoomModel) {
+        var percentRange = dataZoomModel.getPercentRange();
+        storedSnapshots[0][dataZoomId] = {
+          dataZoomId: dataZoomId,
+          start: percentRange[0],
+          end: percentRange[1]
+        };
+      }
+    }
+  });
+  storedSnapshots.push(newSnapshot);
+}
+function pop(ecModel) {
+  var storedSnapshots = getStoreSnapshots(ecModel);
+  var head = storedSnapshots[storedSnapshots.length - 1];
+  storedSnapshots.length > 1 && storedSnapshots.pop();
+  // Find top for all dataZoom.
+  var snapshot = {};
+  each(head, function (batchItem, dataZoomId) {
+    for (var i = storedSnapshots.length - 1; i >= 0; i--) {
+      batchItem = storedSnapshots[i][dataZoomId];
+      if (batchItem) {
+        snapshot[dataZoomId] = batchItem;
+        break;
+      }
+    }
+  });
+  return snapshot;
+}
+function clear(ecModel) {
+  inner(ecModel).snapshots = null;
+}
+function count(ecModel) {
+  return getStoreSnapshots(ecModel).length;
+}
+/**
+ * History length of each dataZoom may be different.
+ * this._history[0] is used to store origin range.
+ */
+function getStoreSnapshots(ecModel) {
+  var store = inner(ecModel);
+  if (!store.snapshots) {
+    store.snapshots = [{}];
+  }
+  return store.snapshots;
+}
+
+exports.clear = clear;
+exports.count = count;
+exports.pop = pop;
+exports.push = push;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/dataZoom/install.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var extension = require('../../extension.js');
+var installDataZoomInside = require('./installDataZoomInside.js');
+var installDataZoomSlider = require('./installDataZoomSlider.js');
+
+function install(registers) {
+  extension.use(installDataZoomInside.install);
+  extension.use(installDataZoomSlider.install);
+  // Do not install './dataZoomSelect',
+  // since it only work for toolbox dataZoom.
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/dataZoom/installCommon.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dataZoomProcessor = require('./dataZoomProcessor.js');
+var dataZoomAction = require('./dataZoomAction.js');
+
+var installed = false;
+function installCommon(registers) {
+  if (installed) {
+    return;
+  }
+  installed = true;
+  registers.registerProcessor(registers.PRIORITY.PROCESSOR.FILTER, dataZoomProcessor.default);
+  dataZoomAction.default(registers);
+  registers.registerSubTypeDefaulter('dataZoom', function () {
+    // Default 'slider' when no type specified.
+    return 'slider';
+  });
+}
+
+exports.default = installCommon;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/dataZoom/installDataZoomInside.js

@@ -0,0 +1,15 @@
+'use strict';
+
+var InsideZoomModel = require('./InsideZoomModel.js');
+var InsideZoomView = require('./InsideZoomView.js');
+var roams = require('./roams.js');
+var installCommon = require('./installCommon.js');
+
+function install(registers) {
+  installCommon.default(registers);
+  registers.registerComponentModel(InsideZoomModel.default);
+  registers.registerComponentView(InsideZoomView.default);
+  roams.installDataZoomRoamProcessor(registers);
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/dataZoom/installDataZoomSelect.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var SelectZoomModel = require('./SelectZoomModel.js');
+var SelectZoomView = require('./SelectZoomView.js');
+var installCommon = require('./installCommon.js');
+
+function install(registers) {
+  registers.registerComponentModel(SelectZoomModel.default);
+  registers.registerComponentView(SelectZoomView.default);
+  installCommon.default(registers);
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/dataZoom/installDataZoomSlider.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var SliderZoomModel = require('./SliderZoomModel.js');
+var SliderZoomView = require('./SliderZoomView.js');
+var installCommon = require('./installCommon.js');
+
+function install(registers) {
+  registers.registerComponentModel(SliderZoomModel.default);
+  registers.registerComponentView(SliderZoomView.default);
+  installCommon.default(registers);
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/dataZoom/roams.js

@@ -0,0 +1,193 @@
+'use strict';
+
+var RoamController = require('../helper/RoamController.js');
+var throttle = require('../../util/throttle.js');
+var model = require('../../util/model.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var helper = require('./helper.js');
+
+var inner = model.makeInner();
+function setViewInfoToCoordSysRecord(api, dataZoomModel, getRange) {
+  inner(api).coordSysRecordMap.each(function (coordSysRecord) {
+    var dzInfo = coordSysRecord.dataZoomInfoMap.get(dataZoomModel.uid);
+    if (dzInfo) {
+      dzInfo.getRange = getRange;
+    }
+  });
+}
+function disposeCoordSysRecordIfNeeded(api, dataZoomModel) {
+  var coordSysRecordMap = inner(api).coordSysRecordMap;
+  var coordSysKeyArr = coordSysRecordMap.keys();
+  for (var i = 0; i < coordSysKeyArr.length; i++) {
+    var coordSysKey = coordSysKeyArr[i];
+    var coordSysRecord = coordSysRecordMap.get(coordSysKey);
+    var dataZoomInfoMap = coordSysRecord.dataZoomInfoMap;
+    if (dataZoomInfoMap) {
+      var dzUid = dataZoomModel.uid;
+      var dzInfo = dataZoomInfoMap.get(dzUid);
+      if (dzInfo) {
+        dataZoomInfoMap.removeKey(dzUid);
+        if (!dataZoomInfoMap.keys().length) {
+          disposeCoordSysRecord(coordSysRecordMap, coordSysRecord);
+        }
+      }
+    }
+  }
+}
+function disposeCoordSysRecord(coordSysRecordMap, coordSysRecord) {
+  if (coordSysRecord) {
+    coordSysRecordMap.removeKey(coordSysRecord.model.uid);
+    var controller = coordSysRecord.controller;
+    controller && controller.dispose();
+  }
+}
+function createCoordSysRecord(api, coordSysModel) {
+  // These init props will never change after record created.
+  var coordSysRecord = {
+    model: coordSysModel,
+    containsPoint: util.curry(containsPoint, coordSysModel),
+    dispatchAction: util.curry(dispatchAction, api),
+    dataZoomInfoMap: null,
+    controller: null
+  };
+  // Must not do anything depends on coordSysRecord outside the event handler here,
+  // because coordSysRecord not completed yet.
+  var controller = coordSysRecord.controller = new RoamController.default(api.getZr());
+  util.each(['pan', 'zoom', 'scrollMove'], function (eventName) {
+    controller.on(eventName, function (event) {
+      var batch = [];
+      coordSysRecord.dataZoomInfoMap.each(function (dzInfo) {
+        // Check whether the behaviors (zoomOnMouseWheel, moveOnMouseMove,
+        // moveOnMouseWheel, ...) enabled.
+        if (!event.isAvailableBehavior(dzInfo.model.option)) {
+          return;
+        }
+        var method = (dzInfo.getRange || {})[eventName];
+        var range = method && method(dzInfo.dzReferCoordSysInfo, coordSysRecord.model.mainType, coordSysRecord.controller, event);
+        !dzInfo.model.get('disabled', true) && range && batch.push({
+          dataZoomId: dzInfo.model.id,
+          start: range[0],
+          end: range[1]
+        });
+      });
+      batch.length && coordSysRecord.dispatchAction(batch);
+    });
+  });
+  return coordSysRecord;
+}
+/**
+ * This action will be throttled.
+ */
+function dispatchAction(api, batch) {
+  if (!api.isDisposed()) {
+    api.dispatchAction({
+      type: 'dataZoom',
+      animation: {
+        easing: 'cubicOut',
+        duration: 100
+      },
+      batch: batch
+    });
+  }
+}
+function containsPoint(coordSysModel, e, x, y) {
+  return coordSysModel.coordinateSystem.containPoint([x, y]);
+}
+/**
+ * Merge roamController settings when multiple dataZooms share one roamController.
+ */
+function mergeControllerParams(dataZoomInfoMap, coordSysRecord, api) {
+  var controlType;
+  // DO NOT use reserved word (true, false, undefined) as key literally. Even if encapsulated
+  // as string, it is probably revert to reserved word by compress tool. See #7411.
+  var prefix = 'type_';
+  var typePriority = {
+    'type_true': 2,
+    'type_move': 1,
+    'type_false': 0,
+    'type_undefined': -1
+  };
+  var preventDefaultMouseMove = true;
+  dataZoomInfoMap.each(function (dataZoomInfo) {
+    var dataZoomModel = dataZoomInfo.model;
+    var oneType = dataZoomModel.get('disabled', true) ? false : dataZoomModel.get('zoomLock', true) ? 'move' : true;
+    if (typePriority[prefix + oneType] > typePriority[prefix + controlType]) {
+      controlType = oneType;
+    }
+    // Prevent default move event by default. If one false, do not prevent. Otherwise
+    // users may be confused why it does not work when multiple insideZooms exist.
+    preventDefaultMouseMove = preventDefaultMouseMove && dataZoomModel.get('preventDefaultMouseMove', true);
+  });
+  return {
+    controlType: controlType,
+    opt: {
+      // RoamController will enable all of these functionalities,
+      // and the final behavior is determined by its event listener
+      // provided by each inside zoom.
+      zoomOnMouseWheel: true,
+      moveOnMouseMove: true,
+      moveOnMouseWheel: true,
+      preventDefaultMouseMove: !!preventDefaultMouseMove,
+      api: api,
+      zInfo: {
+        component: coordSysRecord.model
+      },
+      triggerInfo: {
+        roamTrigger: null,
+        isInSelf: coordSysRecord.containsPoint
+      }
+    }
+  };
+}
+function installDataZoomRoamProcessor(registers) {
+  registers.registerProcessor(registers.PRIORITY.PROCESSOR.FILTER, function (ecModel, api) {
+    var apiInner = inner(api);
+    var coordSysRecordMap = apiInner.coordSysRecordMap || (apiInner.coordSysRecordMap = util.createHashMap());
+    coordSysRecordMap.each(function (coordSysRecord) {
+      // `coordSysRecordMap` always exists (because it holds the `roam controller`, which should
+      // better not re-create each time), but clear `dataZoomInfoMap` each round of the workflow.
+      coordSysRecord.dataZoomInfoMap = null;
+    });
+    ecModel.eachComponent({
+      mainType: 'dataZoom',
+      subType: 'inside'
+    }, function (dataZoomModel) {
+      var dzReferCoordSysWrap = helper.collectReferCoordSysModelInfo(dataZoomModel);
+      util.each(dzReferCoordSysWrap.infoList, function (dzCoordSysInfo) {
+        var coordSysUid = dzCoordSysInfo.model.uid;
+        var coordSysRecord = coordSysRecordMap.get(coordSysUid) || coordSysRecordMap.set(coordSysUid, createCoordSysRecord(api, dzCoordSysInfo.model));
+        var dataZoomInfoMap = coordSysRecord.dataZoomInfoMap || (coordSysRecord.dataZoomInfoMap = util.createHashMap());
+        // Notice these props might be changed each time for a single dataZoomModel.
+        dataZoomInfoMap.set(dataZoomModel.uid, {
+          dzReferCoordSysInfo: dzCoordSysInfo,
+          model: dataZoomModel,
+          getRange: null
+        });
+      });
+    });
+    // (1) Merge dataZoom settings for each coord sys and set to the roam controller.
+    // (2) Clear coord sys if not refered by any dataZoom.
+    coordSysRecordMap.each(function (coordSysRecord) {
+      var controller = coordSysRecord.controller;
+      var firstDzInfo;
+      var dataZoomInfoMap = coordSysRecord.dataZoomInfoMap;
+      if (dataZoomInfoMap) {
+        var firstDzKey = dataZoomInfoMap.keys()[0];
+        if (firstDzKey != null) {
+          firstDzInfo = dataZoomInfoMap.get(firstDzKey);
+        }
+      }
+      if (!firstDzInfo) {
+        disposeCoordSysRecord(coordSysRecordMap, coordSysRecord);
+        return;
+      }
+      var controllerParams = mergeControllerParams(dataZoomInfoMap, coordSysRecord, api);
+      controller.enable(controllerParams.controlType, controllerParams.opt);
+      throttle.createOrUpdate(coordSysRecord, 'dispatchAction', firstDzInfo.model.get('throttle', true), 'fixRate');
+    });
+  });
+}
+
+exports.disposeCoordSysRecordIfNeeded = disposeCoordSysRecordIfNeeded;
+exports.installDataZoomRoamProcessor = installDataZoomRoamProcessor;
+exports.setViewInfoToCoordSysRecord = setViewInfoToCoordSysRecord;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/dataset/install.js

@@ -0,0 +1,53 @@
+'use strict';
+
+var tslib_es6 = require('../../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js');
+var Component = require('../../model/Component.js');
+var Component$1 = require('../../view/Component.js');
+var types = require('../../util/types.js');
+var sourceManager = require('../../data/helper/sourceManager.js');
+
+var DatasetModel = /** @class */function (_super) {
+  tslib_es6.__extends(DatasetModel, _super);
+  function DatasetModel() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = 'dataset';
+    return _this;
+  }
+  DatasetModel.prototype.init = function (option, parentModel, ecModel) {
+    _super.prototype.init.call(this, option, parentModel, ecModel);
+    this._sourceManager = new sourceManager.SourceManager(this);
+    sourceManager.disableTransformOptionMerge(this);
+  };
+  DatasetModel.prototype.mergeOption = function (newOption, ecModel) {
+    _super.prototype.mergeOption.call(this, newOption, ecModel);
+    sourceManager.disableTransformOptionMerge(this);
+  };
+  DatasetModel.prototype.optionUpdated = function () {
+    this._sourceManager.dirty();
+  };
+  DatasetModel.prototype.getSourceManager = function () {
+    return this._sourceManager;
+  };
+  DatasetModel.type = 'dataset';
+  DatasetModel.defaultOption = {
+    seriesLayoutBy: types.SERIES_LAYOUT_BY_COLUMN
+  };
+  return DatasetModel;
+}(Component.default);
+var DatasetView = /** @class */function (_super) {
+  tslib_es6.__extends(DatasetView, _super);
+  function DatasetView() {
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    _this.type = 'dataset';
+    return _this;
+  }
+  DatasetView.type = 'dataset';
+  return DatasetView;
+}(Component$1.default);
+function install(registers) {
+  registers.registerComponentModel(DatasetModel);
+  registers.registerComponentView(DatasetView);
+}
+
+exports.DatasetModel = DatasetModel;
+exports.install = install;