sun-card-design 1.1.16 → 1.1.18

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

@@ -1,120 +1,367 @@
-import { quadraticSubdivide, quadraticAt as quadraticAt$1 } from "./sun-card-design-mobile.es2159.js";
-import { clone, copy, sub, normalize, scaleAndAdd, distSquare } from "./sun-card-design-mobile.es1965.js";
-import { getSymbolSize } from "./sun-card-design-mobile.es2064.js";
-var v1 = [];
-var v2 = [];
-var v3 = [];
-var quadraticAt = quadraticAt$1;
-var v2DistSquare = distSquare;
-var mathAbs = Math.abs;
-function intersectCurveCircle(curvePoints, center, radius) {
-  var p0 = curvePoints[0];
-  var p1 = curvePoints[1];
-  var p2 = curvePoints[2];
-  var d = Infinity;
-  var t;
-  var radiusSquare = radius * radius;
-  var interval = 0.1;
-  for (var _t = 0.1; _t <= 0.9; _t += 0.1) {
-    v1[0] = quadraticAt(p0[0], p1[0], p2[0], _t);
-    v1[1] = quadraticAt(p0[1], p1[1], p2[1], _t);
-    var diff = mathAbs(v2DistSquare(v1, center) - radiusSquare);
-    if (diff < d) {
-      d = diff;
-      t = _t;
-    }
-  }
-  for (var i = 0; i < 32; i++) {
-    var next = t + interval;
-    v2[0] = quadraticAt(p0[0], p1[0], p2[0], t);
-    v2[1] = quadraticAt(p0[1], p1[1], p2[1], t);
-    v3[0] = quadraticAt(p0[0], p1[0], p2[0], next);
-    v3[1] = quadraticAt(p0[1], p1[1], p2[1], next);
-    var diff = v2DistSquare(v2, center) - radiusSquare;
-    if (mathAbs(diff) < 0.01) {
-      break;
+import { clone, noop, assert, isObject as isObject$1, each as each$1, isArray, map, bind, keys, isString } from "./sun-card-design-mobile.es922.js";
+import { parse, stringify, fastLerp, modifyAlpha, modifyHSL } from "./sun-card-design-mobile.es1768.js";
+import { linearMap } from "./sun-card-design-mobile.es1976.js";
+import { warn } from "./sun-card-design-mobile.es1740.js";
+var each = each$1;
+var isObject = isObject$1;
+var CATEGORY_DEFAULT_VISUAL_INDEX = -1;
+var VisualMapping = (
+  /** @class */
+  (function() {
+    function VisualMapping2(option) {
+      var mappingMethod = option.mappingMethod;
+      var visualType = option.type;
+      var thisOption = this.option = clone(option);
+      this.type = visualType;
+      this.mappingMethod = mappingMethod;
+      this._normalizeData = normalizers[mappingMethod];
+      var visualHandler = VisualMapping2.visualHandlers[visualType];
+      this.applyVisual = visualHandler.applyVisual;
+      this.getColorMapper = visualHandler.getColorMapper;
+      this._normalizedToVisual = visualHandler._normalizedToVisual[mappingMethod];
+      if (mappingMethod === "piecewise") {
+        normalizeVisualRange(thisOption);
+        preprocessForPiecewise(thisOption);
+      } else if (mappingMethod === "category") {
+        thisOption.categories ? preprocessForSpecifiedCategory(thisOption) : normalizeVisualRange(thisOption, true);
+      } else {
+        assert(mappingMethod !== "linear" || thisOption.dataExtent);
+        normalizeVisualRange(thisOption);
+      }
     }
-    var nextDiff = v2DistSquare(v3, center) - radiusSquare;
-    interval /= 2;
-    if (diff < 0) {
-      if (nextDiff >= 0) {
-        t = t + interval;
+    VisualMapping2.prototype.mapValueToVisual = function(value) {
+      var normalized = this._normalizeData(value);
+      return this._normalizedToVisual(normalized, value);
+    };
+    VisualMapping2.prototype.getNormalizer = function() {
+      return bind(this._normalizeData, this);
+    };
+    VisualMapping2.listVisualTypes = function() {
+      return keys(VisualMapping2.visualHandlers);
+    };
+    VisualMapping2.isValidType = function(visualType) {
+      return VisualMapping2.visualHandlers.hasOwnProperty(visualType);
+    };
+    VisualMapping2.eachVisual = function(visual, callback, context) {
+      if (isObject$1(visual)) {
+        each$1(visual, callback, context);
       } else {
-        t = t - interval;
+        callback.call(context, visual);
       }
-    } else {
-      if (nextDiff >= 0) {
-        t = t - interval;
+    };
+    VisualMapping2.mapVisual = function(visual, callback, context) {
+      var isPrimary;
+      var newVisual = isArray(visual) ? [] : isObject$1(visual) ? {} : (isPrimary = true, null);
+      VisualMapping2.eachVisual(visual, function(v, key) {
+        var newVal = callback.call(context, v, key);
+        isPrimary ? newVisual = newVal : newVisual[key] = newVal;
+      });
+      return newVisual;
+    };
+    VisualMapping2.retrieveVisuals = function(obj) {
+      var ret = {};
+      var hasVisual;
+      obj && each(VisualMapping2.visualHandlers, function(h, visualType) {
+        if (obj.hasOwnProperty(visualType)) {
+          ret[visualType] = obj[visualType];
+          hasVisual = true;
+        }
+      });
+      return hasVisual ? ret : null;
+    };
+    VisualMapping2.prepareVisualTypes = function(visualTypes) {
+      if (isArray(visualTypes)) {
+        visualTypes = visualTypes.slice();
+      } else if (isObject(visualTypes)) {
+        var types_1 = [];
+        each(visualTypes, function(item, type) {
+          types_1.push(type);
+        });
+        visualTypes = types_1;
       } else {
-        t = t + interval;
+        return [];
       }
-    }
-  }
-  return t;
-}
-function adjustEdge(graph, scale) {
-  var tmp0 = [];
-  var quadraticSubdivide$1 = quadraticSubdivide;
-  var pts = [[], [], []];
-  var pts2 = [[], []];
-  var v = [];
-  scale /= 2;
-  graph.eachEdge(function(edge, idx) {
-    var linePoints = edge.getLayout();
-    var fromSymbol = edge.getVisual("fromSymbol");
-    var toSymbol = edge.getVisual("toSymbol");
-    if (!linePoints.__original) {
-      linePoints.__original = [clone(linePoints[0]), clone(linePoints[1])];
-      if (linePoints[2]) {
-        linePoints.__original.push(clone(linePoints[2]));
+      visualTypes.sort(function(type1, type2) {
+        return type2 === "color" && type1 !== "color" && type1.indexOf("color") === 0 ? 1 : -1;
+      });
+      return visualTypes;
+    };
+    VisualMapping2.dependsOn = function(visualType1, visualType2) {
+      return visualType2 === "color" ? !!(visualType1 && visualType1.indexOf(visualType2) === 0) : visualType1 === visualType2;
+    };
+    VisualMapping2.findPieceIndex = function(value, pieceList, findClosestWhenOutside) {
+      var possibleI;
+      var abs = Infinity;
+      for (var i = 0, len = pieceList.length; i < len; i++) {
+        var pieceValue = pieceList[i].value;
+        if (pieceValue != null) {
+          if (pieceValue === value || isString(pieceValue) && pieceValue === value + "") {
+            return i;
+          }
+          findClosestWhenOutside && updatePossible(pieceValue, i);
+        }
       }
-    }
-    var originalPoints = linePoints.__original;
-    if (linePoints[2] != null) {
-      copy(pts[0], originalPoints[0]);
-      copy(pts[1], originalPoints[2]);
-      copy(pts[2], originalPoints[1]);
-      if (fromSymbol && fromSymbol !== "none") {
-        var symbolSize = getSymbolSize(edge.node1);
-        var t = intersectCurveCircle(pts, originalPoints[0], symbolSize * scale);
-        quadraticSubdivide$1(pts[0][0], pts[1][0], pts[2][0], t, tmp0);
-        pts[0][0] = tmp0[3];
-        pts[1][0] = tmp0[4];
-        quadraticSubdivide$1(pts[0][1], pts[1][1], pts[2][1], t, tmp0);
-        pts[0][1] = tmp0[3];
-        pts[1][1] = tmp0[4];
+      for (var i = 0, len = pieceList.length; i < len; i++) {
+        var piece = pieceList[i];
+        var interval = piece.interval;
+        var close_1 = piece.close;
+        if (interval) {
+          if (interval[0] === -Infinity) {
+            if (littleThan(close_1[1], value, interval[1])) {
+              return i;
+            }
+          } else if (interval[1] === Infinity) {
+            if (littleThan(close_1[0], interval[0], value)) {
+              return i;
+            }
+          } else if (littleThan(close_1[0], interval[0], value) && littleThan(close_1[1], value, interval[1])) {
+            return i;
+          }
+          findClosestWhenOutside && updatePossible(interval[0], i);
+          findClosestWhenOutside && updatePossible(interval[1], i);
+        }
       }
-      if (toSymbol && toSymbol !== "none") {
-        var symbolSize = getSymbolSize(edge.node2);
-        var t = intersectCurveCircle(pts, originalPoints[1], symbolSize * scale);
-        quadraticSubdivide$1(pts[0][0], pts[1][0], pts[2][0], t, tmp0);
-        pts[1][0] = tmp0[1];
-        pts[2][0] = tmp0[2];
-        quadraticSubdivide$1(pts[0][1], pts[1][1], pts[2][1], t, tmp0);
-        pts[1][1] = tmp0[1];
-        pts[2][1] = tmp0[2];
+      if (findClosestWhenOutside) {
+        return value === Infinity ? pieceList.length - 1 : value === -Infinity ? 0 : possibleI;
       }
-      copy(linePoints[0], pts[0]);
-      copy(linePoints[1], pts[2]);
-      copy(linePoints[2], pts[1]);
-    } else {
-      copy(pts2[0], originalPoints[0]);
-      copy(pts2[1], originalPoints[1]);
-      sub(v, pts2[1], pts2[0]);
-      normalize(v, v);
-      if (fromSymbol && fromSymbol !== "none") {
-        var symbolSize = getSymbolSize(edge.node1);
-        scaleAndAdd(pts2[0], pts2[0], v, symbolSize * scale);
+      function updatePossible(val, index) {
+        var newAbs = Math.abs(val - value);
+        if (newAbs < abs) {
+          abs = newAbs;
+          possibleI = index;
+        }
       }
-      if (toSymbol && toSymbol !== "none") {
-        var symbolSize = getSymbolSize(edge.node2);
-        scaleAndAdd(pts2[1], pts2[1], v, -symbolSize * scale);
+    };
+    VisualMapping2.visualHandlers = {
+      color: {
+        applyVisual: makeApplyVisual("color"),
+        getColorMapper: function() {
+          var thisOption = this.option;
+          return bind(thisOption.mappingMethod === "category" ? function(value, isNormalized) {
+            !isNormalized && (value = this._normalizeData(value));
+            return doMapCategory.call(this, value);
+          } : function(value, isNormalized, out) {
+            var returnRGBArray = !!out;
+            !isNormalized && (value = this._normalizeData(value));
+            out = fastLerp(value, thisOption.parsedVisual, out);
+            return returnRGBArray ? out : stringify(out, "rgba");
+          }, this);
+        },
+        _normalizedToVisual: {
+          linear: function(normalized) {
+            return stringify(fastLerp(normalized, this.option.parsedVisual), "rgba");
+          },
+          category: doMapCategory,
+          piecewise: function(normalized, value) {
+            var result = getSpecifiedVisual.call(this, value);
+            if (result == null) {
+              result = stringify(fastLerp(normalized, this.option.parsedVisual), "rgba");
+            }
+            return result;
+          },
+          fixed: doMapFixed
+        }
+      },
+      colorHue: makePartialColorVisualHandler(function(color, value) {
+        return modifyHSL(color, value);
+      }),
+      colorSaturation: makePartialColorVisualHandler(function(color, value) {
+        return modifyHSL(color, null, value);
+      }),
+      colorLightness: makePartialColorVisualHandler(function(color, value) {
+        return modifyHSL(color, null, null, value);
+      }),
+      colorAlpha: makePartialColorVisualHandler(function(color, value) {
+        return modifyAlpha(color, value);
+      }),
+      decal: {
+        applyVisual: makeApplyVisual("decal"),
+        _normalizedToVisual: {
+          linear: null,
+          category: doMapCategory,
+          piecewise: null,
+          fixed: null
+        }
+      },
+      opacity: {
+        applyVisual: makeApplyVisual("opacity"),
+        _normalizedToVisual: createNormalizedToNumericVisual([0, 1])
+      },
+      liftZ: {
+        applyVisual: makeApplyVisual("liftZ"),
+        _normalizedToVisual: {
+          linear: doMapFixed,
+          category: doMapFixed,
+          piecewise: doMapFixed,
+          fixed: doMapFixed
+        }
+      },
+      symbol: {
+        applyVisual: function(value, getter, setter) {
+          var symbolCfg = this.mapValueToVisual(value);
+          setter("symbol", symbolCfg);
+        },
+        _normalizedToVisual: {
+          linear: doMapToArray,
+          category: doMapCategory,
+          piecewise: function(normalized, value) {
+            var result = getSpecifiedVisual.call(this, value);
+            if (result == null) {
+              result = doMapToArray.call(this, normalized);
+            }
+            return result;
+          },
+          fixed: doMapFixed
+        }
+      },
+      symbolSize: {
+        applyVisual: makeApplyVisual("symbolSize"),
+        _normalizedToVisual: createNormalizedToNumericVisual([0, 1])
       }
-      copy(linePoints[0], pts2[0]);
-      copy(linePoints[1], pts2[1]);
+    };
+    return VisualMapping2;
+  })()
+);
+function preprocessForPiecewise(thisOption) {
+  var pieceList = thisOption.pieceList;
+  thisOption.hasSpecialVisual = false;
+  each$1(pieceList, function(piece, index) {
+    piece.originIndex = index;
+    if (piece.visual != null) {
+      thisOption.hasSpecialVisual = true;
     }
   });
 }
+function preprocessForSpecifiedCategory(thisOption) {
+  var categories = thisOption.categories;
+  var categoryMap = thisOption.categoryMap = {};
+  var visual = thisOption.visual;
+  each(categories, function(cate, index) {
+    categoryMap[cate] = index;
+  });
+  if (!isArray(visual)) {
+    var visualArr_1 = [];
+    if (isObject$1(visual)) {
+      each(visual, function(v, cate) {
+        var index = categoryMap[cate];
+        visualArr_1[index != null ? index : CATEGORY_DEFAULT_VISUAL_INDEX] = v;
+      });
+    } else {
+      visualArr_1[CATEGORY_DEFAULT_VISUAL_INDEX] = visual;
+    }
+    visual = setVisualToOption(thisOption, visualArr_1);
+  }
+  for (var i = categories.length - 1; i >= 0; i--) {
+    if (visual[i] == null) {
+      delete categoryMap[categories[i]];
+      categories.pop();
+    }
+  }
+}
+function normalizeVisualRange(thisOption, isCategory) {
+  var visual = thisOption.visual;
+  var visualArr = [];
+  if (isObject$1(visual)) {
+    each(visual, function(v) {
+      visualArr.push(v);
+    });
+  } else if (visual != null) {
+    visualArr.push(visual);
+  }
+  var doNotNeedPair = {
+    color: 1,
+    symbol: 1
+  };
+  if (!isCategory && visualArr.length === 1 && !doNotNeedPair.hasOwnProperty(thisOption.type)) {
+    visualArr[1] = visualArr[0];
+  }
+  setVisualToOption(thisOption, visualArr);
+}
+function makePartialColorVisualHandler(applyValue) {
+  return {
+    applyVisual: function(value, getter, setter) {
+      var colorChannel = this.mapValueToVisual(value);
+      setter("color", applyValue(getter("color"), colorChannel));
+    },
+    _normalizedToVisual: createNormalizedToNumericVisual([0, 1])
+  };
+}
+function doMapToArray(normalized) {
+  var visual = this.option.visual;
+  return visual[Math.round(linearMap(normalized, [0, 1], [0, visual.length - 1], true))] || {};
+}
+function makeApplyVisual(visualType) {
+  return function(value, getter, setter) {
+    setter(visualType, this.mapValueToVisual(value));
+  };
+}
+function doMapCategory(normalized) {
+  var visual = this.option.visual;
+  return visual[this.option.loop && normalized !== CATEGORY_DEFAULT_VISUAL_INDEX ? normalized % visual.length : normalized];
+}
+function doMapFixed() {
+  return this.option.visual[0];
+}
+function createNormalizedToNumericVisual(sourceExtent) {
+  return {
+    linear: function(normalized) {
+      return linearMap(normalized, sourceExtent, this.option.visual, true);
+    },
+    category: doMapCategory,
+    piecewise: function(normalized, value) {
+      var result = getSpecifiedVisual.call(this, value);
+      if (result == null) {
+        result = linearMap(normalized, sourceExtent, this.option.visual, true);
+      }
+      return result;
+    },
+    fixed: doMapFixed
+  };
+}
+function getSpecifiedVisual(value) {
+  var thisOption = this.option;
+  var pieceList = thisOption.pieceList;
+  if (thisOption.hasSpecialVisual) {
+    var pieceIndex = VisualMapping.findPieceIndex(value, pieceList);
+    var piece = pieceList[pieceIndex];
+    if (piece && piece.visual) {
+      return piece.visual[this.type];
+    }
+  }
+}
+function setVisualToOption(thisOption, visualArr) {
+  thisOption.visual = visualArr;
+  if (thisOption.type === "color") {
+    thisOption.parsedVisual = map(visualArr, function(item) {
+      var color = parse(item);
+      if (!color && process.env.NODE_ENV !== "production") {
+        warn("'" + item + "' is an illegal color, fallback to '#000000'", true);
+      }
+      return color || [0, 0, 0, 1];
+    });
+  }
+  return visualArr;
+}
+var normalizers = {
+  linear: function(value) {
+    return linearMap(value, this.option.dataExtent, [0, 1], true);
+  },
+  piecewise: function(value) {
+    var pieceList = this.option.pieceList;
+    var pieceIndex = VisualMapping.findPieceIndex(value, pieceList, true);
+    if (pieceIndex != null) {
+      return linearMap(pieceIndex, [0, pieceList.length - 1], [0, 1], true);
+    }
+  },
+  category: function(value) {
+    var index = this.option.categories ? this.option.categoryMap[value] : value;
+    return index == null ? CATEGORY_DEFAULT_VISUAL_INDEX : index;
+  },
+  fixed: noop
+};
+function littleThan(close, a, b) {
+  return close ? a <= b : a < b;
+}
 export {
-  adjustEdge as default
+  VisualMapping as default
 };

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

@@ -1,22 +1,31 @@
-function getNodeGlobalScale(seriesModel) {
+import { clone } from "./sun-card-design-mobile.es1967.js";
+import { retrieve3 } from "./sun-card-design-mobile.es922.js";
+import { getCurvenessForEdge } from "./sun-card-design-mobile.es2067.js";
+function simpleLayout(seriesModel) {
   var coordSys = seriesModel.coordinateSystem;
-  if (coordSys.type !== "view") {
-    return 1;
+  if (coordSys && coordSys.type !== "view") {
+    return;
   }
-  var nodeScaleRatio = seriesModel.option.nodeScaleRatio;
-  var groupZoom = coordSys.scaleX;
-  var roamZoom = coordSys.getZoom();
-  var nodeScale = (roamZoom - 1) * nodeScaleRatio + 1;
-  return nodeScale / groupZoom;
+  var graph = seriesModel.getGraph();
+  graph.eachNode(function(node) {
+    var model = node.getModel();
+    node.setLayout([+model.get("x"), +model.get("y")]);
+  });
+  simpleLayoutEdge(graph, seriesModel);
 }
-function getSymbolSize(node) {
-  var symbolSize = node.getVisual("symbolSize");
-  if (symbolSize instanceof Array) {
-    symbolSize = (symbolSize[0] + symbolSize[1]) / 2;
-  }
-  return +symbolSize;
+function simpleLayoutEdge(graph, seriesModel) {
+  graph.eachEdge(function(edge, index) {
+    var curveness = retrieve3(edge.getModel().get(["lineStyle", "curveness"]), -getCurvenessForEdge(edge, seriesModel, index, true), 0);
+    var p1 = clone(edge.node1.getLayout());
+    var p2 = clone(edge.node2.getLayout());
+    var points = [p1, p2];
+    if (+curveness) {
+      points.push([(p1[0] + p2[0]) / 2 - (p1[1] - p2[1]) * curveness, (p1[1] + p2[1]) / 2 - (p2[0] - p1[0]) * curveness]);
+    }
+    edge.setLayout(points);
+  });
 }
 export {
-  getNodeGlobalScale,
-  getSymbolSize
+  simpleLayout,
+  simpleLayoutEdge
 };