@fmdevui/fm-dev 1.0.113 → 1.0.114

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/time.mjs

@@ -0,0 +1,373 @@
+import { isString, isFunction, each, isObject, isArray } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import { parseDate } from './number.mjs';
+import { getLocaleModel, SYSTEM_LANG, getDefaultLocaleModel } from '../core/locale.mjs';
+import Model from '../model/Model.mjs';
+import { getScaleBreakHelper } from '../scale/break.mjs';
+
+var ONE_SECOND = 1000;
+var ONE_MINUTE = ONE_SECOND * 60;
+var ONE_HOUR = ONE_MINUTE * 60;
+var ONE_DAY = ONE_HOUR * 24;
+var ONE_YEAR = ONE_DAY * 365;
+var primaryTimeUnitFormatterMatchers = {
+  year: /({yyyy}|{yy})/,
+  month: /({MMMM}|{MMM}|{MM}|{M})/,
+  day: /({dd}|{d})/,
+  hour: /({HH}|{H}|{hh}|{h})/,
+  minute: /({mm}|{m})/,
+  second: /({ss}|{s})/,
+  millisecond: /({SSS}|{S})/
+};
+var defaultFormatterSeed = {
+  year: '{yyyy}',
+  month: '{MMM}',
+  day: '{d}',
+  hour: '{HH}:{mm}',
+  minute: '{HH}:{mm}',
+  second: '{HH}:{mm}:{ss}',
+  millisecond: '{HH}:{mm}:{ss} {SSS}'
+};
+var defaultFullFormatter = '{yyyy}-{MM}-{dd} {HH}:{mm}:{ss} {SSS}';
+var fullDayFormatter = '{yyyy}-{MM}-{dd}';
+var fullLeveledFormatter = {
+  year: '{yyyy}',
+  month: '{yyyy}-{MM}',
+  day: fullDayFormatter,
+  hour: fullDayFormatter + ' ' + defaultFormatterSeed.hour,
+  minute: fullDayFormatter + ' ' + defaultFormatterSeed.minute,
+  second: fullDayFormatter + ' ' + defaultFormatterSeed.second,
+  millisecond: defaultFullFormatter
+};
+// Order must be ensured from big to small.
+var primaryTimeUnits = ['year', 'month', 'day', 'hour', 'minute', 'second', 'millisecond'];
+var timeUnits = ['year', 'half-year', 'quarter', 'month', 'week', 'half-week', 'day', 'half-day', 'quarter-day', 'hour', 'minute', 'second', 'millisecond'];
+function parseTimeAxisLabelFormatter(formatter) {
+  // Keep the logic the same with function `leveledFormat`.
+  return !isString(formatter) && !isFunction(formatter) ? parseTimeAxisLabelFormatterDictionary(formatter) : formatter;
+}
+/**
+ * The final generated dictionary is like:
+ *  generated_dict = {
+ *      year: {
+ *          year: ['{yyyy}', ...<higher_levels_if_any>]
+ *      },
+ *      month: {
+ *          year: ['{yyyy} {MMM}', ...<higher_levels_if_any>],
+ *          month: ['{MMM}', ...<higher_levels_if_any>]
+ *      },
+ *      day: {
+ *          year: ['{yyyy} {MMM} {d}', ...<higher_levels_if_any>],
+ *          month: ['{MMM} {d}', ...<higher_levels_if_any>],
+ *          day: ['{d}', ...<higher_levels_if_any>]
+ *      },
+ *      ...
+ *  }
+ *
+ * In echarts option, users can specify the entire dictionary or typically just:
+ *  {formatter: {
+ *      year: '{yyyy}', // Or an array of leveled templates: `['{yyyy}', '{bold1|{yyyy}}', ...]`,
+ *                      // corresponding to `[level0, level1, level2, ...]`.
+ *      month: '{MMM}',
+ *      day: '{d}',
+ *      hour: '{HH}:{mm}',
+ *      second: '{HH}:{mm}',
+ *      ...
+ *  }}
+ *  If any time unit is not specified in echarts option, the default template is used,
+ *  such as `['{yyyy}', {primary|{yyyy}']`.
+ *
+ * The `tick.level` is only used to read string from each array, meaning the style type.
+ *
+ * Let `lowerUnit = getUnitFromValue(tick.value)`.
+ * The non-break axis ticks only use `generated_dict[lowerUnit][lowerUnit][level]`.
+ * The break axis ticks may use `generated_dict[lowerUnit][upperUnit][level]`, because:
+ *  Consider the case: the non-break ticks are `16th, 23th, Feb, 7th, ...`, where `Feb` is in the break
+ *  range and pruned by breaks, and the break ends might be in lower time unit than day. e.g., break start
+ *  is `Jan 25th 18:00`(in unit `hour`) and break end is `Feb 6th 18:30` (in unit `minute`). Thus the break
+ *  label prefers `Jan 25th 18:00` and `Feb 6th 18:30` rather than only `18:00` and `18:30`, otherwise it
+ *  causes misleading.
+ *  In this case, the tick of the break start and end will both be:
+ *      `{level: 1, lowerTimeUnit: 'minute', upperTimeUnit: 'month'}`
+ *  And get the final template by `generated_dict[lowerTimeUnit][upperTimeUnit][level]`.
+ *  Note that the time unit can not be calculated directly by a single tick value, since the two breaks have
+ *  to be at the same time unit to avoid awkward appearance. i.e., `Jan 25th 18:00` is in the time unit "hour"
+ *  but we need it to be "minute", following `Feb 6th 18:30`.
+ */
+function parseTimeAxisLabelFormatterDictionary(dictOption) {
+  dictOption = dictOption || {};
+  var dict = {};
+  // Currently if any template is specified by user, it may contain rich text tag,
+  // such as `'{my_bold|{YYYY}}'`, thus we do add highlight style to it.
+  // (Note that nested tag (`'{some|{some2|xxx}}'`) in rich text is not supported yet.)
+  var canAddHighlight = true;
+  each(primaryTimeUnits, function (lowestUnit) {
+    canAddHighlight && (canAddHighlight = dictOption[lowestUnit] == null);
+  });
+  each(primaryTimeUnits, function (lowestUnit, lowestUnitIdx) {
+    var upperDictOption = dictOption[lowestUnit];
+    dict[lowestUnit] = {};
+    var lowerTpl = null;
+    for (var upperUnitIdx = lowestUnitIdx; upperUnitIdx >= 0; upperUnitIdx--) {
+      var upperUnit = primaryTimeUnits[upperUnitIdx];
+      var upperDictItemOption = isObject(upperDictOption) && !isArray(upperDictOption) ? upperDictOption[upperUnit] : upperDictOption;
+      var tplArr = void 0;
+      if (isArray(upperDictItemOption)) {
+        tplArr = upperDictItemOption.slice();
+        lowerTpl = tplArr[0] || '';
+      } else if (isString(upperDictItemOption)) {
+        lowerTpl = upperDictItemOption;
+        tplArr = [lowerTpl];
+      } else {
+        if (lowerTpl == null) {
+          lowerTpl = defaultFormatterSeed[lowestUnit];
+        }
+        // Generate the dict by the rule as follows:
+        // If the user specify (or by default):
+        //  {formatter: {
+        //      year: '{yyyy}',
+        //      month: '{MMM}',
+        //      day: '{d}',
+        //      ...
+        //  }}
+        // Concat them to make the final dictionary:
+        //  {formatter: {
+        //      year: {year: ['{yyyy}']},
+        //      month: {year: ['{yyyy} {MMM}'], month: ['{MMM}']},
+        //      day: {year: ['{yyyy} {MMM} {d}'], month: ['{MMM} {d}'], day: ['{d}']}
+        //      ...
+        //  }}
+        // And then add `{primary|...}` to each array if from default template.
+        // This strategy is convinient for user configurating and works for most cases.
+        // If bad cases encountered, users can specify the entire dictionary themselves
+        // instead of going through this logic.
+        else if (!primaryTimeUnitFormatterMatchers[upperUnit].test(lowerTpl)) {
+          lowerTpl = dict[upperUnit][upperUnit][0] + " " + lowerTpl;
+        }
+        tplArr = [lowerTpl];
+        if (canAddHighlight) {
+          tplArr[1] = "{primary|" + lowerTpl + "}";
+        }
+      }
+      dict[lowestUnit][upperUnit] = tplArr;
+    }
+  });
+  return dict;
+}
+function pad(str, len) {
+  str += '';
+  return '0000'.substr(0, len - str.length) + str;
+}
+function getPrimaryTimeUnit(timeUnit) {
+  switch (timeUnit) {
+    case 'half-year':
+    case 'quarter':
+      return 'month';
+    case 'week':
+    case 'half-week':
+      return 'day';
+    case 'half-day':
+    case 'quarter-day':
+      return 'hour';
+    default:
+      // year, minutes, second, milliseconds
+      return timeUnit;
+  }
+}
+function isPrimaryTimeUnit(timeUnit) {
+  return timeUnit === getPrimaryTimeUnit(timeUnit);
+}
+function getDefaultFormatPrecisionOfInterval(timeUnit) {
+  switch (timeUnit) {
+    case 'year':
+    case 'month':
+      return 'day';
+    case 'millisecond':
+      return 'millisecond';
+    default:
+      // Also for day, hour, minute, second
+      return 'second';
+  }
+}
+function format(
+// Note: The result based on `isUTC` are totally different, which can not be just simply
+// substituted by the result without `isUTC`. So we make the param `isUTC` mandatory.
+time, template, isUTC, lang) {
+  var date = parseDate(time);
+  var y = date[fullYearGetterName(isUTC)]();
+  var M = date[monthGetterName(isUTC)]() + 1;
+  var q = Math.floor((M - 1) / 3) + 1;
+  var d = date[dateGetterName(isUTC)]();
+  var e = date['get' + (isUTC ? 'UTC' : '') + 'Day']();
+  var H = date[hoursGetterName(isUTC)]();
+  var h = (H - 1) % 12 + 1;
+  var m = date[minutesGetterName(isUTC)]();
+  var s = date[secondsGetterName(isUTC)]();
+  var S = date[millisecondsGetterName(isUTC)]();
+  var a = H >= 12 ? 'pm' : 'am';
+  var A = a.toUpperCase();
+  var localeModel = lang instanceof Model ? lang : getLocaleModel(lang || SYSTEM_LANG) || getDefaultLocaleModel();
+  var timeModel = localeModel.getModel('time');
+  var month = timeModel.get('month');
+  var monthAbbr = timeModel.get('monthAbbr');
+  var dayOfWeek = timeModel.get('dayOfWeek');
+  var dayOfWeekAbbr = timeModel.get('dayOfWeekAbbr');
+  return (template || '').replace(/{a}/g, a + '').replace(/{A}/g, A + '').replace(/{yyyy}/g, y + '').replace(/{yy}/g, pad(y % 100 + '', 2)).replace(/{Q}/g, q + '').replace(/{MMMM}/g, month[M - 1]).replace(/{MMM}/g, monthAbbr[M - 1]).replace(/{MM}/g, pad(M, 2)).replace(/{M}/g, M + '').replace(/{dd}/g, pad(d, 2)).replace(/{d}/g, d + '').replace(/{eeee}/g, dayOfWeek[e]).replace(/{ee}/g, dayOfWeekAbbr[e]).replace(/{e}/g, e + '').replace(/{HH}/g, pad(H, 2)).replace(/{H}/g, H + '').replace(/{hh}/g, pad(h + '', 2)).replace(/{h}/g, h + '').replace(/{mm}/g, pad(m, 2)).replace(/{m}/g, m + '').replace(/{ss}/g, pad(s, 2)).replace(/{s}/g, s + '').replace(/{SSS}/g, pad(S, 3)).replace(/{S}/g, S + '');
+}
+function leveledFormat(tick, idx, formatter, lang, isUTC) {
+  var template = null;
+  if (isString(formatter)) {
+    // Single formatter for all units at all levels
+    template = formatter;
+  } else if (isFunction(formatter)) {
+    var extra = {
+      time: tick.time,
+      level: tick.time.level
+    };
+    var scaleBreakHelper = getScaleBreakHelper();
+    if (scaleBreakHelper) {
+      scaleBreakHelper.makeAxisLabelFormatterParamBreak(extra, tick["break"]);
+    }
+    template = formatter(tick.value, idx, extra);
+  } else {
+    var tickTime = tick.time;
+    if (tickTime) {
+      var leveledTplArr = formatter[tickTime.lowerTimeUnit][tickTime.upperTimeUnit];
+      template = leveledTplArr[Math.min(tickTime.level, leveledTplArr.length - 1)] || '';
+    } else {
+      // tick may be from customTicks or timeline therefore no tick.time.
+      var unit = getUnitFromValue(tick.value, isUTC);
+      template = formatter[unit][unit][0];
+    }
+  }
+  return format(new Date(tick.value), template, isUTC, lang);
+}
+function getUnitFromValue(value, isUTC) {
+  var date = parseDate(value);
+  var M = date[monthGetterName(isUTC)]() + 1;
+  var d = date[dateGetterName(isUTC)]();
+  var h = date[hoursGetterName(isUTC)]();
+  var m = date[minutesGetterName(isUTC)]();
+  var s = date[secondsGetterName(isUTC)]();
+  var S = date[millisecondsGetterName(isUTC)]();
+  var isSecond = S === 0;
+  var isMinute = isSecond && s === 0;
+  var isHour = isMinute && m === 0;
+  var isDay = isHour && h === 0;
+  var isMonth = isDay && d === 1;
+  var isYear = isMonth && M === 1;
+  if (isYear) {
+    return 'year';
+  } else if (isMonth) {
+    return 'month';
+  } else if (isDay) {
+    return 'day';
+  } else if (isHour) {
+    return 'hour';
+  } else if (isMinute) {
+    return 'minute';
+  } else if (isSecond) {
+    return 'second';
+  } else {
+    return 'millisecond';
+  }
+}
+// export function getUnitValue(
+//     value: number | Date,
+//     unit: TimeUnit,
+//     isUTC: boolean
+// ) : number {
+//     const date = zrUtil.isNumber(value)
+//         ? numberUtil.parseDate(value)
+//         : value;
+//     unit = unit || getUnitFromValue(value, isUTC);
+//     switch (unit) {
+//         case 'year':
+//             return date[fullYearGetterName(isUTC)]();
+//         case 'half-year':
+//             return date[monthGetterName(isUTC)]() >= 6 ? 1 : 0;
+//         case 'quarter':
+//             return Math.floor((date[monthGetterName(isUTC)]() + 1) / 4);
+//         case 'month':
+//             return date[monthGetterName(isUTC)]();
+//         case 'day':
+//             return date[dateGetterName(isUTC)]();
+//         case 'half-day':
+//             return date[hoursGetterName(isUTC)]() / 24;
+//         case 'hour':
+//             return date[hoursGetterName(isUTC)]();
+//         case 'minute':
+//             return date[minutesGetterName(isUTC)]();
+//         case 'second':
+//             return date[secondsGetterName(isUTC)]();
+//         case 'millisecond':
+//             return date[millisecondsGetterName(isUTC)]();
+//     }
+// }
+/**
+ * e.g.,
+ * If timeUnit is 'year', return the Jan 1st 00:00:00 000 of that year.
+ * If timeUnit is 'day', return the 00:00:00 000 of that day.
+ *
+ * @return The input date.
+ */
+function roundTime(date, timeUnit, isUTC) {
+  switch (timeUnit) {
+    case 'year':
+      date[monthSetterName(isUTC)](0);
+    case 'month':
+      date[dateSetterName(isUTC)](1);
+    case 'day':
+      date[hoursSetterName(isUTC)](0);
+    case 'hour':
+      date[minutesSetterName(isUTC)](0);
+    case 'minute':
+      date[secondsSetterName(isUTC)](0);
+    case 'second':
+      date[millisecondsSetterName(isUTC)](0);
+  }
+  return date;
+}
+function fullYearGetterName(isUTC) {
+  return isUTC ? 'getUTCFullYear' : 'getFullYear';
+}
+function monthGetterName(isUTC) {
+  return isUTC ? 'getUTCMonth' : 'getMonth';
+}
+function dateGetterName(isUTC) {
+  return isUTC ? 'getUTCDate' : 'getDate';
+}
+function hoursGetterName(isUTC) {
+  return isUTC ? 'getUTCHours' : 'getHours';
+}
+function minutesGetterName(isUTC) {
+  return isUTC ? 'getUTCMinutes' : 'getMinutes';
+}
+function secondsGetterName(isUTC) {
+  return isUTC ? 'getUTCSeconds' : 'getSeconds';
+}
+function millisecondsGetterName(isUTC) {
+  return isUTC ? 'getUTCMilliseconds' : 'getMilliseconds';
+}
+function fullYearSetterName(isUTC) {
+  return isUTC ? 'setUTCFullYear' : 'setFullYear';
+}
+function monthSetterName(isUTC) {
+  return isUTC ? 'setUTCMonth' : 'setMonth';
+}
+function dateSetterName(isUTC) {
+  return isUTC ? 'setUTCDate' : 'setDate';
+}
+function hoursSetterName(isUTC) {
+  return isUTC ? 'setUTCHours' : 'setHours';
+}
+function minutesSetterName(isUTC) {
+  return isUTC ? 'setUTCMinutes' : 'setMinutes';
+}
+function secondsSetterName(isUTC) {
+  return isUTC ? 'setUTCSeconds' : 'setSeconds';
+}
+function millisecondsSetterName(isUTC) {
+  return isUTC ? 'setUTCMilliseconds' : 'setMilliseconds';
+}
+
+export { ONE_DAY, ONE_HOUR, ONE_MINUTE, ONE_SECOND, ONE_YEAR, dateGetterName, dateSetterName, format, fullLeveledFormatter, fullYearGetterName, fullYearSetterName, getDefaultFormatPrecisionOfInterval, getPrimaryTimeUnit, getUnitFromValue, hoursGetterName, hoursSetterName, isPrimaryTimeUnit, leveledFormat, millisecondsGetterName, millisecondsSetterName, minutesGetterName, minutesSetterName, monthGetterName, monthSetterName, pad, parseTimeAxisLabelFormatter, primaryTimeUnits, roundTime, secondsGetterName, secondsSetterName, timeUnits };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/types.mjs

