office-viewer 0.3.12 → 0.3.14

package/esm/node_modules/echarts/lib/animation/universalTransition.js

@@ -1,608 +0,0 @@
-import { SERIES_UNIVERSAL_TRANSITION_PROP } from '../model/Series.js';
-import { each, createHashMap, filter, map, isArray, extend } from '../../../zrender/lib/core/util.js';
-import { applyMorphAnimation, getPathList } from './morphTransitionHelper.js';
-import Path from '../../../zrender/lib/graphic/Path.js';
-import '../util/graphic.js';
-import DataDiffer from '../data/DataDiffer.js';
-import { normalizeToArray, makeInner } from '../util/model.js';
-import { warn } from '../util/log.js';
-import { getAnimationConfig, initProps, getOldStyle } from './basicTransition.js';
-import Displayable from '../../../zrender/lib/graphic/Displayable.js';
-
-var DATA_COUNT_THRESHOLD = 1e4;
-var TRANSITION_NONE = 0;
-var TRANSITION_P2C = 1;
-var TRANSITION_C2P = 2;
-var getUniversalTransitionGlobalStore = makeInner();
-function getDimension(data, visualDimension) {
-  var dimensions = data.dimensions;
-  for (var i = 0; i < dimensions.length; i++) {
-    var dimInfo = data.getDimensionInfo(dimensions[i]);
-    if (dimInfo && dimInfo.otherDims[visualDimension] === 0) {
-      return dimensions[i];
-    }
-  }
-}
-// get value by dimension. (only get value of itemGroupId or childGroupId, so convert it to string)
-function getValueByDimension(data, dataIndex, dimension) {
-  var dimInfo = data.getDimensionInfo(dimension);
-  var dimOrdinalMeta = dimInfo && dimInfo.ordinalMeta;
-  if (dimInfo) {
-    var value = data.get(dimInfo.name, dataIndex);
-    if (dimOrdinalMeta) {
-      return dimOrdinalMeta.categories[value] || value + '';
-    }
-    return value + '';
-  }
-}
-function getGroupId(data, dataIndex, dataGroupId, isChild) {
-  // try to get groupId from encode
-  var visualDimension = isChild ? 'itemChildGroupId' : 'itemGroupId';
-  var groupIdDim = getDimension(data, visualDimension);
-  if (groupIdDim) {
-    var groupId = getValueByDimension(data, dataIndex, groupIdDim);
-    return groupId;
-  }
-  // try to get groupId from raw data item
-  var rawDataItem = data.getRawDataItem(dataIndex);
-  var property = isChild ? 'childGroupId' : 'groupId';
-  if (rawDataItem && rawDataItem[property]) {
-    return rawDataItem[property] + '';
-  }
-  // fallback
-  if (isChild) {
-    return;
-  }
-  // try to use series.dataGroupId as groupId, otherwise use dataItem's id as groupId
-  return dataGroupId || data.getId(dataIndex);
-}
-// flatten all data items from different serieses into one arrary
-function flattenDataDiffItems(list) {
-  var items = [];
-  each(list, function (seriesInfo) {
-    var data = seriesInfo.data;
-    var dataGroupId = seriesInfo.dataGroupId;
-    if (data.count() > DATA_COUNT_THRESHOLD) {
-      if (process.env.NODE_ENV !== 'production') {
-        warn('Universal transition is disabled on large data > 10k.');
-      }
-      return;
-    }
-    var indices = data.getIndices();
-    for (var dataIndex = 0; dataIndex < indices.length; dataIndex++) {
-      items.push({
-        data: data,
-        groupId: getGroupId(data, dataIndex, dataGroupId, false),
-        childGroupId: getGroupId(data, dataIndex, dataGroupId, true),
-        divide: seriesInfo.divide,
-        dataIndex: dataIndex
-      });
-    }
-  });
-  return items;
-}
-function fadeInElement(newEl, newSeries, newIndex) {
-  newEl.traverse(function (el) {
-    if (el instanceof Path) {
-      // TODO use fade in animation for target element.
-      initProps(el, {
-        style: {
-          opacity: 0
-        }
-      }, newSeries, {
-        dataIndex: newIndex,
-        isFrom: true
-      });
-    }
-  });
-}
-function removeEl(el) {
-  if (el.parent) {
-    // Bake parent transform to element.
-    // So it can still have proper transform to transition after it's removed.
-    var computedTransform = el.getComputedTransform();
-    el.setLocalTransform(computedTransform);
-    el.parent.remove(el);
-  }
-}
-function stopAnimation(el) {
-  el.stopAnimation();
-  if (el.isGroup) {
-    el.traverse(function (child) {
-      child.stopAnimation();
-    });
-  }
-}
-function animateElementStyles(el, dataIndex, seriesModel) {
-  var animationConfig = getAnimationConfig('update', seriesModel, dataIndex);
-  animationConfig && el.traverse(function (child) {
-    if (child instanceof Displayable) {
-      var oldStyle = getOldStyle(child);
-      if (oldStyle) {
-        child.animateFrom({
-          style: oldStyle
-        }, animationConfig);
-      }
-    }
-  });
-}
-function isAllIdSame(oldDiffItems, newDiffItems) {
-  var len = oldDiffItems.length;
-  if (len !== newDiffItems.length) {
-    return false;
-  }
-  for (var i = 0; i < len; i++) {
-    var oldItem = oldDiffItems[i];
-    var newItem = newDiffItems[i];
-    if (oldItem.data.getId(oldItem.dataIndex) !== newItem.data.getId(newItem.dataIndex)) {
-      return false;
-    }
-  }
-  return true;
-}
-function transitionBetween(oldList, newList, api) {
-  var oldDiffItems = flattenDataDiffItems(oldList);
-  var newDiffItems = flattenDataDiffItems(newList);
-  function updateMorphingPathProps(from, to, rawFrom, rawTo, animationCfg) {
-    if (rawFrom || from) {
-      to.animateFrom({
-        style: rawFrom && rawFrom !== from
-        // dividingMethod like clone may override the style(opacity)
-        // So extend it to raw style.
-        ? extend(extend({}, rawFrom.style), from.style) : from.style
-      }, animationCfg);
-    }
-  }
-  var hasMorphAnimation = false;
-  /**
-   * With groupId and childGroupId, we can build parent-child relationships between dataItems.
-   * However, we should mind the parent-child "direction" between old and new options.
-   *
-   * For example, suppose we have two dataItems from two series.data:
-   *
-   * dataA: [                          dataB: [
-   *   {                                 {
-   *     value: 5,                         value: 3,
-   *     groupId: 'creatures',             groupId: 'animals',
-   *     childGroupId: 'animals'           childGroupId: 'dogs'
-   *   },                                },
-   *   ...                               ...
-   * ]                                 ]
-   *
-   * where dataA is belong to optionA and dataB is belong to optionB.
-   *
-   * When we `setOption(optionB)` from optionA, we choose childGroupId of dataItemA and groupId of
-   * dataItemB as keys so the two keys are matched (both are 'animals'), then universalTransition
-   * will work. This derection is "parent -> child".
-   *
-   * If we `setOption(optionA)` from optionB, we also choose groupId of dataItemB and childGroupId
-   * of dataItemA as keys and universalTransition will work. This derection is "child -> parent".
-   *
-   * If there is no childGroupId specified, which means no multiLevelDrillDown/Up is needed and no
-   * parent-child relationship exists. This direction is "none".
-   *
-   * So we need to know whether to use groupId or childGroupId as the key when we call the keyGetter
-   * functions. Thus, we need to decide the direction first.
-   *
-   * The rule is:
-   *
-   * if (all childGroupIds in oldDiffItems and all groupIds in newDiffItems have common value) {
-   *   direction = 'parent -> child';
-   * } else if (all groupIds in oldDiffItems and all childGroupIds in newDiffItems have common value) {
-   *   direction = 'child -> parent';
-   * } else {
-   *   direction = 'none';
-   * }
-   */
-  var direction = TRANSITION_NONE;
-  // find all groupIds and childGroupIds from oldDiffItems
-  var oldGroupIds = createHashMap();
-  var oldChildGroupIds = createHashMap();
-  oldDiffItems.forEach(function (item) {
-    item.groupId && oldGroupIds.set(item.groupId, true);
-    item.childGroupId && oldChildGroupIds.set(item.childGroupId, true);
-  });
-  // traverse newDiffItems and decide the direction according to the rule
-  for (var i = 0; i < newDiffItems.length; i++) {
-    var newGroupId = newDiffItems[i].groupId;
-    if (oldChildGroupIds.get(newGroupId)) {
-      direction = TRANSITION_P2C;
-      break;
-    }
-    var newChildGroupId = newDiffItems[i].childGroupId;
-    if (newChildGroupId && oldGroupIds.get(newChildGroupId)) {
-      direction = TRANSITION_C2P;
-      break;
-    }
-  }
-  function createKeyGetter(isOld, onlyGetId) {
-    return function (diffItem) {
-      var data = diffItem.data;
-      var dataIndex = diffItem.dataIndex;
-      // TODO if specified dim
-      if (onlyGetId) {
-        return data.getId(dataIndex);
-      }
-      if (isOld) {
-        return direction === TRANSITION_P2C ? diffItem.childGroupId : diffItem.groupId;
-      } else {
-        return direction === TRANSITION_C2P ? diffItem.childGroupId : diffItem.groupId;
-      }
-    };
-  }
-  // Use id if it's very likely to be an one to one animation
-  // It's more robust than groupId
-  // TODO Check if key dimension is specified.
-  var useId = isAllIdSame(oldDiffItems, newDiffItems);
-  var isElementStillInChart = {};
-  if (!useId) {
-    // We may have different diff strategy with basicTransition if we use other dimension as key.
-    // If so, we can't simply check if oldEl is same with newEl. We need a map to check if oldEl is still being used in the new chart.
-    // We can't use the elements that already being morphed. Let it keep it's original basic transition.
-    for (var i = 0; i < newDiffItems.length; i++) {
-      var newItem = newDiffItems[i];
-      var el = newItem.data.getItemGraphicEl(newItem.dataIndex);
-      if (el) {
-        isElementStillInChart[el.id] = true;
-      }
-    }
-  }
-  function updateOneToOne(newIndex, oldIndex) {
-    var oldItem = oldDiffItems[oldIndex];
-    var newItem = newDiffItems[newIndex];
-    var newSeries = newItem.data.hostModel;
-    // TODO Mark this elements is morphed and don't morph them anymore
-    var oldEl = oldItem.data.getItemGraphicEl(oldItem.dataIndex);
-    var newEl = newItem.data.getItemGraphicEl(newItem.dataIndex);
-    // Can't handle same elements.
-    if (oldEl === newEl) {
-      newEl && animateElementStyles(newEl, newItem.dataIndex, newSeries);
-      return;
-    }
-    if (
-    // We can't use the elements that already being morphed
-    oldEl && isElementStillInChart[oldEl.id]) {
-      return;
-    }
-    if (newEl) {
-      // TODO: If keep animating the group in case
-      // some of the elements don't want to be morphed.
-      // TODO Label?
-      stopAnimation(newEl);
-      if (oldEl) {
-        stopAnimation(oldEl);
-        // If old element is doing leaving animation. stop it and remove it immediately.
-        removeEl(oldEl);
-        hasMorphAnimation = true;
-        applyMorphAnimation(getPathList(oldEl), getPathList(newEl), newItem.divide, newSeries, newIndex, updateMorphingPathProps);
-      } else {
-        fadeInElement(newEl, newSeries, newIndex);
-      }
-    }
-    // else keep oldEl leaving animation.
-  }
-
-  new DataDiffer(oldDiffItems, newDiffItems, createKeyGetter(true, useId), createKeyGetter(false, useId), null, 'multiple').update(updateOneToOne).updateManyToOne(function (newIndex, oldIndices) {
-    var newItem = newDiffItems[newIndex];
-    var newData = newItem.data;
-    var newSeries = newData.hostModel;
-    var newEl = newData.getItemGraphicEl(newItem.dataIndex);
-    var oldElsList = filter(map(oldIndices, function (idx) {
-      return oldDiffItems[idx].data.getItemGraphicEl(oldDiffItems[idx].dataIndex);
-    }), function (oldEl) {
-      return oldEl && oldEl !== newEl && !isElementStillInChart[oldEl.id];
-    });
-    if (newEl) {
-      stopAnimation(newEl);
-      if (oldElsList.length) {
-        // If old element is doing leaving animation. stop it and remove it immediately.
-        each(oldElsList, function (oldEl) {
-          stopAnimation(oldEl);
-          removeEl(oldEl);
-        });
-        hasMorphAnimation = true;
-        applyMorphAnimation(getPathList(oldElsList), getPathList(newEl), newItem.divide, newSeries, newIndex, updateMorphingPathProps);
-      } else {
-        fadeInElement(newEl, newSeries, newItem.dataIndex);
-      }
-    }
-    // else keep oldEl leaving animation.
-  }).updateOneToMany(function (newIndices, oldIndex) {
-    var oldItem = oldDiffItems[oldIndex];
-    var oldEl = oldItem.data.getItemGraphicEl(oldItem.dataIndex);
-    // We can't use the elements that already being morphed
-    if (oldEl && isElementStillInChart[oldEl.id]) {
-      return;
-    }
-    var newElsList = filter(map(newIndices, function (idx) {
-      return newDiffItems[idx].data.getItemGraphicEl(newDiffItems[idx].dataIndex);
-    }), function (el) {
-      return el && el !== oldEl;
-    });
-    var newSeris = newDiffItems[newIndices[0]].data.hostModel;
-    if (newElsList.length) {
-      each(newElsList, function (newEl) {
-        return stopAnimation(newEl);
-      });
-      if (oldEl) {
-        stopAnimation(oldEl);
-        // If old element is doing leaving animation. stop it and remove it immediately.
-        removeEl(oldEl);
-        hasMorphAnimation = true;
-        applyMorphAnimation(getPathList(oldEl), getPathList(newElsList), oldItem.divide,
-        // Use divide on old.
-        newSeris, newIndices[0], updateMorphingPathProps);
-      } else {
-        each(newElsList, function (newEl) {
-          return fadeInElement(newEl, newSeris, newIndices[0]);
-        });
-      }
-    }
-    // else keep oldEl leaving animation.
-  }).updateManyToMany(function (newIndices, oldIndices) {
-    // If two data are same and both have groupId.
-    // Normally they should be diff by id.
-    new DataDiffer(oldIndices, newIndices, function (rawIdx) {
-      return oldDiffItems[rawIdx].data.getId(oldDiffItems[rawIdx].dataIndex);
-    }, function (rawIdx) {
-      return newDiffItems[rawIdx].data.getId(newDiffItems[rawIdx].dataIndex);
-    }).update(function (newIndex, oldIndex) {
-      // Use the original index
-      updateOneToOne(newIndices[newIndex], oldIndices[oldIndex]);
-    }).execute();
-  }).execute();
-  if (hasMorphAnimation) {
-    each(newList, function (_a) {
-      var data = _a.data;
-      var seriesModel = data.hostModel;
-      var view = seriesModel && api.getViewOfSeriesModel(seriesModel);
-      var animationCfg = getAnimationConfig('update', seriesModel, 0); // use 0 index.
-      if (view && seriesModel.isAnimationEnabled() && animationCfg && animationCfg.duration > 0) {
-        view.group.traverse(function (el) {
-          if (el instanceof Path && !el.animators.length) {
-            // We can't accept there still exists element that has no animation
-            // if universalTransition is enabled
-            el.animateFrom({
-              style: {
-                opacity: 0
-              }
-            }, animationCfg);
-          }
-        });
-      }
-    });
-  }
-}
-function getSeriesTransitionKey(series) {
-  var seriesKey = series.getModel('universalTransition').get('seriesKey');
-  if (!seriesKey) {
-    // Use series id by default.
-    return series.id;
-  }
-  return seriesKey;
-}
-function convertArraySeriesKeyToString(seriesKey) {
-  if (isArray(seriesKey)) {
-    // Order independent.
-    return seriesKey.sort().join(',');
-  }
-  return seriesKey;
-}
-function getDivideShapeFromData(data) {
-  if (data.hostModel) {
-    return data.hostModel.getModel('universalTransition').get('divideShape');
-  }
-}
-function findTransitionSeriesBatches(globalStore, params) {
-  var updateBatches = createHashMap();
-  var oldDataMap = createHashMap();
-  // Map that only store key in array seriesKey.
-  // Which is used to query the old data when transition from one to multiple series.
-  var oldDataMapForSplit = createHashMap();
-  each(globalStore.oldSeries, function (series, idx) {
-    var oldDataGroupId = globalStore.oldDataGroupIds[idx];
-    var oldData = globalStore.oldData[idx];
-    var transitionKey = getSeriesTransitionKey(series);
-    var transitionKeyStr = convertArraySeriesKeyToString(transitionKey);
-    oldDataMap.set(transitionKeyStr, {
-      dataGroupId: oldDataGroupId,
-      data: oldData
-    });
-    if (isArray(transitionKey)) {
-      // Same key can't in different array seriesKey.
-      each(transitionKey, function (key) {
-        oldDataMapForSplit.set(key, {
-          key: transitionKeyStr,
-          dataGroupId: oldDataGroupId,
-          data: oldData
-        });
-      });
-    }
-  });
-  function checkTransitionSeriesKeyDuplicated(transitionKeyStr) {
-    if (updateBatches.get(transitionKeyStr)) {
-      warn("Duplicated seriesKey in universalTransition " + transitionKeyStr);
-    }
-  }
-  each(params.updatedSeries, function (series) {
-    if (series.isUniversalTransitionEnabled() && series.isAnimationEnabled()) {
-      var newDataGroupId = series.get('dataGroupId');
-      var newData = series.getData();
-      var transitionKey = getSeriesTransitionKey(series);
-      var transitionKeyStr = convertArraySeriesKeyToString(transitionKey);
-      // Only transition between series with same id.
-      var oldData = oldDataMap.get(transitionKeyStr);
-      // string transition key is the best match.
-      if (oldData) {
-        if (process.env.NODE_ENV !== 'production') {
-          checkTransitionSeriesKeyDuplicated(transitionKeyStr);
-        }
-        // TODO check if data is same?
-        updateBatches.set(transitionKeyStr, {
-          oldSeries: [{
-            dataGroupId: oldData.dataGroupId,
-            divide: getDivideShapeFromData(oldData.data),
-            data: oldData.data
-          }],
-          newSeries: [{
-            dataGroupId: newDataGroupId,
-            divide: getDivideShapeFromData(newData),
-            data: newData
-          }]
-        });
-      } else {
-        // Transition from multiple series.
-        // e.g. 'female', 'male' -> ['female', 'male']
-        if (isArray(transitionKey)) {
-          if (process.env.NODE_ENV !== 'production') {
-            checkTransitionSeriesKeyDuplicated(transitionKeyStr);
-          }
-          var oldSeries_1 = [];
-          each(transitionKey, function (key) {
-            var oldData = oldDataMap.get(key);
-            if (oldData.data) {
-              oldSeries_1.push({
-                dataGroupId: oldData.dataGroupId,
-                divide: getDivideShapeFromData(oldData.data),
-                data: oldData.data
-              });
-            }
-          });
-          if (oldSeries_1.length) {
-            updateBatches.set(transitionKeyStr, {
-              oldSeries: oldSeries_1,
-              newSeries: [{
-                dataGroupId: newDataGroupId,
-                data: newData,
-                divide: getDivideShapeFromData(newData)
-              }]
-            });
-          }
-        } else {
-          // Try transition to multiple series.
-          // e.g. ['female', 'male'] -> 'female', 'male'
-          var oldData_1 = oldDataMapForSplit.get(transitionKey);
-          if (oldData_1) {
-            var batch = updateBatches.get(oldData_1.key);
-            if (!batch) {
-              batch = {
-                oldSeries: [{
-                  dataGroupId: oldData_1.dataGroupId,
-                  data: oldData_1.data,
-                  divide: getDivideShapeFromData(oldData_1.data)
-                }],
-                newSeries: []
-              };
-              updateBatches.set(oldData_1.key, batch);
-            }
-            batch.newSeries.push({
-              dataGroupId: newDataGroupId,
-              data: newData,
-              divide: getDivideShapeFromData(newData)
-            });
-          }
-        }
-      }
-    }
-  });
-  return updateBatches;
-}
-function querySeries(series, finder) {
-  for (var i = 0; i < series.length; i++) {
-    var found = finder.seriesIndex != null && finder.seriesIndex === series[i].seriesIndex || finder.seriesId != null && finder.seriesId === series[i].id;
-    if (found) {
-      return i;
-    }
-  }
-}
-function transitionSeriesFromOpt(transitionOpt, globalStore, params, api) {
-  var from = [];
-  var to = [];
-  each(normalizeToArray(transitionOpt.from), function (finder) {
-    var idx = querySeries(globalStore.oldSeries, finder);
-    if (idx >= 0) {
-      from.push({
-        dataGroupId: globalStore.oldDataGroupIds[idx],
-        data: globalStore.oldData[idx],
-        // TODO can specify divideShape in transition.
-        divide: getDivideShapeFromData(globalStore.oldData[idx]),
-        groupIdDim: finder.dimension
-      });
-    }
-  });
-  each(normalizeToArray(transitionOpt.to), function (finder) {
-    var idx = querySeries(params.updatedSeries, finder);
-    if (idx >= 0) {
-      var data = params.updatedSeries[idx].getData();
-      to.push({
-        dataGroupId: globalStore.oldDataGroupIds[idx],
-        data: data,
-        divide: getDivideShapeFromData(data),
-        groupIdDim: finder.dimension
-      });
-    }
-  });
-  if (from.length > 0 && to.length > 0) {
-    transitionBetween(from, to, api);
-  }
-}
-function installUniversalTransition(registers) {
-  registers.registerUpdateLifecycle('series:beforeupdate', function (ecMOdel, api, params) {
-    each(normalizeToArray(params.seriesTransition), function (transOpt) {
-      each(normalizeToArray(transOpt.to), function (finder) {
-        var series = params.updatedSeries;
-        for (var i = 0; i < series.length; i++) {
-          if (finder.seriesIndex != null && finder.seriesIndex === series[i].seriesIndex || finder.seriesId != null && finder.seriesId === series[i].id) {
-            series[i][SERIES_UNIVERSAL_TRANSITION_PROP] = true;
-          }
-        }
-      });
-    });
-  });
-  registers.registerUpdateLifecycle('series:transition', function (ecModel, api, params) {
-    // TODO api provide an namespace that can save stuff per instance
-    var globalStore = getUniversalTransitionGlobalStore(api);
-    // TODO multiple to multiple series.
-    if (globalStore.oldSeries && params.updatedSeries && params.optionChanged) {
-      // TODO transitionOpt was used in an old implementation and can be removed now
-      // Use give transition config if its' give;
-      var transitionOpt = params.seriesTransition;
-      if (transitionOpt) {
-        each(normalizeToArray(transitionOpt), function (opt) {
-          transitionSeriesFromOpt(opt, globalStore, params, api);
-        });
-      } else {
-        // Else guess from series based on transition series key.
-        var updateBatches_1 = findTransitionSeriesBatches(globalStore, params);
-        each(updateBatches_1.keys(), function (key) {
-          var batch = updateBatches_1.get(key);
-          transitionBetween(batch.oldSeries, batch.newSeries, api);
-        });
-      }
-      // Reset
-      each(params.updatedSeries, function (series) {
-        // Reset;
-        if (series[SERIES_UNIVERSAL_TRANSITION_PROP]) {
-          series[SERIES_UNIVERSAL_TRANSITION_PROP] = false;
-        }
-      });
-    }
-    // Save all series of current update. Not only the updated one.
-    var allSeries = ecModel.getSeries();
-    var savedSeries = globalStore.oldSeries = [];
-    var savedDataGroupIds = globalStore.oldDataGroupIds = [];
-    var savedData = globalStore.oldData = [];
-    for (var i = 0; i < allSeries.length; i++) {
-      var data = allSeries[i].getData();
-      // Only save the data that can have transition.
-      // Avoid large data costing too much extra memory
-      if (data.count() < DATA_COUNT_THRESHOLD) {
-        savedSeries.push(allSeries[i]);
-        savedDataGroupIds.push(allSeries[i].get('dataGroupId'));
-        savedData.push(data);
-      }
-    }
-  });
-}
-
-export { installUniversalTransition };

