office-viewer 0.3.11 → 0.3.13

package/esm/node_modules/echarts/lib/model/Series.js

@@ -0,0 +1,502 @@
+import { __extends } from 'tslib';
+import { assert, merge, isTypedArray, createHashMap, keys, isObject, mixin, each, curry, concatArray } from '../../../zrender/lib/core/util.js';
+import env from '../../../zrender/lib/core/env.js';
+import { defaultEmphasis, isNameSpecified, makeInner } from '../util/model.js';
+import ComponentModel from './Component.js';
+import { PaletteMixin } from './mixin/palette.js';
+import { DataFormatMixin } from './mixin/dataFormat.js';
+import { fetchLayoutMode, getLayoutParams, mergeLayoutParam } from '../util/layout.js';
+import { createTask } from '../core/task.js';
+import { mountExtend } from '../util/clazz.js';
+import { SourceManager } from '../data/helper/sourceManager.js';
+import { defaultSeriesFormatTooltip } from '../component/tooltip/seriesFormatTooltip.js';
+
+var inner = makeInner();
+function getSelectionKey(data, dataIndex) {
+  return data.getName(dataIndex) || data.getId(dataIndex);
+}
+var SERIES_UNIVERSAL_TRANSITION_PROP = '__universalTransitionEnabled';
+var SeriesModel = /** @class */function (_super) {
+  __extends(SeriesModel, _super);
+  function SeriesModel() {
+    // [Caution]: Because this class or desecendants can be used as `XXX.extend(subProto)`,
+    // the class members must not be initialized in constructor or declaration place.
+    // Otherwise there is bad case:
+    //   class A {xxx = 1;}
+    //   enableClassExtend(A);
+    //   class B extends A {}
+    //   var C = B.extend({xxx: 5});
+    //   var c = new C();
+    //   console.log(c.xxx); // expect 5 but always 1.
+    var _this = _super !== null && _super.apply(this, arguments) || this;
+    // ---------------------------------------
+    // Props about data selection
+    // ---------------------------------------
+    _this._selectedDataIndicesMap = {};
+    return _this;
+  }
+  SeriesModel.prototype.init = function (option, parentModel, ecModel) {
+    this.seriesIndex = this.componentIndex;
+    this.dataTask = createTask({
+      count: dataTaskCount,
+      reset: dataTaskReset
+    });
+    this.dataTask.context = {
+      model: this
+    };
+    this.mergeDefaultAndTheme(option, ecModel);
+    var sourceManager = inner(this).sourceManager = new SourceManager(this);
+    sourceManager.prepareSource();
+    var data = this.getInitialData(option, ecModel);
+    wrapData(data, this);
+    this.dataTask.context.data = data;
+    if (process.env.NODE_ENV !== 'production') {
+      assert(data, 'getInitialData returned invalid data.');
+    }
+    inner(this).dataBeforeProcessed = data;
+    // If we reverse the order (make data firstly, and then make
+    // dataBeforeProcessed by cloneShallow), cloneShallow will
+    // cause data.graph.data !== data when using
+    // module:echarts/data/Graph or module:echarts/data/Tree.
+    // See module:echarts/data/helper/linkSeriesData
+    // Theoretically, it is unreasonable to call `seriesModel.getData()` in the model
+    // init or merge stage, because the data can be restored. So we do not `restoreData`
+    // and `setData` here, which forbids calling `seriesModel.getData()` in this stage.
+    // Call `seriesModel.getRawData()` instead.
+    // this.restoreData();
+    autoSeriesName(this);
+    this._initSelectedMapFromData(data);
+  };
+  /**
+   * Util for merge default and theme to option
+   */
+  SeriesModel.prototype.mergeDefaultAndTheme = function (option, ecModel) {
+    var layoutMode = fetchLayoutMode(this);
+    var inputPositionParams = layoutMode ? getLayoutParams(option) : {};
+    // Backward compat: using subType on theme.
+    // But if name duplicate between series subType
+    // (for example: parallel) add component mainType,
+    // add suffix 'Series'.
+    var themeSubType = this.subType;
+    if (ComponentModel.hasClass(themeSubType)) {
+      themeSubType += 'Series';
+    }
+    merge(option, ecModel.getTheme().get(this.subType));
+    merge(option, this.getDefaultOption());
+    // Default label emphasis `show`
+    defaultEmphasis(option, 'label', ['show']);
+    this.fillDataTextStyle(option.data);
+    if (layoutMode) {
+      mergeLayoutParam(option, inputPositionParams, layoutMode);
+    }
+  };
+  SeriesModel.prototype.mergeOption = function (newSeriesOption, ecModel) {
+    // this.settingTask.dirty();
+    newSeriesOption = merge(this.option, newSeriesOption, true);
+    this.fillDataTextStyle(newSeriesOption.data);
+    var layoutMode = fetchLayoutMode(this);
+    if (layoutMode) {
+      mergeLayoutParam(this.option, newSeriesOption, layoutMode);
+    }
+    var sourceManager = inner(this).sourceManager;
+    sourceManager.dirty();
+    sourceManager.prepareSource();
+    var data = this.getInitialData(newSeriesOption, ecModel);
+    wrapData(data, this);
+    this.dataTask.dirty();
+    this.dataTask.context.data = data;
+    inner(this).dataBeforeProcessed = data;
+    autoSeriesName(this);
+    this._initSelectedMapFromData(data);
+  };
+  SeriesModel.prototype.fillDataTextStyle = function (data) {
+    // Default data label emphasis `show`
+    // FIXME Tree structure data ?
+    // FIXME Performance ?
+    if (data && !isTypedArray(data)) {
+      var props = ['show'];
+      for (var i = 0; i < data.length; i++) {
+        if (data[i] && data[i].label) {
+          defaultEmphasis(data[i], 'label', props);
+        }
+      }
+    }
+  };
+  /**
+   * Init a data structure from data related option in series
+   * Must be overridden.
+   */
+  SeriesModel.prototype.getInitialData = function (option, ecModel) {
+    return;
+  };
+  /**
+   * Append data to list
+   */
+  SeriesModel.prototype.appendData = function (params) {
+    // FIXME ???
+    // (1) If data from dataset, forbidden append.
+    // (2) support append data of dataset.
+    var data = this.getRawData();
+    data.appendData(params.data);
+  };
+  /**
+   * Consider some method like `filter`, `map` need make new data,
+   * We should make sure that `seriesModel.getData()` get correct
+   * data in the stream procedure. So we fetch data from upstream
+   * each time `task.perform` called.
+   */
+  SeriesModel.prototype.getData = function (dataType) {
+    var task = getCurrentTask(this);
+    if (task) {
+      var data = task.context.data;
+      return dataType == null ? data : data.getLinkedData(dataType);
+    } else {
+      // When series is not alive (that may happen when click toolbox
+      // restore or setOption with not merge mode), series data may
+      // be still need to judge animation or something when graphic
+      // elements want to know whether fade out.
+      return inner(this).data;
+    }
+  };
+  SeriesModel.prototype.getAllData = function () {
+    var mainData = this.getData();
+    return mainData && mainData.getLinkedDataAll ? mainData.getLinkedDataAll() : [{
+      data: mainData
+    }];
+  };
+  SeriesModel.prototype.setData = function (data) {
+    var task = getCurrentTask(this);
+    if (task) {
+      var context = task.context;
+      // Consider case: filter, data sample.
+      // FIXME:TS never used, so comment it
+      // if (context.data !== data && task.modifyOutputEnd) {
+      //     task.setOutputEnd(data.count());
+      // }
+      context.outputData = data;
+      // Caution: setData should update context.data,
+      // Because getData may be called multiply in a
+      // single stage and expect to get the data just
+      // set. (For example, AxisProxy, x y both call
+      // getData and setDate sequentially).
+      // So the context.data should be fetched from
+      // upstream each time when a stage starts to be
+      // performed.
+      if (task !== this.dataTask) {
+        context.data = data;
+      }
+    }
+    inner(this).data = data;
+  };
+  SeriesModel.prototype.getEncode = function () {
+    var encode = this.get('encode', true);
+    if (encode) {
+      return createHashMap(encode);
+    }
+  };
+  SeriesModel.prototype.getSourceManager = function () {
+    return inner(this).sourceManager;
+  };
+  SeriesModel.prototype.getSource = function () {
+    return this.getSourceManager().getSource();
+  };
+  /**
+   * Get data before processed
+   */
+  SeriesModel.prototype.getRawData = function () {
+    return inner(this).dataBeforeProcessed;
+  };
+  SeriesModel.prototype.getColorBy = function () {
+    var colorBy = this.get('colorBy');
+    return colorBy || 'series';
+  };
+  SeriesModel.prototype.isColorBySeries = function () {
+    return this.getColorBy() === 'series';
+  };
+  /**
+   * Get base axis if has coordinate system and has axis.
+   * By default use coordSys.getBaseAxis();
+   * Can be overridden for some chart.
+   * @return {type} description
+   */
+  SeriesModel.prototype.getBaseAxis = function () {
+    var coordSys = this.coordinateSystem;
+    // @ts-ignore
+    return coordSys && coordSys.getBaseAxis && coordSys.getBaseAxis();
+  };
+  /**
+   * Default tooltip formatter
+   *
+   * @param dataIndex
+   * @param multipleSeries
+   * @param dataType
+   * @param renderMode valid values: 'html'(by default) and 'richText'.
+   *        'html' is used for rendering tooltip in extra DOM form, and the result
+   *        string is used as DOM HTML content.
+   *        'richText' is used for rendering tooltip in rich text form, for those where
+   *        DOM operation is not supported.
+   * @return formatted tooltip with `html` and `markers`
+   *        Notice: The override method can also return string
+   */
+  SeriesModel.prototype.formatTooltip = function (dataIndex, multipleSeries, dataType) {
+    return defaultSeriesFormatTooltip({
+      series: this,
+      dataIndex: dataIndex,
+      multipleSeries: multipleSeries
+    });
+  };
+  SeriesModel.prototype.isAnimationEnabled = function () {
+    var ecModel = this.ecModel;
+    // Disable animation if using echarts in node but not give ssr flag.
+    // In ssr mode, renderToString will generate svg with css animation.
+    if (env.node && !(ecModel && ecModel.ssr)) {
+      return false;
+    }
+    var animationEnabled = this.getShallow('animation');
+    if (animationEnabled) {
+      if (this.getData().count() > this.getShallow('animationThreshold')) {
+        animationEnabled = false;
+      }
+    }
+    return !!animationEnabled;
+  };
+  SeriesModel.prototype.restoreData = function () {
+    this.dataTask.dirty();
+  };
+  SeriesModel.prototype.getColorFromPalette = function (name, scope, requestColorNum) {
+    var ecModel = this.ecModel;
+    // PENDING
+    var color = PaletteMixin.prototype.getColorFromPalette.call(this, name, scope, requestColorNum);
+    if (!color) {
+      color = ecModel.getColorFromPalette(name, scope, requestColorNum);
+    }
+    return color;
+  };
+  /**
+   * Use `data.mapDimensionsAll(coordDim)` instead.
+   * @deprecated
+   */
+  SeriesModel.prototype.coordDimToDataDim = function (coordDim) {
+    return this.getRawData().mapDimensionsAll(coordDim);
+  };
+  /**
+   * Get progressive rendering count each step
+   */
+  SeriesModel.prototype.getProgressive = function () {
+    return this.get('progressive');
+  };
+  /**
+   * Get progressive rendering count each step
+   */
+  SeriesModel.prototype.getProgressiveThreshold = function () {
+    return this.get('progressiveThreshold');
+  };
+  // PENGING If selectedMode is null ?
+  SeriesModel.prototype.select = function (innerDataIndices, dataType) {
+    this._innerSelect(this.getData(dataType), innerDataIndices);
+  };
+  SeriesModel.prototype.unselect = function (innerDataIndices, dataType) {
+    var selectedMap = this.option.selectedMap;
+    if (!selectedMap) {
+      return;
+    }
+    var selectedMode = this.option.selectedMode;
+    var data = this.getData(dataType);
+    if (selectedMode === 'series' || selectedMap === 'all') {
+      this.option.selectedMap = {};
+      this._selectedDataIndicesMap = {};
+      return;
+    }
+    for (var i = 0; i < innerDataIndices.length; i++) {
+      var dataIndex = innerDataIndices[i];
+      var nameOrId = getSelectionKey(data, dataIndex);
+      selectedMap[nameOrId] = false;
+      this._selectedDataIndicesMap[nameOrId] = -1;
+    }
+  };
+  SeriesModel.prototype.toggleSelect = function (innerDataIndices, dataType) {
+    var tmpArr = [];
+    for (var i = 0; i < innerDataIndices.length; i++) {
+      tmpArr[0] = innerDataIndices[i];
+      this.isSelected(innerDataIndices[i], dataType) ? this.unselect(tmpArr, dataType) : this.select(tmpArr, dataType);
+    }
+  };
+  SeriesModel.prototype.getSelectedDataIndices = function () {
+    if (this.option.selectedMap === 'all') {
+      return [].slice.call(this.getData().getIndices());
+    }
+    var selectedDataIndicesMap = this._selectedDataIndicesMap;
+    var nameOrIds = keys(selectedDataIndicesMap);
+    var dataIndices = [];
+    for (var i = 0; i < nameOrIds.length; i++) {
+      var dataIndex = selectedDataIndicesMap[nameOrIds[i]];
+      if (dataIndex >= 0) {
+        dataIndices.push(dataIndex);
+      }
+    }
+    return dataIndices;
+  };
+  SeriesModel.prototype.isSelected = function (dataIndex, dataType) {
+    var selectedMap = this.option.selectedMap;
+    if (!selectedMap) {
+      return false;
+    }
+    var data = this.getData(dataType);
+    return (selectedMap === 'all' || selectedMap[getSelectionKey(data, dataIndex)]) && !data.getItemModel(dataIndex).get(['select', 'disabled']);
+  };
+  SeriesModel.prototype.isUniversalTransitionEnabled = function () {
+    if (this[SERIES_UNIVERSAL_TRANSITION_PROP]) {
+      return true;
+    }
+    var universalTransitionOpt = this.option.universalTransition;
+    // Quick reject
+    if (!universalTransitionOpt) {
+      return false;
+    }
+    if (universalTransitionOpt === true) {
+      return true;
+    }
+    // Can be simply 'universalTransition: true'
+    return universalTransitionOpt && universalTransitionOpt.enabled;
+  };
+  SeriesModel.prototype._innerSelect = function (data, innerDataIndices) {
+    var _a, _b;
+    var option = this.option;
+    var selectedMode = option.selectedMode;
+    var len = innerDataIndices.length;
+    if (!selectedMode || !len) {
+      return;
+    }
+    if (selectedMode === 'series') {
+      option.selectedMap = 'all';
+    } else if (selectedMode === 'multiple') {
+      if (!isObject(option.selectedMap)) {
+        option.selectedMap = {};
+      }
+      var selectedMap = option.selectedMap;
+      for (var i = 0; i < len; i++) {
+        var dataIndex = innerDataIndices[i];
+        // TODO different types of data share same object.
+        var nameOrId = getSelectionKey(data, dataIndex);
+        selectedMap[nameOrId] = true;
+        this._selectedDataIndicesMap[nameOrId] = data.getRawIndex(dataIndex);
+      }
+    } else if (selectedMode === 'single' || selectedMode === true) {
+      var lastDataIndex = innerDataIndices[len - 1];
+      var nameOrId = getSelectionKey(data, lastDataIndex);
+      option.selectedMap = (_a = {}, _a[nameOrId] = true, _a);
+      this._selectedDataIndicesMap = (_b = {}, _b[nameOrId] = data.getRawIndex(lastDataIndex), _b);
+    }
+  };
+  SeriesModel.prototype._initSelectedMapFromData = function (data) {
+    // Ignore select info in data if selectedMap exists.
+    // NOTE It's only for legacy usage. edge data is not supported.
+    if (this.option.selectedMap) {
+      return;
+    }
+    var dataIndices = [];
+    if (data.hasItemOption) {
+      data.each(function (idx) {
+        var rawItem = data.getRawDataItem(idx);
+        if (rawItem && rawItem.selected) {
+          dataIndices.push(idx);
+        }
+      });
+    }
+    if (dataIndices.length > 0) {
+      this._innerSelect(data, dataIndices);
+    }
+  };
+  // /**
+  //  * @see {module:echarts/stream/Scheduler}
+  //  */
+  // abstract pipeTask: null
+  SeriesModel.registerClass = function (clz) {
+    return ComponentModel.registerClass(clz);
+  };
+  SeriesModel.protoInitialize = function () {
+    var proto = SeriesModel.prototype;
+    proto.type = 'series.__base__';
+    proto.seriesIndex = 0;
+    proto.ignoreStyleOnData = false;
+    proto.hasSymbolVisual = false;
+    proto.defaultSymbol = 'circle';
+    // Make sure the values can be accessed!
+    proto.visualStyleAccessPath = 'itemStyle';
+    proto.visualDrawType = 'fill';
+  }();
+  return SeriesModel;
+}(ComponentModel);
+mixin(SeriesModel, DataFormatMixin);
+mixin(SeriesModel, PaletteMixin);
+mountExtend(SeriesModel, ComponentModel);
+/**
+ * MUST be called after `prepareSource` called
+ * Here we need to make auto series, especially for auto legend. But we
+ * do not modify series.name in option to avoid side effects.
+ */
+function autoSeriesName(seriesModel) {
+  // User specified name has higher priority, otherwise it may cause
+  // series can not be queried unexpectedly.
+  var name = seriesModel.name;
+  if (!isNameSpecified(seriesModel)) {
+    seriesModel.name = getSeriesAutoName(seriesModel) || name;
+  }
+}
+function getSeriesAutoName(seriesModel) {
+  var data = seriesModel.getRawData();
+  var dataDims = data.mapDimensionsAll('seriesName');
+  var nameArr = [];
+  each(dataDims, function (dataDim) {
+    var dimInfo = data.getDimensionInfo(dataDim);
+    dimInfo.displayName && nameArr.push(dimInfo.displayName);
+  });
+  return nameArr.join(' ');
+}
+function dataTaskCount(context) {
+  return context.model.getRawData().count();
+}
+function dataTaskReset(context) {
+  var seriesModel = context.model;
+  seriesModel.setData(seriesModel.getRawData().cloneShallow());
+  return dataTaskProgress;
+}
+function dataTaskProgress(param, context) {
+  // Avoid repeat cloneShallow when data just created in reset.
+  if (context.outputData && param.end > context.outputData.count()) {
+    context.model.getRawData().cloneShallow(context.outputData);
+  }
+}
+// TODO refactor
+function wrapData(data, seriesModel) {
+  each(concatArray(data.CHANGABLE_METHODS, data.DOWNSAMPLE_METHODS), function (methodName) {
+    data.wrapMethod(methodName, curry(onDataChange, seriesModel));
+  });
+}
+function onDataChange(seriesModel, newList) {
+  var task = getCurrentTask(seriesModel);
+  if (task) {
+    // Consider case: filter, selectRange
+    task.setOutputEnd((newList || this).count());
+  }
+  return newList;
+}
+function getCurrentTask(seriesModel) {
+  var scheduler = (seriesModel.ecModel || {}).scheduler;
+  var pipeline = scheduler && scheduler.getPipeline(seriesModel.uid);
+  if (pipeline) {
+    // When pipline finished, the currrentTask keep the last
+    // task (renderTask).
+    var task = pipeline.currentTask;
+    if (task) {
+      var agentStubMap = task.agentStubMap;
+      if (agentStubMap) {
+        task = agentStubMap.get(seriesModel.uid);
+      }
+    }
+    return task;
+  }
+}
+var SeriesModel$1 = SeriesModel;
+
+export { SERIES_UNIVERSAL_TRANSITION_PROP, SeriesModel$1 as default };