@@ -0,0 +1,20 @@
+import { createHashMap } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+;
+;
+;
+var VISUAL_DIMENSIONS = createHashMap(['tooltip', 'label', 'itemName', 'itemId', 'itemGroupId', 'itemChildGroupId', 'seriesName']);
+var SOURCE_FORMAT_ORIGINAL = 'original';
+var SOURCE_FORMAT_ARRAY_ROWS = 'arrayRows';
+var SOURCE_FORMAT_OBJECT_ROWS = 'objectRows';
+var SOURCE_FORMAT_KEYED_COLUMNS = 'keyedColumns';
+var SOURCE_FORMAT_TYPED_ARRAY = 'typedArray';
+var SOURCE_FORMAT_UNKNOWN = 'unknown';
+var SERIES_LAYOUT_BY_COLUMN = 'column';
+var SERIES_LAYOUT_BY_ROW = 'row';
+;
+;
+;
+;
+
+export { SERIES_LAYOUT_BY_COLUMN, SERIES_LAYOUT_BY_ROW, SOURCE_FORMAT_ARRAY_ROWS, SOURCE_FORMAT_KEYED_COLUMNS, SOURCE_FORMAT_OBJECT_ROWS, SOURCE_FORMAT_ORIGINAL, SOURCE_FORMAT_TYPED_ARRAY, SOURCE_FORMAT_UNKNOWN, VISUAL_DIMENSIONS };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/vendor.mjs

