@fecp/mobile 1.0.79 → 1.1.0

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const format = require("../../util/format.js");
+const env = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/env.js");
+function shouldTooltipConfine(tooltipModel) {
+  var confineOption = tooltipModel.get("confine");
+  return confineOption != null ? !!confineOption : 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 ? stl[style] : 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@5.6.0/node_modules/echarts/lib/component/tooltip/install.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const install$1 = require("../axisPointer/install.js");
+const extension = require("../../extension.js");
+const TooltipModel = require("./TooltipModel.js");
+const TooltipView = require("./TooltipView.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+function install(registers) {
+  extension.use(install$1.install);
+  registers.registerComponentModel(TooltipModel.default);
+  registers.registerComponentView(TooltipView.default);
+  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@5.6.0/node_modules/echarts/lib/component/tooltip/seriesFormatTooltip.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const tooltipMarkup = require("./tooltipMarkup.js");
+const dataProvider = require("../../data/helper/dataProvider.js");
+const 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);
+  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;
+    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;
+  }
+  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,
+    blocks: [tooltipMarkup.createTooltipMarkup("nameValue", {
+      markerType: "item",
+      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
+    })].concat(subBlocks || [])
+  });
+}
+function formatTooltipArrayValue(value, series, dataIndex, tooltipDims, colorStr) {
+  var data = series.getData();
+  var isValueMultipleLine = util.reduce(value, function(isValueMultipleLine2, val, idx) {
+    var dimItem = data.getDimensionInfo(idx);
+    return isValueMultipleLine2 = isValueMultipleLine2 || 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);
+  }) : util.each(value, setEachItem);
+  function setEachItem(val, dim) {
+    var dimInfo = data.getDimensionInfo(dim);
+    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,
+    inlineValueTypes,
+    blocks
+  };
+}
+exports.defaultSeriesFormatTooltip = defaultSeriesFormatTooltip;

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

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const format = require("../../util/format.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const dataValueHelper = require("../../data/helper/dataValueHelper.js");
+const number = require("../../util/number.js");
+const dom = require("../../../../../../zrender@5.6.1/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";
+  }
+}
+function getTooltipTextStyle(textStyle, renderMode) {
+  var nameFontColor = textStyle.color || "#6e7079";
+  var nameFontSize = textStyle.fontSize || 12;
+  var nameFontWeight = textStyle.fontWeight || "400";
+  var valueFontColor = textStyle.color || "#464646";
+  var valueFontSize = textStyle.fontSize || 14;
+  var valueFontWeight = textStyle.fontWeight || "900";
+  if (renderMode === "html") {
+    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
+      }
+    };
+  }
+}
+var HTML_GAPS = [0, 10, 20, 30];
+var RICH_TEXT_GAPS = ["", "\n", "\n\n", "\n\n\n"];
+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 (subGapLevel >= gapLevel_1) {
+        gapLevel_1 = subGapLevel + +(hasInnerGap_1 && // 0 always can not be readable gap level.
+        (!subGapLevel || 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);
+      });
+    } else if (orderMode === "seriesDesc") {
+      subBlocks.reverse();
+    }
+  }
+  util.each(subBlocks, function(subBlock, idx) {
+    var valueFormatter = fragment.valueFormatter;
+    var subMarkupText2 = getBuilder(subBlock)(
+      // Inherit valueFormatter
+      valueFormatter ? util.extend(util.extend({}, ctx), {
+        valueFormatter
+      }) : ctx,
+      subBlock,
+      idx > 0 ? gaps.html : 0,
+      toolTipTextStyle
+    );
+    subMarkupText2 != null && subMarkupTextList.push(subMarkupText2);
+  });
+  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 || "#333", 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;
+  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)) + (noValue ? "" : wrapInlineValueRichText(ctx, readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)) : wrapBlockHTML(toolTipTextStyle, (noMarker ? "" : markerStr) + (noName ? "" : wrapInlineNameHTML(readableName, !noMarker, nameStyle)) + (noValue ? "" : wrapInlineValueHTML(readableValueList, valueAlignRight, valueCloseToMarker, valueStyle)), topMarginForOuterGap);
+}
+function buildTooltipMarkup(fragment, markupStyleCreator, renderMode, orderMode, useUTC, toolTipTextStyle) {
+  if (!fragment) {
+    return;
+  }
+  var builder = getBuilder(fragment);
+  var ctx = {
+    useUTC,
+    renderMode,
+    orderMode,
+    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) {
+  var paddingStr = valueCloseToMarker ? "10px" : "20px";
+  var alignCSS = alignRight ? "float:right;margin-left:" + paddingStr : "";
+  valueList = util.isArray(valueList) ? valueList : [valueList];
+  return '<span style="' + alignCSS + ";" + style + '">' + 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"
+  });
+  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 : renderMode === "richText" ? [8, 10] : 10;
+}
+var TooltipMarkupStyleCreator = (
+  /** @class */
+  function() {
+    function TooltipMarkupStyleCreator2() {
+      this.richTextStyles = {};
+      this._nextStyleNameId = number.getRandomIdBase();
+    }
+    TooltipMarkupStyleCreator2.prototype._generateStyleName = function() {
+      return "__EC_aUTo_" + this._nextStyleNameId++;
+    };
+    TooltipMarkupStyleCreator2.prototype.makeTooltipMarker = function(markerType, colorStr, renderMode) {
+      var markerId = renderMode === "richText" ? this._generateStyleName() : null;
+      var marker = format.getTooltipMarker({
+        color: colorStr,
+        type: markerType,
+        renderMode,
+        markerId
+      });
+      if (util.isString(marker)) {
+        return marker;
+      } else {
+        this.richTextStyles[markerId] = marker.style;
+        return marker.content;
+      }
+    };
+    TooltipMarkupStyleCreator2.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 TooltipMarkupStyleCreator2;
+  }()
+);
+exports.TooltipMarkupStyleCreator = TooltipMarkupStyleCreator;
+exports.buildTooltipMarkup = buildTooltipMarkup;
+exports.createTooltipMarkup = createTooltipMarkup;
+exports.getPaddingFromTooltipModel = getPaddingFromTooltipModel;
+exports.retrieveVisualColorForTooltipMarker = retrieveVisualColorForTooltipMarker;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const conditionalExpression = require("../../util/conditionalExpression.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const log = require("../../util/log.js");
+var filterTransform = {
+  type: "echarts:filter",
+  // PENDING: enhance to filter by index rather than create new data
+  transform: function(params) {
+    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")) {
+          log.throwError(errMsg);
+        }
+        var dimInfo = upstream.getDimensionInfo(dimLoose);
+        if (!dimInfo) {
+          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@5.6.0/node_modules/echarts/lib/component/transform/install.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const filterTransform = require("./filterTransform.js");
+const sortTransform = require("./sortTransform.js");
+function install(registers) {
+  registers.registerTransform(filterTransform.filterTransform);
+  registers.registerTransform(sortTransform.sortTransform);
+}
+exports.install = install;

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const types = require("../../util/types.js");
+const log = require("../../util/log.js");
+const util = require("../../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const model = require("../../util/model.js");
+const dataValueHelper = require("../../data/helper/dataValueHelper.js");
+var sortTransform = {
+  type: "echarts:sort",
+  transform: function(params) {
+    var upstream = params.upstream;
+    var config = params.config;
+    var errMsg = "";
+    var orderExprList = model.normalizeToArray(config);
+    if (!orderExprList.length) {
+      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) {
+        log.throwError(errMsg);
+      }
+      if (order !== "asc" && order !== "desc") {
+        log.throwError(errMsg);
+      }
+      if (incomparable && incomparable !== "min" && incomparable !== "max") {
+        var errMsg_1 = "";
+        log.throwError(errMsg_1);
+      }
+      if (order !== "asc" && order !== "desc") {
+        var errMsg_2 = "";
+        log.throwError(errMsg_2);
+      }
+      var dimInfo = upstream.getDimensionInfo(dimLoose);
+      if (!dimInfo) {
+        log.throwError(errMsg);
+      }
+      var parser = parserName ? dataValueHelper.getRawValueParser(parserName) : null;
+      if (parserName && !parser) {
+        log.throwError(errMsg);
+      }
+      orderDefList.push({
+        dimIdx: dimInfo.index,
+        parser,
+        comparator: new dataValueHelper.SortOrderComparator(order, incomparable)
+      });
+    });
+    var sourceFormat = upstream.sourceFormat;
+    if (sourceFormat !== types.SOURCE_FORMAT_ARRAY_ROWS && sourceFormat !== types.SOURCE_FORMAT_OBJECT_ROWS) {
+      log.throwError(errMsg);
+    }
+    var resultData = [];
+    for (var i = 0, len = upstream.count(); i < len; i++) {
+      resultData.push(upstream.getRawDataItem(i));
+    }
+    resultData.sort(function(item0, item1) {
+      for (var i2 = 0; i2 < orderDefList.length; i2++) {
+        var orderDef = orderDefList[i2];
+        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;