package/esm/node_modules/echarts/lib/model/globalDefault.js

@@ -0,0 +1,132 @@
+/*
+* 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 platform = '';
+// Navigator not exists in node
+if (typeof navigator !== 'undefined') {
+  /* global navigator */
+  platform = navigator.platform || '';
+}
+var decalColor = 'rgba(0, 0, 0, 0.2)';
+var globalDefault = {
+  darkMode: 'auto',
+  // backgroundColor: 'rgba(0,0,0,0)',
+  colorBy: 'series',
+  color: ['#5470c6', '#91cc75', '#fac858', '#ee6666', '#73c0de', '#3ba272', '#fc8452', '#9a60b4', '#ea7ccc'],
+  gradientColor: ['#f6efa6', '#d88273', '#bf444c'],
+  aria: {
+    decal: {
+      decals: [{
+        color: decalColor,
+        dashArrayX: [1, 0],
+        dashArrayY: [2, 5],
+        symbolSize: 1,
+        rotation: Math.PI / 6
+      }, {
+        color: decalColor,
+        symbol: 'circle',
+        dashArrayX: [[8, 8], [0, 8, 8, 0]],
+        dashArrayY: [6, 0],
+        symbolSize: 0.8
+      }, {
+        color: decalColor,
+        dashArrayX: [1, 0],
+        dashArrayY: [4, 3],
+        rotation: -Math.PI / 4
+      }, {
+        color: decalColor,
+        dashArrayX: [[6, 6], [0, 6, 6, 0]],
+        dashArrayY: [6, 0]
+      }, {
+        color: decalColor,
+        dashArrayX: [[1, 0], [1, 6]],
+        dashArrayY: [1, 0, 6, 0],
+        rotation: Math.PI / 4
+      }, {
+        color: decalColor,
+        symbol: 'triangle',
+        dashArrayX: [[9, 9], [0, 9, 9, 0]],
+        dashArrayY: [7, 2],
+        symbolSize: 0.75
+      }]
+    }
+  },
+  // If xAxis and yAxis declared, grid is created by default.
+  // grid: {},
+  textStyle: {
+    // color: '#000',
+    // decoration: 'none',
+    // PENDING
+    fontFamily: platform.match(/^Win/) ? 'Microsoft YaHei' : 'sans-serif',
+    // fontFamily: 'Arial, Verdana, sans-serif',
+    fontSize: 12,
+    fontStyle: 'normal',
+    fontWeight: 'normal'
+  },
+  // http://blogs.adobe.com/webplatform/2014/02/24/using-blend-modes-in-html-canvas/
+  // https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
+  // Default is source-over
+  blendMode: null,
+  stateAnimation: {
+    duration: 300,
+    easing: 'cubicOut'
+  },
+  animation: 'auto',
+  animationDuration: 1000,
+  animationDurationUpdate: 500,
+  animationEasing: 'cubicInOut',
+  animationEasingUpdate: 'cubicInOut',
+  animationThreshold: 2000,
+  // Configuration for progressive/incremental rendering
+  progressiveThreshold: 3000,
+  progressive: 400,
+  // Threshold of if use single hover layer to optimize.
+  // It is recommended that `hoverLayerThreshold` is equivalent to or less than
+  // `progressiveThreshold`, otherwise hover will cause restart of progressive,
+  // which is unexpected.
+  // see example <echarts/test/heatmap-large.html>.
+  hoverLayerThreshold: 3000,
+  // See: module:echarts/scale/Time
+  useUTC: false
+};
+
+export { globalDefault as default };