@@ -0,0 +1,15 @@
+import { isArray } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+
+/* global Float32Array */
+var supportFloat32Array = typeof Float32Array !== 'undefined';
+var Float32ArrayCtor = !supportFloat32Array ? Array : Float32Array;
+function createFloat32Array(arg) {
+  if (isArray(arg)) {
+    // Return self directly if don't support TypedArray.
+    return supportFloat32Array ? new Float32Array(arg) : arg;
+  }
+  // Else is number
+  return new Float32ArrayCtor(arg);
+}
+
+export { createFloat32Array };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/view/Chart.mjs

@@ -0,0 +1,160 @@
+import { each } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import Group from '../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Group.mjs';
+import { getUID } from '../util/component.mjs';
+import { enableClassExtend, enableClassManagement } from '../util/clazz.mjs';
+import { makeInner, queryDataIndex, normalizeToArray } from '../util/model.mjs';
+import { isHighDownDispatcher, enterEmphasis, leaveEmphasis, getHighlightDigit } from '../util/states.mjs';
+import { createTask } from '../core/task.mjs';
+import createRenderPlanner from '../chart/helper/createRenderPlanner.mjs';
+import { traverseElements } from '../util/graphic.mjs';
+import { error } from '../util/log.mjs';
+
+var inner = makeInner();
+var renderPlanner = createRenderPlanner();
+var ChartView = /** @class */function () {
+  function ChartView() {
+    this.group = new Group();
+    this.uid = getUID('viewChart');
+    this.renderTask = createTask({
+      plan: renderTaskPlan,
+      reset: renderTaskReset
+    });
+    this.renderTask.context = {
+      view: this
+    };
+  }
+  ChartView.prototype.init = function (ecModel, api) {};
+  ChartView.prototype.render = function (seriesModel, ecModel, api, payload) {
+    if (process.env.NODE_ENV !== 'production') {
+      throw new Error('render method must been implemented');
+    }
+  };
+  /**
+   * Highlight series or specified data item.
+   */
+  ChartView.prototype.highlight = function (seriesModel, ecModel, api, payload) {
+    var data = seriesModel.getData(payload && payload.dataType);
+    if (!data) {
+      if (process.env.NODE_ENV !== 'production') {
+        error("Unknown dataType " + payload.dataType);
+      }
+      return;
+    }
+    toggleHighlight(data, payload, 'emphasis');
+  };
+  /**
+   * Downplay series or specified data item.
+   */
+  ChartView.prototype.downplay = function (seriesModel, ecModel, api, payload) {
+    var data = seriesModel.getData(payload && payload.dataType);
+    if (!data) {
+      if (process.env.NODE_ENV !== 'production') {
+        error("Unknown dataType " + payload.dataType);
+      }
+      return;
+    }
+    toggleHighlight(data, payload, 'normal');
+  };
+  /**
+   * Remove self.
+   */
+  ChartView.prototype.remove = function (ecModel, api) {
+    this.group.removeAll();
+  };
+  /**
+   * Dispose self.
+   */
+  ChartView.prototype.dispose = function (ecModel, api) {};
+  ChartView.prototype.updateView = function (seriesModel, ecModel, api, payload) {
+    this.render(seriesModel, ecModel, api, payload);
+  };
+  // FIXME never used?
+  ChartView.prototype.updateLayout = function (seriesModel, ecModel, api, payload) {
+    this.render(seriesModel, ecModel, api, payload);
+  };
+  // FIXME never used?
+  ChartView.prototype.updateVisual = function (seriesModel, ecModel, api, payload) {
+    this.render(seriesModel, ecModel, api, payload);
+  };
+  /**
+   * Traverse the new rendered elements.
+   *
+   * It will traverse the new added element in progressive rendering.
+   * And traverse all in normal rendering.
+   */
+  ChartView.prototype.eachRendered = function (cb) {
+    traverseElements(this.group, cb);
+  };
+  ChartView.markUpdateMethod = function (payload, methodName) {
+    inner(payload).updateMethod = methodName;
+  };
+  ChartView.protoInitialize = function () {
+    var proto = ChartView.prototype;
+    proto.type = 'chart';
+  }();
+  return ChartView;
+}();
+;
+/**
+ * Set state of single element
+ */
+function elSetState(el, state, highlightDigit) {
+  if (el && isHighDownDispatcher(el)) {
+    (state === 'emphasis' ? enterEmphasis : leaveEmphasis)(el, highlightDigit);
+  }
+}
+function toggleHighlight(data, payload, state) {
+  var dataIndex = queryDataIndex(data, payload);
+  var highlightDigit = payload && payload.highlightKey != null ? getHighlightDigit(payload.highlightKey) : null;
+  if (dataIndex != null) {
+    each(normalizeToArray(dataIndex), function (dataIdx) {
+      elSetState(data.getItemGraphicEl(dataIdx), state, highlightDigit);
+    });
+  } else {
+    data.eachItemGraphicEl(function (el) {
+      elSetState(el, state, highlightDigit);
+    });
+  }
+}
+enableClassExtend(ChartView, ['dispose']);
+enableClassManagement(ChartView);
+function renderTaskPlan(context) {
+  return renderPlanner(context.model);
+}
+function renderTaskReset(context) {
+  var seriesModel = context.model;
+  var ecModel = context.ecModel;
+  var api = context.api;
+  var payload = context.payload;
+  // FIXME: remove updateView updateVisual
+  var progressiveRender = seriesModel.pipelineContext.progressiveRender;
+  var view = context.view;
+  var updateMethod = payload && inner(payload).updateMethod;
+  var methodName = progressiveRender ? 'incrementalPrepareRender' : updateMethod && view[updateMethod] ? updateMethod
+  // `appendData` is also supported when data amount
+  // is less than progressive threshold.
+  : 'render';
+  if (methodName !== 'render') {
+    view[methodName](seriesModel, ecModel, api, payload);
+  }
+  return progressMethodMap[methodName];
+}
+var progressMethodMap = {
+  incrementalPrepareRender: {
+    progress: function (params, context) {
+      context.view.incrementalRender(params, context.model, context.ecModel, context.api, context.payload);
+    }
+  },
+  render: {
+    // Put view.render in `progress` to support appendData. But in this case
+    // view.render should not be called in reset, otherwise it will be called
+    // twise. Use `forceFirstProgress` to make sure that view.render is called
+    // in any cases.
+    forceFirstProgress: true,
+    progress: function (params, context) {
+      context.view.render(context.model, context.ecModel, context.api, context.payload);
+    }
+  }
+};
+
+export { ChartView as default };

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/view/Component.mjs

