sun-card-design 1.1.32 → 1.1.34

package/dist/mobile/sun-card-design-mobile.es2115.js

@@ -1,19 +1,308 @@
-import { __extends } from "./sun-card-design-mobile.es1725.js";
-import Axis from "./sun-card-design-mobile.es2021.js";
-var IndicatorAxis = (
+import { createHashMap, each as each$1, clone } from "./sun-card-design-mobile.es930.js";
+import { rotate, create, translate } from "./sun-card-design-mobile.es1976.js";
+import { getLayoutRect } from "./sun-card-design-mobile.es1766.js";
+import { createScaleByModel, niceScaleExtent } from "./sun-card-design-mobile.es2097.js";
+import ParallelAxis from "./sun-card-design-mobile.es2193.js";
+import { applyTransform } from "./sun-card-design-mobile.es1764.js";
+import { round as round$1 } from "./sun-card-design-mobile.es1971.js";
+import sliderMove from "./sun-card-design-mobile.es2124.js";
+var each = each$1;
+var mathMin = Math.min;
+var mathMax = Math.max;
+var mathFloor = Math.floor;
+var mathCeil = Math.ceil;
+var round = round$1;
+var PI = Math.PI;
+var Parallel = (
   /** @class */
-  (function(_super) {
-    __extends(IndicatorAxis2, _super);
-    function IndicatorAxis2(dim, scale, radiusExtent) {
-      var _this = _super.call(this, dim, scale, radiusExtent) || this;
-      _this.type = "value";
-      _this.angle = 0;
-      _this.name = "";
-      return _this;
+  (function() {
+    function Parallel2(parallelModel, ecModel, api) {
+      this.type = "parallel";
+      this._axesMap = createHashMap();
+      this._axesLayout = {};
+      this.dimensions = parallelModel.dimensions;
+      this._model = parallelModel;
+      this._init(parallelModel, ecModel, api);
     }
-    return IndicatorAxis2;
-  })(Axis)
+    Parallel2.prototype._init = function(parallelModel, ecModel, api) {
+      var dimensions = parallelModel.dimensions;
+      var parallelAxisIndex = parallelModel.parallelAxisIndex;
+      each(dimensions, function(dim, idx) {
+        var axisIndex = parallelAxisIndex[idx];
+        var axisModel = ecModel.getComponent("parallelAxis", axisIndex);
+        var axis = this._axesMap.set(dim, new ParallelAxis(dim, createScaleByModel(axisModel), [0, 0], axisModel.get("type"), axisIndex));
+        var isCategory = axis.type === "category";
+        axis.onBand = isCategory && axisModel.get("boundaryGap");
+        axis.inverse = axisModel.get("inverse");
+        axisModel.axis = axis;
+        axis.model = axisModel;
+        axis.coordinateSystem = axisModel.coordinateSystem = this;
+      }, this);
+    };
+    Parallel2.prototype.update = function(ecModel, api) {
+      this._updateAxesFromSeries(this._model, ecModel);
+    };
+    Parallel2.prototype.containPoint = function(point) {
+      var layoutInfo = this._makeLayoutInfo();
+      var axisBase = layoutInfo.axisBase;
+      var layoutBase = layoutInfo.layoutBase;
+      var pixelDimIndex = layoutInfo.pixelDimIndex;
+      var pAxis = point[1 - pixelDimIndex];
+      var pLayout = point[pixelDimIndex];
+      return pAxis >= axisBase && pAxis <= axisBase + layoutInfo.axisLength && pLayout >= layoutBase && pLayout <= layoutBase + layoutInfo.layoutLength;
+    };
+    Parallel2.prototype.getModel = function() {
+      return this._model;
+    };
+    Parallel2.prototype._updateAxesFromSeries = function(parallelModel, ecModel) {
+      ecModel.eachSeries(function(seriesModel) {
+        if (!parallelModel.contains(seriesModel, ecModel)) {
+          return;
+        }
+        var data = seriesModel.getData();
+        each(this.dimensions, function(dim) {
+          var axis = this._axesMap.get(dim);
+          axis.scale.unionExtentFromData(data, data.mapDimension(dim));
+          niceScaleExtent(axis.scale, axis.model);
+        }, this);
+      }, this);
+    };
+    Parallel2.prototype.resize = function(parallelModel, api) {
+      this._rect = getLayoutRect(parallelModel.getBoxLayoutParams(), {
+        width: api.getWidth(),
+        height: api.getHeight()
+      });
+      this._layoutAxes();
+    };
+    Parallel2.prototype.getRect = function() {
+      return this._rect;
+    };
+    Parallel2.prototype._makeLayoutInfo = function() {
+      var parallelModel = this._model;
+      var rect = this._rect;
+      var xy = ["x", "y"];
+      var wh = ["width", "height"];
+      var layout = parallelModel.get("layout");
+      var pixelDimIndex = layout === "horizontal" ? 0 : 1;
+      var layoutLength = rect[wh[pixelDimIndex]];
+      var layoutExtent = [0, layoutLength];
+      var axisCount = this.dimensions.length;
+      var axisExpandWidth = restrict(parallelModel.get("axisExpandWidth"), layoutExtent);
+      var axisExpandCount = restrict(parallelModel.get("axisExpandCount") || 0, [0, axisCount]);
+      var axisExpandable = parallelModel.get("axisExpandable") && axisCount > 3 && axisCount > axisExpandCount && axisExpandCount > 1 && axisExpandWidth > 0 && layoutLength > 0;
+      var axisExpandWindow = parallelModel.get("axisExpandWindow");
+      var winSize;
+      if (!axisExpandWindow) {
+        winSize = restrict(axisExpandWidth * (axisExpandCount - 1), layoutExtent);
+        var axisExpandCenter = parallelModel.get("axisExpandCenter") || mathFloor(axisCount / 2);
+        axisExpandWindow = [axisExpandWidth * axisExpandCenter - winSize / 2];
+        axisExpandWindow[1] = axisExpandWindow[0] + winSize;
+      } else {
+        winSize = restrict(axisExpandWindow[1] - axisExpandWindow[0], layoutExtent);
+        axisExpandWindow[1] = axisExpandWindow[0] + winSize;
+      }
+      var axisCollapseWidth = (layoutLength - winSize) / (axisCount - axisExpandCount);
+      axisCollapseWidth < 3 && (axisCollapseWidth = 0);
+      var winInnerIndices = [mathFloor(round(axisExpandWindow[0] / axisExpandWidth, 1)) + 1, mathCeil(round(axisExpandWindow[1] / axisExpandWidth, 1)) - 1];
+      var axisExpandWindow0Pos = axisCollapseWidth / axisExpandWidth * axisExpandWindow[0];
+      return {
+        layout,
+        pixelDimIndex,
+        layoutBase: rect[xy[pixelDimIndex]],
+        layoutLength,
+        axisBase: rect[xy[1 - pixelDimIndex]],
+        axisLength: rect[wh[1 - pixelDimIndex]],
+        axisExpandable,
+        axisExpandWidth,
+        axisCollapseWidth,
+        axisExpandWindow,
+        axisCount,
+        winInnerIndices,
+        axisExpandWindow0Pos
+      };
+    };
+    Parallel2.prototype._layoutAxes = function() {
+      var rect = this._rect;
+      var axes = this._axesMap;
+      var dimensions = this.dimensions;
+      var layoutInfo = this._makeLayoutInfo();
+      var layout = layoutInfo.layout;
+      axes.each(function(axis) {
+        var axisExtent = [0, layoutInfo.axisLength];
+        var idx = axis.inverse ? 1 : 0;
+        axis.setExtent(axisExtent[idx], axisExtent[1 - idx]);
+      });
+      each(dimensions, function(dim, idx) {
+        var posInfo = (layoutInfo.axisExpandable ? layoutAxisWithExpand : layoutAxisWithoutExpand)(idx, layoutInfo);
+        var positionTable = {
+          horizontal: {
+            x: posInfo.position,
+            y: layoutInfo.axisLength
+          },
+          vertical: {
+            x: 0,
+            y: posInfo.position
+          }
+        };
+        var rotationTable = {
+          horizontal: PI / 2,
+          vertical: 0
+        };
+        var position = [positionTable[layout].x + rect.x, positionTable[layout].y + rect.y];
+        var rotation = rotationTable[layout];
+        var transform = create();
+        rotate(transform, transform, rotation);
+        translate(transform, transform, position);
+        this._axesLayout[dim] = {
+          position,
+          rotation,
+          transform,
+          axisNameAvailableWidth: posInfo.axisNameAvailableWidth,
+          axisLabelShow: posInfo.axisLabelShow,
+          nameTruncateMaxWidth: posInfo.nameTruncateMaxWidth,
+          tickDirection: 1,
+          labelDirection: 1
+        };
+      }, this);
+    };
+    Parallel2.prototype.getAxis = function(dim) {
+      return this._axesMap.get(dim);
+    };
+    Parallel2.prototype.dataToPoint = function(value, dim) {
+      return this.axisCoordToPoint(this._axesMap.get(dim).dataToCoord(value), dim);
+    };
+    Parallel2.prototype.eachActiveState = function(data, callback, start, end) {
+      start == null && (start = 0);
+      end == null && (end = data.count());
+      var axesMap = this._axesMap;
+      var dimensions = this.dimensions;
+      var dataDimensions = [];
+      var axisModels = [];
+      each$1(dimensions, function(axisDim) {
+        dataDimensions.push(data.mapDimension(axisDim));
+        axisModels.push(axesMap.get(axisDim).model);
+      });
+      var hasActiveSet = this.hasAxisBrushed();
+      for (var dataIndex = start; dataIndex < end; dataIndex++) {
+        var activeState = void 0;
+        if (!hasActiveSet) {
+          activeState = "normal";
+        } else {
+          activeState = "active";
+          var values = data.getValues(dataDimensions, dataIndex);
+          for (var j = 0, lenj = dimensions.length; j < lenj; j++) {
+            var state = axisModels[j].getActiveState(values[j]);
+            if (state === "inactive") {
+              activeState = "inactive";
+              break;
+            }
+          }
+        }
+        callback(activeState, dataIndex);
+      }
+    };
+    Parallel2.prototype.hasAxisBrushed = function() {
+      var dimensions = this.dimensions;
+      var axesMap = this._axesMap;
+      var hasActiveSet = false;
+      for (var j = 0, lenj = dimensions.length; j < lenj; j++) {
+        if (axesMap.get(dimensions[j]).model.getActiveState() !== "normal") {
+          hasActiveSet = true;
+        }
+      }
+      return hasActiveSet;
+    };
+    Parallel2.prototype.axisCoordToPoint = function(coord, dim) {
+      var axisLayout = this._axesLayout[dim];
+      return applyTransform([coord, 0], axisLayout.transform);
+    };
+    Parallel2.prototype.getAxisLayout = function(dim) {
+      return clone(this._axesLayout[dim]);
+    };
+    Parallel2.prototype.getSlidedAxisExpandWindow = function(point) {
+      var layoutInfo = this._makeLayoutInfo();
+      var pixelDimIndex = layoutInfo.pixelDimIndex;
+      var axisExpandWindow = layoutInfo.axisExpandWindow.slice();
+      var winSize = axisExpandWindow[1] - axisExpandWindow[0];
+      var extent = [0, layoutInfo.axisExpandWidth * (layoutInfo.axisCount - 1)];
+      if (!this.containPoint(point)) {
+        return {
+          behavior: "none",
+          axisExpandWindow
+        };
+      }
+      var pointCoord = point[pixelDimIndex] - layoutInfo.layoutBase - layoutInfo.axisExpandWindow0Pos;
+      var delta;
+      var behavior = "slide";
+      var axisCollapseWidth = layoutInfo.axisCollapseWidth;
+      var triggerArea = this._model.get("axisExpandSlideTriggerArea");
+      var useJump = triggerArea[0] != null;
+      if (axisCollapseWidth) {
+        if (useJump && axisCollapseWidth && pointCoord < winSize * triggerArea[0]) {
+          behavior = "jump";
+          delta = pointCoord - winSize * triggerArea[2];
+        } else if (useJump && axisCollapseWidth && pointCoord > winSize * (1 - triggerArea[0])) {
+          behavior = "jump";
+          delta = pointCoord - winSize * (1 - triggerArea[2]);
+        } else {
+          (delta = pointCoord - winSize * triggerArea[1]) >= 0 && (delta = pointCoord - winSize * (1 - triggerArea[1])) <= 0 && (delta = 0);
+        }
+        delta *= layoutInfo.axisExpandWidth / axisCollapseWidth;
+        delta ? sliderMove(delta, axisExpandWindow, extent, "all") : behavior = "none";
+      } else {
+        var winSize2 = axisExpandWindow[1] - axisExpandWindow[0];
+        var pos = extent[1] * pointCoord / winSize2;
+        axisExpandWindow = [mathMax(0, pos - winSize2 / 2)];
+        axisExpandWindow[1] = mathMin(extent[1], axisExpandWindow[0] + winSize2);
+        axisExpandWindow[0] = axisExpandWindow[1] - winSize2;
+      }
+      return {
+        axisExpandWindow,
+        behavior
+      };
+    };
+    return Parallel2;
+  })()
 );
+function restrict(len, extent) {
+  return mathMin(mathMax(len, extent[0]), extent[1]);
+}
+function layoutAxisWithoutExpand(axisIndex, layoutInfo) {
+  var step = layoutInfo.layoutLength / (layoutInfo.axisCount - 1);
+  return {
+    position: step * axisIndex,
+    axisNameAvailableWidth: step,
+    axisLabelShow: true
+  };
+}
+function layoutAxisWithExpand(axisIndex, layoutInfo) {
+  var layoutLength = layoutInfo.layoutLength;
+  var axisExpandWidth = layoutInfo.axisExpandWidth;
+  var axisCount = layoutInfo.axisCount;
+  var axisCollapseWidth = layoutInfo.axisCollapseWidth;
+  var winInnerIndices = layoutInfo.winInnerIndices;
+  var position;
+  var axisNameAvailableWidth = axisCollapseWidth;
+  var axisLabelShow = false;
+  var nameTruncateMaxWidth;
+  if (axisIndex < winInnerIndices[0]) {
+    position = axisIndex * axisCollapseWidth;
+    nameTruncateMaxWidth = axisCollapseWidth;
+  } else if (axisIndex <= winInnerIndices[1]) {
+    position = layoutInfo.axisExpandWindow0Pos + axisIndex * axisExpandWidth - layoutInfo.axisExpandWindow[0];
+    axisNameAvailableWidth = axisExpandWidth;
+    axisLabelShow = true;
+  } else {
+    position = layoutLength - (axisCount - 1 - axisIndex) * axisCollapseWidth;
+    nameTruncateMaxWidth = axisCollapseWidth;
+  }
+  return {
+    position,
+    axisNameAvailableWidth,
+    axisLabelShow,
+    nameTruncateMaxWidth
+  };
+}
 export {
-  IndicatorAxis as default
+  Parallel as default
 };