package/esm/node_modules/echarts/lib/model/internalComponentCreator.js

@@ -0,0 +1,26 @@
+import { createHashMap, assert } from '../../../zrender/lib/core/util.js';
+import { isComponentIdInternal } from '../util/model.js';
+
+var internalOptionCreatorMap = createHashMap();
+function registerInternalOptionCreator(mainType, creator) {
+  assert(internalOptionCreatorMap.get(mainType) == null && creator);
+  internalOptionCreatorMap.set(mainType, creator);
+}
+function concatInternalOptions(ecModel, mainType, newCmptOptionList) {
+  var internalOptionCreator = internalOptionCreatorMap.get(mainType);
+  if (!internalOptionCreator) {
+    return newCmptOptionList;
+  }
+  var internalOptions = internalOptionCreator(ecModel);
+  if (!internalOptions) {
+    return newCmptOptionList;
+  }
+  if (process.env.NODE_ENV !== 'production') {
+    for (var i = 0; i < internalOptions.length; i++) {
+      assert(isComponentIdInternal(internalOptions[i]));
+    }
+  }
+  return newCmptOptionList.concat(internalOptions);
+}
+
+export { concatInternalOptions, registerInternalOptionCreator };

package/esm/node_modules/echarts/lib/model/mixin/areaStyle.js

@@ -0,0 +1,17 @@
+import makeStyleMapper from './makeStyleMapper.js';
+
+var AREA_STYLE_KEY_MAP = [['fill', 'color'], ['shadowBlur'], ['shadowOffsetX'], ['shadowOffsetY'], ['opacity'], ['shadowColor']
+// Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+// So do not transfer decal directly.
+];
+
+var getAreaStyle = makeStyleMapper(AREA_STYLE_KEY_MAP);
+var AreaStyleMixin = /** @class */function () {
+  function AreaStyleMixin() {}
+  AreaStyleMixin.prototype.getAreaStyle = function (excludes, includes) {
+    return getAreaStyle(this, excludes, includes);
+  };
+  return AreaStyleMixin;
+}();
+
+export { AREA_STYLE_KEY_MAP, AreaStyleMixin };