@@ -0,0 +1,47 @@
+import Group from '../../../../../zrender@6.0.0/node_modules/zrender/lib/graphic/Group.mjs';
+import { getUID } from '../util/component.mjs';
+import { enableClassExtend, enableClassManagement } from '../util/clazz.mjs';
+
+var ComponentView = /** @class */function () {
+  function ComponentView() {
+    this.group = new Group();
+    this.uid = getUID('viewComponent');
+  }
+  ComponentView.prototype.init = function (ecModel, api) {};
+  ComponentView.prototype.render = function (model, ecModel, api, payload) {};
+  ComponentView.prototype.dispose = function (ecModel, api) {};
+  ComponentView.prototype.updateView = function (model, ecModel, api, payload) {
+    // Do nothing;
+  };
+  ComponentView.prototype.updateLayout = function (model, ecModel, api, payload) {
+    // Do nothing;
+  };
+  ComponentView.prototype.updateVisual = function (model, ecModel, api, payload) {
+    // Do nothing;
+  };
+  /**
+   * Hook for toggle blur target series.
+   * Can be used in marker for blur or leave blur the markers
+   */
+  ComponentView.prototype.toggleBlurSeries = function (seriesModels, isBlur, ecModel) {
+    // Do nothing;
+  };
+  /**
+   * Traverse the new rendered elements.
+   *
+   * It will traverse the new added element in progressive rendering.
+   * And traverse all in normal rendering.
+   */
+  ComponentView.prototype.eachRendered = function (cb) {
+    var group = this.group;
+    if (group) {
+      group.traverse(cb);
+    }
+  };
+  return ComponentView;
+}();
+;
+enableClassExtend(ComponentView);
+enableClassManagement(ComponentView);
+
+export { ComponentView as default };