@fmdevui/fm-dev 1.0.112 → 1.0.114

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

@@ -0,0 +1,44 @@
+'use strict';
+
+var format = require('../../util/format.js');
+var env = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/env.js');
+
+/* global document */
+function shouldTooltipConfine(tooltipModel) {
+  var confineOption = tooltipModel.get('confine');
+  return confineOption != null ? !!confineOption
+  // In richText mode, the outside part can not be visible.
+  : tooltipModel.get('renderMode') === 'richText';
+}
+function testStyle(styleProps) {
+  if (!env.default.domSupported) {
+    return;
+  }
+  var style = document.documentElement.style;
+  for (var i = 0, len = styleProps.length; i < len; i++) {
+    if (styleProps[i] in style) {
+      return styleProps[i];
+    }
+  }
+}
+var TRANSFORM_VENDOR = testStyle(['transform', 'webkitTransform', 'OTransform', 'MozTransform', 'msTransform']);
+var TRANSITION_VENDOR = testStyle(['webkitTransition', 'transition', 'OTransition', 'MozTransition', 'msTransition']);
+function toCSSVendorPrefix(styleVendor, styleProp) {
+  if (!styleVendor) {
+    return styleProp;
+  }
+  styleProp = format.toCamelCase(styleProp, true);
+  var idx = styleVendor.indexOf(styleProp);
+  styleVendor = idx === -1 ? styleProp : "-" + styleVendor.slice(0, idx) + "-" + styleProp;
+  return styleVendor.toLowerCase();
+}
+function getComputedStyle(el, style) {
+  var stl = el.currentStyle || document.defaultView && document.defaultView.getComputedStyle(el);
+  return stl ? style ? stl[style] : stl : null;
+}
+
+exports.TRANSFORM_VENDOR = TRANSFORM_VENDOR;
+exports.TRANSITION_VENDOR = TRANSITION_VENDOR;
+exports.getComputedStyle = getComputedStyle;
+exports.shouldTooltipConfine = shouldTooltipConfine;
+exports.toCSSVendorPrefix = toCSSVendorPrefix;

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

