sun-card-design 1.1.16 → 1.1.18

package/dist/pc/sun-card-design-pc.es2190.js

@@ -1,275 +1,198 @@
-import { copyTransform } from "./sun-card-design-pc.es1966.js";
-import { createBrushScope } from "./sun-card-design-pc.es2137.js";
-import SVGPathRebuilder from "./sun-card-design-pc.es2188.js";
-import PathProxy from "./sun-card-design-pc.es2048.js";
-import { getSRTTransformString, getPathPrecision } from "./sun-card-design-pc.es2138.js";
-import { each, keys, isString, extend, filter, isNumber } from "./sun-card-design-pc.es922.js";
-import CompoundPath from "./sun-card-design-pc.es1976.js";
-import { createCubicEasingFunc } from "./sun-card-design-pc.es2165.js";
-import { getClassId } from "./sun-card-design-pc.es2201.js";
-var EASING_MAP = {
-  cubicIn: "0.32,0,0.67,0",
-  cubicOut: "0.33,1,0.68,1",
-  cubicInOut: "0.65,0,0.35,1",
-  quadraticIn: "0.11,0,0.5,0",
-  quadraticOut: "0.5,1,0.89,1",
-  quadraticInOut: "0.45,0,0.55,1",
-  quarticIn: "0.5,0,0.75,0",
-  quarticOut: "0.25,1,0.5,1",
-  quarticInOut: "0.76,0,0.24,1",
-  quinticIn: "0.64,0,0.78,0",
-  quinticOut: "0.22,1,0.36,1",
-  quinticInOut: "0.83,0,0.17,1",
-  sinusoidalIn: "0.12,0,0.39,0",
-  sinusoidalOut: "0.61,1,0.88,1",
-  sinusoidalInOut: "0.37,0,0.63,1",
-  exponentialIn: "0.7,0,0.84,0",
-  exponentialOut: "0.16,1,0.3,1",
-  exponentialInOut: "0.87,0,0.13,1",
-  circularIn: "0.55,0,1,0.45",
-  circularOut: "0,0.55,0.45,1",
-  circularInOut: "0.85,0,0.15,1"
-};
-var transformOriginKey = "transform-origin";
-function buildPathString(el, kfShape, path) {
-  var shape = extend({}, el.shape);
-  extend(shape, kfShape);
-  el.buildPath(path, shape);
-  var svgPathBuilder = new SVGPathRebuilder();
-  svgPathBuilder.reset(getPathPrecision(el));
-  path.rebuildPath(svgPathBuilder, 1);
-  svgPathBuilder.generateStr();
-  return svgPathBuilder.getStr();
+import { cubicSubdivide } from "./sun-card-design-pc.es2159.js";
+import PathProxy from "./sun-card-design-pc.es1979.js";
+var CMD = PathProxy.CMD;
+function aroundEqual(a, b) {
+  return Math.abs(a - b) < 1e-5;
 }
-function setTransformOrigin(target, transform) {
-  var originX = transform.originX, originY = transform.originY;
-  if (originX || originY) {
-    target[transformOriginKey] = originX + "px " + originY + "px";
+function pathToBezierCurves(path) {
+  var data = path.data;
+  var len = path.len();
+  var bezierArrayGroups = [];
+  var currentSubpath;
+  var xi = 0;
+  var yi = 0;
+  var x0 = 0;
+  var y0 = 0;
+  function createNewSubpath(x, y) {
+    if (currentSubpath && currentSubpath.length > 2) {
+      bezierArrayGroups.push(currentSubpath);
+    }
+    currentSubpath = [x, y];
   }
-}
-var ANIMATE_STYLE_MAP = {
-  fill: "fill",
-  opacity: "opacity",
-  lineWidth: "stroke-width",
-  lineDashOffset: "stroke-dashoffset"
-};
-function addAnimation(cssAnim, scope) {
-  var animationName = scope.zrId + "-ani-" + scope.cssAnimIdx++;
-  scope.cssAnims[animationName] = cssAnim;
-  return animationName;
-}
-function createCompoundPathCSSAnimation(el, attrs, scope) {
-  var paths = el.shape.paths;
-  var composedAnim = {};
-  var cssAnimationCfg;
-  var cssAnimationName;
-  each(paths, function(path) {
-    var subScope = createBrushScope(scope.zrId);
-    subScope.animation = true;
-    createCSSAnimation(path, {}, subScope, true);
-    var cssAnims = subScope.cssAnims;
-    var cssNodes = subScope.cssNodes;
-    var animNames = keys(cssAnims);
-    var len = animNames.length;
-    if (!len) {
-      return;
-    }
-    cssAnimationName = animNames[len - 1];
-    var lastAnim = cssAnims[cssAnimationName];
-    for (var percent in lastAnim) {
-      var kf = lastAnim[percent];
-      composedAnim[percent] = composedAnim[percent] || { d: "" };
-      composedAnim[percent].d += kf.d || "";
-    }
-    for (var className in cssNodes) {
-      var val = cssNodes[className].animation;
-      if (val.indexOf(cssAnimationName) >= 0) {
-        cssAnimationCfg = val;
-      }
+  function addLine(x02, y02, x12, y12) {
+    if (!(aroundEqual(x02, x12) && aroundEqual(y02, y12))) {
+      currentSubpath.push(x02, y02, x12, y12, x12, y12);
     }
-  });
-  if (!cssAnimationCfg) {
-    return;
   }
-  attrs.d = false;
-  var animationName = addAnimation(composedAnim, scope);
-  return cssAnimationCfg.replace(cssAnimationName, animationName);
-}
-function getEasingFunc(easing) {
-  return isString(easing) ? EASING_MAP[easing] ? "cubic-bezier(" + EASING_MAP[easing] + ")" : createCubicEasingFunc(easing) ? easing : "" : "";
-}
-function createCSSAnimation(el, attrs, scope, onlyShape) {
-  var animators = el.animators;
-  var len = animators.length;
-  var cssAnimations = [];
-  if (el instanceof CompoundPath) {
-    var animationCfg = createCompoundPathCSSAnimation(el, attrs, scope);
-    if (animationCfg) {
-      cssAnimations.push(animationCfg);
-    } else if (!len) {
-      return;
-    }
-  } else if (!len) {
-    return;
+  function addArc(startAngle2, endAngle2, cx2, cy2, rx2, ry2) {
+    var delta = Math.abs(endAngle2 - startAngle2);
+    var len2 = Math.tan(delta / 4) * 4 / 3;
+    var dir = endAngle2 < startAngle2 ? -1 : 1;
+    var c1 = Math.cos(startAngle2);
+    var s1 = Math.sin(startAngle2);
+    var c2 = Math.cos(endAngle2);
+    var s2 = Math.sin(endAngle2);
+    var x12 = c1 * rx2 + cx2;
+    var y12 = s1 * ry2 + cy2;
+    var x4 = c2 * rx2 + cx2;
+    var y4 = s2 * ry2 + cy2;
+    var hx = rx2 * len2 * dir;
+    var hy = ry2 * len2 * dir;
+    currentSubpath.push(x12 - hx * s1, y12 + hy * c1, x4 + hx * s2, y4 - hy * c2, x4, y4);
   }
-  var groupAnimators = {};
-  for (var i = 0; i < len; i++) {
-    var animator = animators[i];
-    var cfgArr = [animator.getMaxTime() / 1e3 + "s"];
-    var easing = getEasingFunc(animator.getClip().easing);
-    var delay = animator.getDelay();
-    if (easing) {
-      cfgArr.push(easing);
-    } else {
-      cfgArr.push("linear");
-    }
-    if (delay) {
-      cfgArr.push(delay / 1e3 + "s");
-    }
-    if (animator.getLoop()) {
-      cfgArr.push("infinite");
-    }
-    var cfg = cfgArr.join(" ");
-    groupAnimators[cfg] = groupAnimators[cfg] || [cfg, []];
-    groupAnimators[cfg][1].push(animator);
-  }
-  function createSingleCSSAnimation(groupAnimator) {
-    var animators2 = groupAnimator[1];
-    var len2 = animators2.length;
-    var transformKfs = {};
-    var shapeKfs = {};
-    var finalKfs = {};
-    var animationTimingFunctionAttrName = "animation-timing-function";
-    function saveAnimatorTrackToCssKfs(animator3, cssKfs, toCssAttrName) {
-      var tracks = animator3.getTracks();
-      var maxTime = animator3.getMaxTime();
-      for (var k = 0; k < tracks.length; k++) {
-        var track = tracks[k];
-        if (track.needsAnimate()) {
-          var kfs = track.keyframes;
-          var attrName = track.propName;
-          toCssAttrName && (attrName = toCssAttrName(attrName));
-          if (attrName) {
-            for (var i3 = 0; i3 < kfs.length; i3++) {
-              var kf = kfs[i3];
-              var percent2 = Math.round(kf.time / maxTime * 100) + "%";
-              var kfEasing = getEasingFunc(kf.easing);
-              var rawValue = kf.rawValue;
-              if (isString(rawValue) || isNumber(rawValue)) {
-                cssKfs[percent2] = cssKfs[percent2] || {};
-                cssKfs[percent2][attrName] = kf.rawValue;
-                if (kfEasing) {
-                  cssKfs[percent2][animationTimingFunctionAttrName] = kfEasing;
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    for (var i2 = 0; i2 < len2; i2++) {
-      var animator2 = animators2[i2];
-      var targetProp = animator2.targetName;
-      if (!targetProp) {
-        !onlyShape && saveAnimatorTrackToCssKfs(animator2, transformKfs);
-      } else if (targetProp === "shape") {
-        saveAnimatorTrackToCssKfs(animator2, shapeKfs);
+  var x1;
+  var y1;
+  var x2;
+  var y2;
+  for (var i = 0; i < len; ) {
+    var cmd = data[i++];
+    var isFirst = i === 1;
+    if (isFirst) {
+      xi = data[i];
+      yi = data[i + 1];
+      x0 = xi;
+      y0 = yi;
+      if (cmd === CMD.L || cmd === CMD.C || cmd === CMD.Q) {
+        currentSubpath = [x0, y0];
       }
     }
-    for (var percent in transformKfs) {
-      var transform = {};
-      copyTransform(transform, el);
-      extend(transform, transformKfs[percent]);
-      var str = getSRTTransformString(transform);
-      var timingFunction = transformKfs[percent][animationTimingFunctionAttrName];
-      finalKfs[percent] = str ? {
-        transform: str
-      } : {};
-      setTransformOrigin(finalKfs[percent], transform);
-      if (timingFunction) {
-        finalKfs[percent][animationTimingFunctionAttrName] = timingFunction;
-      }
-    }
-    var path;
-    var canAnimateShape = true;
-    for (var percent in shapeKfs) {
-      finalKfs[percent] = finalKfs[percent] || {};
-      var isFirst = !path;
-      var timingFunction = shapeKfs[percent][animationTimingFunctionAttrName];
-      if (isFirst) {
-        path = new PathProxy();
-      }
-      var len_1 = path.len();
-      path.reset();
-      finalKfs[percent].d = buildPathString(el, shapeKfs[percent], path);
-      var newLen = path.len();
-      if (!isFirst && len_1 !== newLen) {
-        canAnimateShape = false;
+    switch (cmd) {
+      case CMD.M:
+        xi = x0 = data[i++];
+        yi = y0 = data[i++];
+        createNewSubpath(x0, y0);
         break;
-      }
-      if (timingFunction) {
-        finalKfs[percent][animationTimingFunctionAttrName] = timingFunction;
-      }
-    }
-    if (!canAnimateShape) {
-      for (var percent in finalKfs) {
-        delete finalKfs[percent].d;
-      }
-    }
-    if (!onlyShape) {
-      for (var i2 = 0; i2 < len2; i2++) {
-        var animator2 = animators2[i2];
-        var targetProp = animator2.targetName;
-        if (targetProp === "style") {
-          saveAnimatorTrackToCssKfs(animator2, finalKfs, function(propName) {
-            return ANIMATE_STYLE_MAP[propName];
-          });
-        }
-      }
-    }
-    var percents = keys(finalKfs);
-    var allTransformOriginSame = true;
-    var transformOrigin;
-    for (var i2 = 1; i2 < percents.length; i2++) {
-      var p0 = percents[i2 - 1];
-      var p1 = percents[i2];
-      if (finalKfs[p0][transformOriginKey] !== finalKfs[p1][transformOriginKey]) {
-        allTransformOriginSame = false;
+      case CMD.L:
+        x1 = data[i++];
+        y1 = data[i++];
+        addLine(xi, yi, x1, y1);
+        xi = x1;
+        yi = y1;
         break;
-      }
-      transformOrigin = finalKfs[p0][transformOriginKey];
-    }
-    if (allTransformOriginSame && transformOrigin) {
-      for (var percent in finalKfs) {
-        if (finalKfs[percent][transformOriginKey]) {
-          delete finalKfs[percent][transformOriginKey];
+      case CMD.C:
+        currentSubpath.push(data[i++], data[i++], data[i++], data[i++], xi = data[i++], yi = data[i++]);
+        break;
+      case CMD.Q:
+        x1 = data[i++];
+        y1 = data[i++];
+        x2 = data[i++];
+        y2 = data[i++];
+        currentSubpath.push(xi + 2 / 3 * (x1 - xi), yi + 2 / 3 * (y1 - yi), x2 + 2 / 3 * (x1 - x2), y2 + 2 / 3 * (y1 - y2), x2, y2);
+        xi = x2;
+        yi = y2;
+        break;
+      case CMD.A:
+        var cx = data[i++];
+        var cy = data[i++];
+        var rx = data[i++];
+        var ry = data[i++];
+        var startAngle = data[i++];
+        var endAngle = data[i++] + startAngle;
+        i += 1;
+        var anticlockwise = !data[i++];
+        x1 = Math.cos(startAngle) * rx + cx;
+        y1 = Math.sin(startAngle) * ry + cy;
+        if (isFirst) {
+          x0 = x1;
+          y0 = y1;
+          createNewSubpath(x0, y0);
+        } else {
+          addLine(xi, yi, x1, y1);
         }
-      }
-      attrs[transformOriginKey] = transformOrigin;
-    }
-    if (filter(percents, function(percent2) {
-      return keys(finalKfs[percent2]).length > 0;
-    }).length) {
-      var animationName = addAnimation(finalKfs, scope);
-      return animationName + " " + groupAnimator[0] + " both";
+        xi = Math.cos(endAngle) * rx + cx;
+        yi = Math.sin(endAngle) * ry + cy;
+        var step = (anticlockwise ? -1 : 1) * Math.PI / 2;
+        for (var angle = startAngle; anticlockwise ? angle > endAngle : angle < endAngle; angle += step) {
+          var nextAngle = anticlockwise ? Math.max(angle + step, endAngle) : Math.min(angle + step, endAngle);
+          addArc(angle, nextAngle, cx, cy, rx, ry);
+        }
+        break;
+      case CMD.R:
+        x0 = xi = data[i++];
+        y0 = yi = data[i++];
+        x1 = x0 + data[i++];
+        y1 = y0 + data[i++];
+        createNewSubpath(x1, y0);
+        addLine(x1, y0, x1, y1);
+        addLine(x1, y1, x0, y1);
+        addLine(x0, y1, x0, y0);
+        addLine(x0, y0, x1, y0);
+        break;
+      case CMD.Z:
+        currentSubpath && addLine(xi, yi, x0, y0);
+        xi = x0;
+        yi = y0;
+        break;
     }
   }
-  for (var key in groupAnimators) {
-    var animationCfg = createSingleCSSAnimation(groupAnimators[key]);
-    if (animationCfg) {
-      cssAnimations.push(animationCfg);
-    }
+  if (currentSubpath && currentSubpath.length > 2) {
+    bezierArrayGroups.push(currentSubpath);
+  }
+  return bezierArrayGroups;
+}
+function adpativeBezier(x0, y0, x1, y1, x2, y2, x3, y3, out, scale) {
+  if (aroundEqual(x0, x1) && aroundEqual(y0, y1) && aroundEqual(x2, x3) && aroundEqual(y2, y3)) {
+    out.push(x3, y3);
+    return;
+  }
+  var PIXEL_DISTANCE = 2 / scale;
+  var PIXEL_DISTANCE_SQR = PIXEL_DISTANCE * PIXEL_DISTANCE;
+  var dx = x3 - x0;
+  var dy = y3 - y0;
+  var d = Math.sqrt(dx * dx + dy * dy);
+  dx /= d;
+  dy /= d;
+  var dx1 = x1 - x0;
+  var dy1 = y1 - y0;
+  var dx2 = x2 - x3;
+  var dy2 = y2 - y3;
+  var cp1LenSqr = dx1 * dx1 + dy1 * dy1;
+  var cp2LenSqr = dx2 * dx2 + dy2 * dy2;
+  if (cp1LenSqr < PIXEL_DISTANCE_SQR && cp2LenSqr < PIXEL_DISTANCE_SQR) {
+    out.push(x3, y3);
+    return;
   }
-  if (cssAnimations.length) {
-    var className = scope.zrId + "-cls-" + getClassId();
-    scope.cssNodes["." + className] = {
-      animation: cssAnimations.join(",")
-    };
-    attrs["class"] = className;
+  var projLen1 = dx * dx1 + dy * dy1;
+  var projLen2 = -dx * dx2 - dy * dy2;
+  var d1Sqr = cp1LenSqr - projLen1 * projLen1;
+  var d2Sqr = cp2LenSqr - projLen2 * projLen2;
+  if (d1Sqr < PIXEL_DISTANCE_SQR && projLen1 >= 0 && d2Sqr < PIXEL_DISTANCE_SQR && projLen2 >= 0) {
+    out.push(x3, y3);
+    return;
+  }
+  var tmpSegX = [];
+  var tmpSegY = [];
+  cubicSubdivide(x0, x1, x2, x3, 0.5, tmpSegX);
+  cubicSubdivide(y0, y1, y2, y3, 0.5, tmpSegY);
+  adpativeBezier(tmpSegX[0], tmpSegY[0], tmpSegX[1], tmpSegY[1], tmpSegX[2], tmpSegY[2], tmpSegX[3], tmpSegY[3], out, scale);
+  adpativeBezier(tmpSegX[4], tmpSegY[4], tmpSegX[5], tmpSegY[5], tmpSegX[6], tmpSegY[6], tmpSegX[7], tmpSegY[7], out, scale);
+}
+function pathToPolygons(path, scale) {
+  var bezierArrayGroups = pathToBezierCurves(path);
+  var polygons = [];
+  scale = scale || 1;
+  for (var i = 0; i < bezierArrayGroups.length; i++) {
+    var beziers = bezierArrayGroups[i];
+    var polygon = [];
+    var x0 = beziers[0];
+    var y0 = beziers[1];
+    polygon.push(x0, y0);
+    for (var k = 2; k < beziers.length; ) {
+      var x1 = beziers[k++];
+      var y1 = beziers[k++];
+      var x2 = beziers[k++];
+      var y2 = beziers[k++];
+      var x3 = beziers[k++];
+      var y3 = beziers[k++];
+      adpativeBezier(x0, y0, x1, y1, x2, y2, x3, y3, polygon, scale);
+      x0 = x3;
+      y0 = y3;
+    }
+    polygons.push(polygon);
   }
+  return polygons;
 }
 export {
-  ANIMATE_STYLE_MAP,
-  EASING_MAP,
-  createCSSAnimation
+  pathToBezierCurves,
+  pathToPolygons
 };

package/dist/pc/sun-card-design-pc.es2191.js

@@ -1,54 +1,15 @@
-import { liftColor } from "./sun-card-design-pc.es1767.js";
-import { getClassId } from "./sun-card-design-pc.es2201.js";
-function createCSSEmphasis(el, attrs, scope) {
-  if (!el.ignore) {
-    if (el.isSilent()) {
-      var style = {
-        "pointer-events": "none"
-      };
-      setClassAttribute(style, attrs, scope);
-    } else {
-      var emphasisStyle = el.states.emphasis && el.states.emphasis.style ? el.states.emphasis.style : {};
-      var fill = emphasisStyle.fill;
-      if (!fill) {
-        var normalFill = el.style && el.style.fill;
-        var selectFill = el.states.select && el.states.select.style && el.states.select.style.fill;
-        var fromFill = el.currentStates.indexOf("select") >= 0 ? selectFill || normalFill : normalFill;
-        if (fromFill) {
-          fill = liftColor(fromFill);
-        }
-      }
-      var lineWidth = emphasisStyle.lineWidth;
-      if (lineWidth) {
-        var scaleX = !emphasisStyle.strokeNoScale && el.transform ? el.transform[0] : 1;
-        lineWidth = lineWidth / scaleX;
-      }
-      var style = {
-        cursor: "pointer"
-      };
-      if (fill) {
-        style.fill = fill;
-      }
-      if (emphasisStyle.stroke) {
-        style.stroke = emphasisStyle.stroke;
-      }
-      if (lineWidth) {
-        style["stroke-width"] = lineWidth;
-      }
-      setClassAttribute(style, attrs, scope);
-    }
+import { cubicProjectPoint } from "./sun-card-design-pc.es2159.js";
+function containStroke(x0, y0, x1, y1, x2, y2, x3, y3, lineWidth, x, y) {
+  if (lineWidth === 0) {
+    return false;
   }
-}
-function setClassAttribute(style, attrs, scope, withHover) {
-  var styleKey = JSON.stringify(style);
-  var className = scope.cssStyleCache[styleKey];
-  if (!className) {
-    className = scope.zrId + "-cls-" + getClassId();
-    scope.cssStyleCache[styleKey] = className;
-    scope.cssNodes["." + className + ":hover"] = style;
+  var _l = lineWidth;
+  if (y > y0 + _l && y > y1 + _l && y > y2 + _l && y > y3 + _l || y < y0 - _l && y < y1 - _l && y < y2 - _l && y < y3 - _l || x > x0 + _l && x > x1 + _l && x > x2 + _l && x > x3 + _l || x < x0 - _l && x < x1 - _l && x < x2 - _l && x < x3 - _l) {
+    return false;
   }
-  attrs["class"] = attrs["class"] ? attrs["class"] + " " + className : className;
+  var d = cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, null);
+  return d <= _l / 2;
 }
 export {
-  createCSSEmphasis
+  containStroke
 };

package/dist/pc/sun-card-design-pc.es2192.js

@@ -1,30 +1,36 @@
-function createTextNode(text) {
-  return document.createTextNode(text);
-}
-function insertBefore(parentNode2, newNode, referenceNode) {
-  parentNode2.insertBefore(newNode, referenceNode);
-}
-function removeChild(node, child) {
-  node.removeChild(child);
-}
-function appendChild(node, child) {
-  node.appendChild(child);
-}
-function parentNode(node) {
-  return node.parentNode;
-}
-function nextSibling(node) {
-  return node.nextSibling;
-}
-function setTextContent(node, text) {
-  node.textContent = text;
+import { normalizeRadian } from "./sun-card-design-pc.es1988.js";
+var PI2 = Math.PI * 2;
+function containStroke(cx, cy, r, startAngle, endAngle, anticlockwise, lineWidth, x, y) {
+  if (lineWidth === 0) {
+    return false;
+  }
+  var _l = lineWidth;
+  x -= cx;
+  y -= cy;
+  var d = Math.sqrt(x * x + y * y);
+  if (d - _l > r || d + _l < r) {
+    return false;
+  }
+  if (Math.abs(startAngle - endAngle) % PI2 < 1e-4) {
+    return true;
+  }
+  if (anticlockwise) {
+    var tmp = startAngle;
+    startAngle = normalizeRadian(endAngle);
+    endAngle = normalizeRadian(tmp);
+  } else {
+    startAngle = normalizeRadian(startAngle);
+    endAngle = normalizeRadian(endAngle);
+  }
+  if (startAngle > endAngle) {
+    endAngle += PI2;
+  }
+  var angle = Math.atan2(y, x);
+  if (angle < 0) {
+    angle += PI2;
+  }
+  return angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle;
 }
 export {
-  appendChild,
-  createTextNode,
-  insertBefore,
-  nextSibling,
-  parentNode,
-  removeChild,
-  setTextContent
+  containStroke
 };