package/esm/node_modules/echarts/lib/chart/bar/BarSeries.js

@@ -1,71 +0,0 @@
-import { __extends } from 'tslib';
-import BaseBarSeriesModel from './BaseBarSeries.js';
-import createSeriesData from '../helper/createSeriesData.js';
-import { inheritDefaultOption } from '../../util/component.js';
-
-var BarSeriesModel = /** @class */function (_super) {
-  __extends(BarSeriesModel, _super);
-  function BarSeriesModel() {
-    var _this = _super !== null && _super.apply(this, arguments) || this;
-    _this.type = BarSeriesModel.type;
-    return _this;
-  }
-  BarSeriesModel.prototype.getInitialData = function () {
-    return createSeriesData(null, this, {
-      useEncodeDefaulter: true,
-      createInvertedIndices: !!this.get('realtimeSort', true) || null
-    });
-  };
-  /**
-   * @override
-   */
-  BarSeriesModel.prototype.getProgressive = function () {
-    // Do not support progressive in normal mode.
-    return this.get('large') ? this.get('progressive') : false;
-  };
-  /**
-   * @override
-   */
-  BarSeriesModel.prototype.getProgressiveThreshold = function () {
-    // Do not support progressive in normal mode.
-    var progressiveThreshold = this.get('progressiveThreshold');
-    var largeThreshold = this.get('largeThreshold');
-    if (largeThreshold > progressiveThreshold) {
-      progressiveThreshold = largeThreshold;
-    }
-    return progressiveThreshold;
-  };
-  BarSeriesModel.prototype.brushSelector = function (dataIndex, data, selectors) {
-    return selectors.rect(data.getItemLayout(dataIndex));
-  };
-  BarSeriesModel.type = 'series.bar';
-  BarSeriesModel.dependencies = ['grid', 'polar'];
-  BarSeriesModel.defaultOption = inheritDefaultOption(BaseBarSeriesModel.defaultOption, {
-    // If clipped
-    // Only available on cartesian2d
-    clip: true,
-    roundCap: false,
-    showBackground: false,
-    backgroundStyle: {
-      color: 'rgba(180, 180, 180, 0.2)',
-      borderColor: null,
-      borderWidth: 0,
-      borderType: 'solid',
-      borderRadius: 0,
-      shadowBlur: 0,
-      shadowColor: null,
-      shadowOffsetX: 0,
-      shadowOffsetY: 0,
-      opacity: 1
-    },
-    select: {
-      itemStyle: {
-        borderColor: '#212121'
-      }
-    },
-    realtimeSort: false
-  });
-  return BarSeriesModel;
-}(BaseBarSeriesModel);
-
-export { BarSeriesModel as default };