@@ -0,0 +1,33 @@
+'use strict';
+
+var install$1 = require('../axisPointer/install.js');
+var extension = require('../../extension.js');
+var TooltipModel = require('./TooltipModel.js');
+var TooltipView = require('./TooltipView.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+
+function install(registers) {
+  extension.use(install$1.install);
+  registers.registerComponentModel(TooltipModel.default);
+  registers.registerComponentView(TooltipView.default);
+  /**
+   * @action
+   * @property {string} type
+   * @property {number} seriesIndex
+   * @property {number} dataIndex
+   * @property {number} [x]
+   * @property {number} [y]
+   */
+  registers.registerAction({
+    type: 'showTip',
+    event: 'showTip',
+    update: 'tooltip:manuallyShowTip'
+  }, util.noop);
+  registers.registerAction({
+    type: 'hideTip',
+    event: 'hideTip',
+    update: 'tooltip:manuallyHideTip'
+  }, util.noop);
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/tooltip/seriesFormatTooltip.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var tooltipMarkup = require('./tooltipMarkup.js');
+var dataProvider = require('../../data/helper/dataProvider.js');
+var model = require('../../util/model.js');
+
+function defaultSeriesFormatTooltip(opt) {
+  var series = opt.series;
+  var dataIndex = opt.dataIndex;
+  var multipleSeries = opt.multipleSeries;
+  var data = series.getData();
+  var tooltipDims = data.mapDimensionsAll('defaultedTooltip');
+  var tooltipDimLen = tooltipDims.length;
+  var value = series.getRawValue(dataIndex);
+  var isValueArr = util.isArray(value);
+  var markerColor = tooltipMarkup.retrieveVisualColorForTooltipMarker(series, dataIndex);
+  // Complicated rule for pretty tooltip.
+  var inlineValue;
+  var inlineValueType;
+  var subBlocks;
+  var sortParam;
+  if (tooltipDimLen > 1 || isValueArr && !tooltipDimLen) {
+    var formatArrResult = formatTooltipArrayValue(value, series, dataIndex, tooltipDims, markerColor);
+    inlineValue = formatArrResult.inlineValues;
+    inlineValueType = formatArrResult.inlineValueTypes;
+    subBlocks = formatArrResult.blocks;
+    // Only support tooltip sort by the first inline value. It's enough in most cases.
+    sortParam = formatArrResult.inlineValues[0];
+  } else if (tooltipDimLen) {
+    var dimInfo = data.getDimensionInfo(tooltipDims[0]);
+    sortParam = inlineValue = dataProvider.retrieveRawValue(data, dataIndex, tooltipDims[0]);
+    inlineValueType = dimInfo.type;
+  } else {
+    sortParam = inlineValue = isValueArr ? value[0] : value;
+  }
+  // Do not show generated series name. It might not be readable.
+  var seriesNameSpecified = model.isNameSpecified(series);
+  var seriesName = seriesNameSpecified && series.name || '';
+  var itemName = data.getName(dataIndex);
+  var inlineName = multipleSeries ? seriesName : itemName;
+  return tooltipMarkup.createTooltipMarkup('section', {
+    header: seriesName,
+    // When series name is not specified, do not show a header line with only '-'.
+    // This case always happens in tooltip.trigger: 'item'.
+    noHeader: multipleSeries || !seriesNameSpecified,
+    sortParam: sortParam,
+    blocks: [tooltipMarkup.createTooltipMarkup('nameValue', {
+      markerType: 'item',
+      markerColor: markerColor,
+      // Do not mix display seriesName and itemName in one tooltip,
+      // which might confuses users.
+      name: inlineName,
+      // name dimension might be auto assigned, where the name might
+      // be not readable. So we check trim here.
+      noName: !util.trim(inlineName),
+      value: inlineValue,
+      valueType: inlineValueType,
+      dataIndex: dataIndex
+    })].concat(subBlocks || [])
+  });
+}
+function formatTooltipArrayValue(value, series, dataIndex, tooltipDims, colorStr) {
+  // check: category-no-encode-has-axis-data in dataset.html
+  var data = series.getData();
+  var isValueMultipleLine = util.reduce(value, function (isValueMultipleLine, val, idx) {
+    var dimItem = data.getDimensionInfo(idx);
+    return isValueMultipleLine = isValueMultipleLine || dimItem && dimItem.tooltip !== false && dimItem.displayName != null;
+  }, false);
+  var inlineValues = [];
+  var inlineValueTypes = [];
+  var blocks = [];
+  tooltipDims.length ? util.each(tooltipDims, function (dim) {
+    setEachItem(dataProvider.retrieveRawValue(data, dataIndex, dim), dim);
+  })
+  // By default, all dims is used on tooltip.
+  : util.each(value, setEachItem);
+  function setEachItem(val, dim) {
+    var dimInfo = data.getDimensionInfo(dim);
+    // If `dimInfo.tooltip` is not set, show tooltip.
+    if (!dimInfo || dimInfo.otherDims.tooltip === false) {
+      return;
+    }
+    if (isValueMultipleLine) {
+      blocks.push(tooltipMarkup.createTooltipMarkup('nameValue', {
+        markerType: 'subItem',
+        markerColor: colorStr,
+        name: dimInfo.displayName,
+        value: val,
+        valueType: dimInfo.type
+      }));
+    } else {
+      inlineValues.push(val);
+      inlineValueTypes.push(dimInfo.type);
+    }
+  }
+  return {
+    inlineValues: inlineValues,
+    inlineValueTypes: inlineValueTypes,
+    blocks: blocks
+  };
+}
+
+exports.defaultSeriesFormatTooltip = defaultSeriesFormatTooltip;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/tooltip/tooltipMarkup.js

@@ -0,0 +1,301 @@
+'use strict';
+
+var format = require('../../util/format.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var dataValueHelper = require('../../data/helper/dataValueHelper.js');
+var number = require('../../util/number.js');
+var tokens = require('../../visual/tokens.js');
+var dom = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/dom.js');
+
+var TOOLTIP_LINE_HEIGHT_CSS = 'line-height:1';
+function getTooltipLineHeight(textStyle) {
+  var lineHeight = textStyle.lineHeight;
+  if (lineHeight == null) {
+    return TOOLTIP_LINE_HEIGHT_CSS;
+  } else {
+    return "line-height:" + dom.encodeHTML(lineHeight + '') + "px";
+  }
+}
+// TODO: more textStyle option
+function getTooltipTextStyle(textStyle, renderMode) {
+  var nameFontColor = textStyle.color || tokens.default.color.tertiary;
+  var nameFontSize = textStyle.fontSize || 12;
+  var nameFontWeight = textStyle.fontWeight || '400';
+  var valueFontColor = textStyle.color || tokens.default.color.secondary;
+  var valueFontSize = textStyle.fontSize || 14;
+  var valueFontWeight = textStyle.fontWeight || '900';
+  if (renderMode === 'html') {
+    // `textStyle` is probably from user input, should be encoded to reduce security risk.
+    return {
+      // eslint-disable-next-line max-len
+      nameStyle: "font-size:" + dom.encodeHTML(nameFontSize + '') + "px;color:" + dom.encodeHTML(nameFontColor) + ";font-weight:" + dom.encodeHTML(nameFontWeight + ''),
+      // eslint-disable-next-line max-len
+      valueStyle: "font-size:" + dom.encodeHTML(valueFontSize + '') + "px;color:" + dom.encodeHTML(valueFontColor) + ";font-weight:" + dom.encodeHTML(valueFontWeight + '')
+    };
+  } else {
+    return {
+      nameStyle: {
+        fontSize: nameFontSize,
+        fill: nameFontColor,
+        fontWeight: nameFontWeight
+      },
+      valueStyle: {
+        fontSize: valueFontSize,
+        fill: valueFontColor,
+        fontWeight: valueFontWeight
+      }
+    };
+  }
+}
+// See `TooltipMarkupLayoutIntent['innerGapLevel']`.
+// (value from UI design)
+var HTML_GAPS = [0, 10, 20, 30];
+var RICH_TEXT_GAPS = ['', '\n', '\n\n', '\n\n\n'];
+// eslint-disable-next-line max-len
+function createTooltipMarkup(type, option) {
+  option.type = type;
+  return option;
+}
+function isSectionFragment(frag) {
+  return frag.type === 'section';
+}
+function getBuilder(frag) {
+  return isSectionFragment(frag) ? buildSection : buildNameValue;
+}
+function getBlockGapLevel(frag) {
+  if (isSectionFragment(frag)) {
+    var gapLevel_1 = 0;
+    var subBlockLen = frag.blocks.length;
+    var hasInnerGap_1 = subBlockLen > 1 || subBlockLen > 0 && !frag.noHeader;
+    util.each(frag.blocks, function (subBlock) {
+      var subGapLevel = getBlockGapLevel(subBlock);
+      // If the some of the sub-blocks have some gaps (like 10px) inside, this block
+      // should use a larger gap (like 20px) to distinguish those sub-blocks.
+      if (subGapLevel >= gapLevel_1) {
+        gapLevel_1 = subGapLevel + +(hasInnerGap_1 && (
+        // 0 always can not be readable gap level.
+        !subGapLevel
+        // If no header, always keep the sub gap level. Otherwise
+        // look weird in case `multipleSeries`.
+        || isSectionFragment(subBlock) && !subBlock.noHeader));
+      }
+    });
+    return gapLevel_1;
+  }
+  return 0;
+}
+function buildSection(ctx, fragment, topMarginForOuterGap, toolTipTextStyle) {
+  var noHeader = fragment.noHeader;
+  var gaps = getGap(getBlockGapLevel(fragment));
+  var subMarkupTextList = [];
+  var subBlocks = fragment.blocks || [];
+  util.assert(!subBlocks || util.isArray(subBlocks));
+  subBlocks = subBlocks || [];
+  var orderMode = ctx.orderMode;
+  if (fragment.sortBlocks && orderMode) {
+    subBlocks = subBlocks.slice();
+    var orderMap = {
+      valueAsc: 'asc',
+      valueDesc: 'desc'
+    };
+    if (util.hasOwn(orderMap, orderMode)) {
+      var comparator_1 = new dataValueHelper.SortOrderComparator(orderMap[orderMode], null);
+      subBlocks.sort(function (a, b) {
+        return comparator_1.evaluate(a.sortParam, b.sortParam);
+      });
+    }
+    // FIXME 'seriesDesc' necessary?
+    else if (orderMode === 'seriesDesc') {
+      subBlocks.reverse();
+    }
+  }
+  util.each(subBlocks, function (subBlock, idx) {
+    var valueFormatter = fragment.valueFormatter;
+    var subMarkupText = getBuilder(subBlock)(
+    // Inherit valueFormatter
+    valueFormatter ? util.extend(util.extend({}, ctx), {
+      valueFormatter: valueFormatter
+    }) : ctx, subBlock, idx > 0 ? gaps.html : 0, toolTipTextStyle);
+    subMarkupText != null && subMarkupTextList.push(subMarkupText);
+  });
+  var subMarkupText = ctx.renderMode === 'richText' ? subMarkupTextList.join(gaps.richText) : wrapBlockHTML(toolTipTextStyle, subMarkupTextList.join(''), noHeader ? topMarginForOuterGap : gaps.html);
+  if (noHeader) {
+    return subMarkupText;
+  }
+  var displayableHeader = format.makeValueReadable(fragment.header, 'ordinal', ctx.useUTC);
+  var nameStyle = getTooltipTextStyle(toolTipTextStyle, ctx.renderMode).nameStyle;
+  var tooltipLineHeight = getTooltipLineHeight(toolTipTextStyle);
+  if (ctx.renderMode === 'richText') {
+    return wrapInlineNameRichText(ctx, displayableHeader, nameStyle) + gaps.richText + subMarkupText;
+  } else {
+    return wrapBlockHTML(toolTipTextStyle, "<div style=\"" + nameStyle + ";" + tooltipLineHeight + ";\">" + dom.encodeHTML(displayableHeader) + '</div>' + subMarkupText, topMarginForOuterGap);
+  }
+}
+function buildNameValue(ctx, fragment, topMarginForOuterGap, toolTipTextStyle) {
+  var renderMode = ctx.renderMode;
+  var noName = fragment.noName;
+  var noValue = fragment.noValue;
+  var noMarker = !fragment.markerType;
+  var name = fragment.name;
+  var useUTC = ctx.useUTC;
+  var valueFormatter = fragment.valueFormatter || ctx.valueFormatter || function (value) {
+    value = util.isArray(value) ? value : [value];
+    return util.map(value, function (val, idx) {
+      return format.makeValueReadable(val, util.isArray(valueTypeOption) ? valueTypeOption[idx] : valueTypeOption, useUTC);
+    });
+  };
+  if (noName && noValue) {
+    return;
+  }
+  var markerStr = noMarker ? '' : ctx.markupStyleCreator.makeTooltipMarker(fragment.markerType, fragment.markerColor || tokens.default.color.secondary, renderMode);
+  var readableName = noName ? '' : format.makeValueReadable(name, 'ordinal', useUTC);
+  var valueTypeOption = fragment.valueType;
+  var readableValueList = noValue ? [] : valueFormatter(fragment.value, fragment.dataIndex);
+  var valueAlignRight = !noMarker || !noName;
+  // It little weird if only value next to marker but far from marker.
+  var valueCloseToMarker = !noMarker && noName;
+  var _a = getTooltipTextStyle(toolTipTextStyle, renderMode),
+    nameStyle = _a.nameStyle,
+    valueStyle = _a.valueStyle;
+  return renderMode === 'richText' ? (noMarker ? '' : markerStr) + (noName ? '' : wrapInlineNameRichText(ctx, readableName, nameStyle))
+  // Value has commas inside, so use ' ' as delimiter for multiple values.
+  + (noValue ? '' : wrapInlineValueRichText(ctx, readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)) : wrapBlockHTML(toolTipTextStyle, (noMarker ? '' : markerStr) + (noName ? '' : wrapInlineNameHTML(readableName, !noMarker, nameStyle)) + (noValue ? '' : wrapInlineValueHTML(readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)), topMarginForOuterGap);
+}
+/**
+ * @return markupText. null/undefined means no content.
+ */
+function buildTooltipMarkup(fragment, markupStyleCreator, renderMode, orderMode, useUTC, toolTipTextStyle) {
+  if (!fragment) {
+    return;
+  }
+  var builder = getBuilder(fragment);
+  var ctx = {
+    useUTC: useUTC,
+    renderMode: renderMode,
+    orderMode: orderMode,
+    markupStyleCreator: markupStyleCreator,
+    valueFormatter: fragment.valueFormatter
+  };
+  return builder(ctx, fragment, 0, toolTipTextStyle);
+}
+function getGap(gapLevel) {
+  return {
+    html: HTML_GAPS[gapLevel],
+    richText: RICH_TEXT_GAPS[gapLevel]
+  };
+}
+function wrapBlockHTML(textStyle, encodedContent, topGap) {
+  var clearfix = '<div style="clear:both"></div>';
+  var marginCSS = "margin: " + topGap + "px 0 0";
+  var tooltipLineHeight = getTooltipLineHeight(textStyle);
+  return "<div style=\"" + marginCSS + ";" + tooltipLineHeight + ";\">" + encodedContent + clearfix + '</div>';
+}
+function wrapInlineNameHTML(name, leftHasMarker, style) {
+  var marginCss = leftHasMarker ? 'margin-left:2px' : '';
+  return "<span style=\"" + style + ";" + marginCss + "\">" + dom.encodeHTML(name) + '</span>';
+}
+function wrapInlineValueHTML(valueList, alignRight, valueCloseToMarker, style) {
+  // Do not too close to marker, considering there are multiple values separated by spaces.
+  var paddingStr = valueCloseToMarker ? '10px' : '20px';
+  var alignCSS = alignRight ? "float:right;margin-left:" + paddingStr : '';
+  valueList = util.isArray(valueList) ? valueList : [valueList];
+  return "<span style=\"" + alignCSS + ";" + style + "\">"
+  // Value has commas inside, so use '  ' as delimiter for multiple values.
+  + util.map(valueList, function (value) {
+    return dom.encodeHTML(value);
+  }).join('&nbsp;&nbsp;') + '</span>';
+}
+function wrapInlineNameRichText(ctx, name, style) {
+  return ctx.markupStyleCreator.wrapRichTextStyle(name, style);
+}
+function wrapInlineValueRichText(ctx, values, alignRight, valueCloseToMarker, style) {
+  var styles = [style];
+  var paddingLeft = valueCloseToMarker ? 10 : 20;
+  alignRight && styles.push({
+    padding: [0, 0, 0, paddingLeft],
+    align: 'right'
+  });
+  // Value has commas inside, so use '  ' as delimiter for multiple values.
+  return ctx.markupStyleCreator.wrapRichTextStyle(util.isArray(values) ? values.join('  ') : values, styles);
+}
+function retrieveVisualColorForTooltipMarker(series, dataIndex) {
+  var style = series.getData().getItemVisual(dataIndex, 'style');
+  var color = style[series.visualDrawType];
+  return format.convertToColorString(color);
+}
+function getPaddingFromTooltipModel(model, renderMode) {
+  var padding = model.get('padding');
+  return padding != null ? padding
+  // We give slightly different to look pretty.
+  : renderMode === 'richText' ? [8, 10] : 10;
+}
+/**
+ * The major feature is generate styles for `renderMode: 'richText'`.
+ * But it also serves `renderMode: 'html'` to provide
+ * "renderMode-independent" API.
+ */
+var TooltipMarkupStyleCreator = /** @class */function () {
+  function TooltipMarkupStyleCreator() {
+    this.richTextStyles = {};
+    // Notice that "generate a style name" usually happens repeatedly when mouse is moving and
+    // a tooltip is displayed. So we put the `_nextStyleNameId` as a member of each creator
+    // rather than static shared by all creators (which will cause it increase to fast).
+    this._nextStyleNameId = number.getRandomIdBase();
+  }
+  TooltipMarkupStyleCreator.prototype._generateStyleName = function () {
+    return '__EC_aUTo_' + this._nextStyleNameId++;
+  };
+  TooltipMarkupStyleCreator.prototype.makeTooltipMarker = function (markerType, colorStr, renderMode) {
+    var markerId = renderMode === 'richText' ? this._generateStyleName() : null;
+    var marker = format.getTooltipMarker({
+      color: colorStr,
+      type: markerType,
+      renderMode: renderMode,
+      markerId: markerId
+    });
+    if (util.isString(marker)) {
+      return marker;
+    } else {
+      if (process.env.NODE_ENV !== 'production') {
+        util.assert(markerId);
+      }
+      this.richTextStyles[markerId] = marker.style;
+      return marker.content;
+    }
+  };
+  /**
+   * @usage
+   * ```ts
+   * const styledText = markupStyleCreator.wrapRichTextStyle([
+   *     // The styles will be auto merged.
+   *     {
+   *         fontSize: 12,
+   *         color: 'blue'
+   *     },
+   *     {
+   *         padding: 20
+   *     }
+   * ]);
+   * ```
+   */
+  TooltipMarkupStyleCreator.prototype.wrapRichTextStyle = function (text, styles) {
+    var finalStl = {};
+    if (util.isArray(styles)) {
+      util.each(styles, function (stl) {
+        return util.extend(finalStl, stl);
+      });
+    } else {
+      util.extend(finalStl, styles);
+    }
+    var styleName = this._generateStyleName();
+    this.richTextStyles[styleName] = finalStl;
+    return "{" + styleName + "|" + text + "}";
+  };
+  return TooltipMarkupStyleCreator;
+}();
+
+exports.TooltipMarkupStyleCreator = TooltipMarkupStyleCreator;
+exports.buildTooltipMarkup = buildTooltipMarkup;
+exports.createTooltipMarkup = createTooltipMarkup;
+exports.getPaddingFromTooltipModel = getPaddingFromTooltipModel;
+exports.retrieveVisualColorForTooltipMarker = retrieveVisualColorForTooltipMarker;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/transform/filterTransform.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var conditionalExpression = require('../../util/conditionalExpression.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var log = require('../../util/log.js');
+
+var filterTransform = {
+  type: 'echarts:filter',
+  // PENDING: enhance to filter by index rather than create new data
+  transform: function (params) {
+    // [Caveat] Fail-Fast:
+    // Do not return the whole dataset unless user config indicates it explicitly.
+    // For example, if no condition is specified by mistake, returning an empty result
+    // is better than returning the entire raw source for the user to find the mistake.
+    var upstream = params.upstream;
+    var rawItem;
+    var condition = conditionalExpression.parseConditionalExpression(params.config, {
+      valueGetterAttrMap: util.createHashMap({
+        dimension: true
+      }),
+      prepareGetValue: function (exprOption) {
+        var errMsg = '';
+        var dimLoose = exprOption.dimension;
+        if (!util.hasOwn(exprOption, 'dimension')) {
+          if (process.env.NODE_ENV !== 'production') {
+            errMsg = log.makePrintable('Relation condition must has prop "dimension" specified.', 'Illegal condition:', exprOption);
+          }
+          log.throwError(errMsg);
+        }
+        var dimInfo = upstream.getDimensionInfo(dimLoose);
+        if (!dimInfo) {
+          if (process.env.NODE_ENV !== 'production') {
+            errMsg = log.makePrintable('Can not find dimension info via: ' + dimLoose + '.\n', 'Existing dimensions: ', upstream.cloneAllDimensionInfo(), '.\n', 'Illegal condition:', exprOption, '.\n');
+          }
+          log.throwError(errMsg);
+        }
+        return {
+          dimIdx: dimInfo.index
+        };
+      },
+      getValue: function (param) {
+        return upstream.retrieveValueFromItem(rawItem, param.dimIdx);
+      }
+    });
+    var resultData = [];
+    for (var i = 0, len = upstream.count(); i < len; i++) {
+      rawItem = upstream.getRawDataItem(i);
+      if (condition.evaluate()) {
+        resultData.push(rawItem);
+      }
+    }
+    return {
+      data: resultData
+    };
+  }
+};
+
+exports.filterTransform = filterTransform;

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

@@ -0,0 +1,11 @@
+'use strict';
+
+var filterTransform = require('./filterTransform.js');
+var sortTransform = require('./sortTransform.js');
+
+function install(registers) {
+  registers.registerTransform(filterTransform.filterTransform);
+  registers.registerTransform(sortTransform.sortTransform);
+}
+
+exports.install = install;

package/lib/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/component/transform/sortTransform.js

@@ -0,0 +1,117 @@
+'use strict';
+
+var types = require('../../util/types.js');
+var log = require('../../util/log.js');
+var util = require('../../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.js');
+var model = require('../../util/model.js');
+var dataValueHelper = require('../../data/helper/dataValueHelper.js');
+
+var sampleLog = '';
+if (process.env.NODE_ENV !== 'production') {
+  sampleLog = ['Valid config is like:', '{ dimension: "age", order: "asc" }', 'or [{ dimension: "age", order: "asc"], { dimension: "date", order: "desc" }]'].join(' ');
+}
+var sortTransform = {
+  type: 'echarts:sort',
+  transform: function (params) {
+    var upstream = params.upstream;
+    var config = params.config;
+    var errMsg = '';
+    // Normalize
+    // const orderExprList: OrderExpression[] = isArray(config[0])
+    //     ? config as OrderExpression[]
+    //     : [config as OrderExpression];
+    var orderExprList = model.normalizeToArray(config);
+    if (!orderExprList.length) {
+      if (process.env.NODE_ENV !== 'production') {
+        errMsg = 'Empty `config` in sort transform.';
+      }
+      log.throwError(errMsg);
+    }
+    var orderDefList = [];
+    util.each(orderExprList, function (orderExpr) {
+      var dimLoose = orderExpr.dimension;
+      var order = orderExpr.order;
+      var parserName = orderExpr.parser;
+      var incomparable = orderExpr.incomparable;
+      if (dimLoose == null) {
+        if (process.env.NODE_ENV !== 'production') {
+          errMsg = 'Sort transform config must has "dimension" specified.' + sampleLog;
+        }
+        log.throwError(errMsg);
+      }
+      if (order !== 'asc' && order !== 'desc') {
+        if (process.env.NODE_ENV !== 'production') {
+          errMsg = 'Sort transform config must has "order" specified.' + sampleLog;
+        }
+        log.throwError(errMsg);
+      }
+      if (incomparable && incomparable !== 'min' && incomparable !== 'max') {
+        var errMsg_1 = '';
+        if (process.env.NODE_ENV !== 'production') {
+          errMsg_1 = 'incomparable must be "min" or "max" rather than "' + incomparable + '".';
+        }
+        log.throwError(errMsg_1);
+      }
+      if (order !== 'asc' && order !== 'desc') {
+        var errMsg_2 = '';
+        if (process.env.NODE_ENV !== 'production') {
+          errMsg_2 = 'order must be "asc" or "desc" rather than "' + order + '".';
+        }
+        log.throwError(errMsg_2);
+      }
+      var dimInfo = upstream.getDimensionInfo(dimLoose);
+      if (!dimInfo) {
+        if (process.env.NODE_ENV !== 'production') {
+          errMsg = log.makePrintable('Can not find dimension info via: ' + dimLoose + '.\n', 'Existing dimensions: ', upstream.cloneAllDimensionInfo(), '.\n', 'Illegal config:', orderExpr, '.\n');
+        }
+        log.throwError(errMsg);
+      }
+      var parser = parserName ? dataValueHelper.getRawValueParser(parserName) : null;
+      if (parserName && !parser) {
+        if (process.env.NODE_ENV !== 'production') {
+          errMsg = log.makePrintable('Invalid parser name ' + parserName + '.\n', 'Illegal config:', orderExpr, '.\n');
+        }
+        log.throwError(errMsg);
+      }
+      orderDefList.push({
+        dimIdx: dimInfo.index,
+        parser: parser,
+        comparator: new dataValueHelper.SortOrderComparator(order, incomparable)
+      });
+    });
+    // TODO: support it?
+    var sourceFormat = upstream.sourceFormat;
+    if (sourceFormat !== types.SOURCE_FORMAT_ARRAY_ROWS && sourceFormat !== types.SOURCE_FORMAT_OBJECT_ROWS) {
+      if (process.env.NODE_ENV !== 'production') {
+        errMsg = 'sourceFormat "' + sourceFormat + '" is not supported yet';
+      }
+      log.throwError(errMsg);
+    }
+    // Other upstream format are all array.
+    var resultData = [];
+    for (var i = 0, len = upstream.count(); i < len; i++) {
+      resultData.push(upstream.getRawDataItem(i));
+    }
+    resultData.sort(function (item0, item1) {
+      for (var i = 0; i < orderDefList.length; i++) {
+        var orderDef = orderDefList[i];
+        var val0 = upstream.retrieveValueFromItem(item0, orderDef.dimIdx);
+        var val1 = upstream.retrieveValueFromItem(item1, orderDef.dimIdx);
+        if (orderDef.parser) {
+          val0 = orderDef.parser(val0);
+          val1 = orderDef.parser(val1);
+        }
+        var result = orderDef.comparator.evaluate(val0, val1);
+        if (result !== 0) {
+          return result;
+        }
+      }
+      return 0;
+    });
+    return {
+      data: resultData
+    };
+  }
+};
+
+exports.sortTransform = sortTransform;