sun-card-design 1.1.33 → 1.1.35

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

@@ -1,31 +1,316 @@
-import { map } from "./sun-card-design-pc.es932.js";
-import { GeoJSONRegion } from "./sun-card-design-pc.es2025.js";
-var geoCoord = [126, 25];
-var nanhaiName = "南海诸岛";
-var points = [[[0, 3.5], [7, 11.2], [15, 11.9], [30, 7], [42, 0.7], [52, 0.7], [56, 7.7], [59, 0.7], [64, 0.7], [64, 0], [5, 0], [0, 3.5]], [[13, 16.1], [19, 14.7], [16, 21.7], [11, 23.1], [13, 16.1]], [[12, 32.2], [14, 38.5], [15, 38.5], [13, 32.2], [12, 32.2]], [[16, 47.6], [12, 53.2], [13, 53.2], [18, 47.6], [16, 47.6]], [[6, 64.4], [8, 70], [9, 70], [8, 64.4], [6, 64.4]], [[23, 82.6], [29, 79.8], [30, 79.8], [25, 82.6], [23, 82.6]], [[37, 70.7], [43, 62.3], [44, 62.3], [39, 70.7], [37, 70.7]], [[48, 51.1], [51, 45.5], [53, 45.5], [50, 51.1], [48, 51.1]], [[51, 35], [51, 28.7], [53, 28.7], [53, 35], [51, 35]], [[52, 22.4], [55, 17.5], [56, 17.5], [53, 22.4], [52, 22.4]], [[58, 12.6], [62, 7], [63, 7], [60, 12.6], [58, 12.6]], [[0, 3.5], [0, 93.1], [64, 93.1], [64, 0], [63, 0], [63, 92.4], [1, 92.4], [1, 3.5], [0, 3.5]]];
-for (var i = 0; i < points.length; i++) {
-  for (var k = 0; k < points[i].length; k++) {
-    points[i][k][0] /= 10.5;
-    points[i][k][1] /= -10.5 / 0.75;
-    points[i][k][0] += geoCoord[0];
-    points[i][k][1] += geoCoord[1];
-  }
-}
-function fixNanhai(mapType, regions) {
-  if (mapType === "china") {
-    for (var i = 0; i < regions.length; i++) {
-      if (regions[i].name === nanhaiName) {
-        return;
+import { fromPoints } from "./sun-card-design-pc.es2040.js";
+import BoundingRect from "./sun-card-design-pc.es1970.js";
+import Point from "./sun-card-design-pc.es1989.js";
+import { map } from "./sun-card-design-pc.es931.js";
+import Polygon from "./sun-card-design-pc.es1980.js";
+import Rect from "./sun-card-design-pc.es1757.js";
+import Sector from "./sun-card-design-pc.es1978.js";
+import { pathToPolygons } from "./sun-card-design-pc.es2206.js";
+import { clonePath } from "./sun-card-design-pc.es1972.js";
+function getDividingGrids(dimSize, rowDim, count) {
+  var rowSize = dimSize[rowDim];
+  var columnSize = dimSize[1 - rowDim];
+  var ratio = Math.abs(rowSize / columnSize);
+  var rowCount = Math.ceil(Math.sqrt(ratio * count));
+  var columnCount = Math.floor(count / rowCount);
+  if (columnCount === 0) {
+    columnCount = 1;
+    rowCount = count;
+  }
+  var grids = [];
+  for (var i = 0; i < rowCount; i++) {
+    grids.push(columnCount);
+  }
+  var currentCount = rowCount * columnCount;
+  var remained = count - currentCount;
+  if (remained > 0) {
+    for (var i = 0; i < remained; i++) {
+      grids[i % rowCount] += 1;
+    }
+  }
+  return grids;
+}
+function divideSector(sectorShape, count, outShapes) {
+  var r0 = sectorShape.r0;
+  var r = sectorShape.r;
+  var startAngle = sectorShape.startAngle;
+  var endAngle = sectorShape.endAngle;
+  var angle = Math.abs(endAngle - startAngle);
+  var arcLen = angle * r;
+  var deltaR = r - r0;
+  var isAngleRow = arcLen > Math.abs(deltaR);
+  var grids = getDividingGrids([arcLen, deltaR], isAngleRow ? 0 : 1, count);
+  var rowSize = (isAngleRow ? angle : deltaR) / grids.length;
+  for (var row = 0; row < grids.length; row++) {
+    var columnSize = (isAngleRow ? deltaR : angle) / grids[row];
+    for (var column = 0; column < grids[row]; column++) {
+      var newShape = {};
+      if (isAngleRow) {
+        newShape.startAngle = startAngle + rowSize * row;
+        newShape.endAngle = startAngle + rowSize * (row + 1);
+        newShape.r0 = r0 + columnSize * column;
+        newShape.r = r0 + columnSize * (column + 1);
+      } else {
+        newShape.startAngle = startAngle + columnSize * column;
+        newShape.endAngle = startAngle + columnSize * (column + 1);
+        newShape.r0 = r0 + rowSize * row;
+        newShape.r = r0 + rowSize * (row + 1);
       }
+      newShape.clockwise = sectorShape.clockwise;
+      newShape.cx = sectorShape.cx;
+      newShape.cy = sectorShape.cy;
+      outShapes.push(newShape);
+    }
+  }
+}
+function divideRect(rectShape, count, outShapes) {
+  var width = rectShape.width;
+  var height = rectShape.height;
+  var isHorizontalRow = width > height;
+  var grids = getDividingGrids([width, height], isHorizontalRow ? 0 : 1, count);
+  var rowSizeDim = isHorizontalRow ? "width" : "height";
+  var columnSizeDim = isHorizontalRow ? "height" : "width";
+  var rowDim = isHorizontalRow ? "x" : "y";
+  var columnDim = isHorizontalRow ? "y" : "x";
+  var rowSize = rectShape[rowSizeDim] / grids.length;
+  for (var row = 0; row < grids.length; row++) {
+    var columnSize = rectShape[columnSizeDim] / grids[row];
+    for (var column = 0; column < grids[row]; column++) {
+      var newShape = {};
+      newShape[rowDim] = row * rowSize;
+      newShape[columnDim] = column * columnSize;
+      newShape[rowSizeDim] = rowSize;
+      newShape[columnSizeDim] = columnSize;
+      newShape.x += rectShape.x;
+      newShape.y += rectShape.y;
+      outShapes.push(newShape);
+    }
+  }
+}
+function crossProduct2d(x1, y1, x2, y2) {
+  return x1 * y2 - x2 * y1;
+}
+function lineLineIntersect(a1x, a1y, a2x, a2y, b1x, b1y, b2x, b2y) {
+  var mx = a2x - a1x;
+  var my = a2y - a1y;
+  var nx = b2x - b1x;
+  var ny = b2y - b1y;
+  var nmCrossProduct = crossProduct2d(nx, ny, mx, my);
+  if (Math.abs(nmCrossProduct) < 1e-6) {
+    return null;
+  }
+  var b1a1x = a1x - b1x;
+  var b1a1y = a1y - b1y;
+  var p = crossProduct2d(b1a1x, b1a1y, nx, ny) / nmCrossProduct;
+  if (p < 0 || p > 1) {
+    return null;
+  }
+  return new Point(p * mx + a1x, p * my + a1y);
+}
+function projPtOnLine(pt, lineA, lineB) {
+  var dir = new Point();
+  Point.sub(dir, lineB, lineA);
+  dir.normalize();
+  var dir2 = new Point();
+  Point.sub(dir2, pt, lineA);
+  var len = dir2.dot(dir);
+  return len;
+}
+function addToPoly(poly, pt) {
+  var last = poly[poly.length - 1];
+  if (last && last[0] === pt[0] && last[1] === pt[1]) {
+    return;
+  }
+  poly.push(pt);
+}
+function splitPolygonByLine(points, lineA, lineB) {
+  var len = points.length;
+  var intersections = [];
+  for (var i = 0; i < len; i++) {
+    var p0 = points[i];
+    var p1 = points[(i + 1) % len];
+    var intersectionPt = lineLineIntersect(p0[0], p0[1], p1[0], p1[1], lineA.x, lineA.y, lineB.x, lineB.y);
+    if (intersectionPt) {
+      intersections.push({
+        projPt: projPtOnLine(intersectionPt, lineA, lineB),
+        pt: intersectionPt,
+        idx: i
+      });
     }
-    regions.push(new GeoJSONRegion(nanhaiName, map(points, function(exterior) {
-      return {
-        type: "polygon",
-        exterior
-      };
-    }), geoCoord));
   }
+  if (intersections.length < 2) {
+    return [{ points }, { points }];
+  }
+  intersections.sort(function(a, b) {
+    return a.projPt - b.projPt;
+  });
+  var splitPt0 = intersections[0];
+  var splitPt1 = intersections[intersections.length - 1];
+  if (splitPt1.idx < splitPt0.idx) {
+    var tmp = splitPt0;
+    splitPt0 = splitPt1;
+    splitPt1 = tmp;
+  }
+  var splitPt0Arr = [splitPt0.pt.x, splitPt0.pt.y];
+  var splitPt1Arr = [splitPt1.pt.x, splitPt1.pt.y];
+  var newPolyA = [splitPt0Arr];
+  var newPolyB = [splitPt1Arr];
+  for (var i = splitPt0.idx + 1; i <= splitPt1.idx; i++) {
+    addToPoly(newPolyA, points[i].slice());
+  }
+  addToPoly(newPolyA, splitPt1Arr);
+  addToPoly(newPolyA, splitPt0Arr);
+  for (var i = splitPt1.idx + 1; i <= splitPt0.idx + len; i++) {
+    addToPoly(newPolyB, points[i % len].slice());
+  }
+  addToPoly(newPolyB, splitPt0Arr);
+  addToPoly(newPolyB, splitPt1Arr);
+  return [{
+    points: newPolyA
+  }, {
+    points: newPolyB
+  }];
+}
+function binaryDividePolygon(polygonShape) {
+  var points = polygonShape.points;
+  var min = [];
+  var max = [];
+  fromPoints(points, min, max);
+  var boundingRect = new BoundingRect(min[0], min[1], max[0] - min[0], max[1] - min[1]);
+  var width = boundingRect.width;
+  var height = boundingRect.height;
+  var x = boundingRect.x;
+  var y = boundingRect.y;
+  var pt0 = new Point();
+  var pt1 = new Point();
+  if (width > height) {
+    pt0.x = pt1.x = x + width / 2;
+    pt0.y = y;
+    pt1.y = y + height;
+  } else {
+    pt0.y = pt1.y = y + height / 2;
+    pt0.x = x;
+    pt1.x = x + width;
+  }
+  return splitPolygonByLine(points, pt0, pt1);
+}
+function binaryDivideRecursive(divider, shape, count, out) {
+  if (count === 1) {
+    out.push(shape);
+  } else {
+    var mid = Math.floor(count / 2);
+    var sub = divider(shape);
+    binaryDivideRecursive(divider, sub[0], mid, out);
+    binaryDivideRecursive(divider, sub[1], count - mid, out);
+  }
+  return out;
+}
+function clone(path, count) {
+  var paths = [];
+  for (var i = 0; i < count; i++) {
+    paths.push(clonePath(path));
+  }
+  return paths;
+}
+function copyPathProps(source, target) {
+  target.setStyle(source.style);
+  target.z = source.z;
+  target.z2 = source.z2;
+  target.zlevel = source.zlevel;
+}
+function polygonConvert(points) {
+  var out = [];
+  for (var i = 0; i < points.length; ) {
+    out.push([points[i++], points[i++]]);
+  }
+  return out;
+}
+function split(path, count) {
+  var outShapes = [];
+  var shape = path.shape;
+  var OutShapeCtor;
+  switch (path.type) {
+    case "rect":
+      divideRect(shape, count, outShapes);
+      OutShapeCtor = Rect;
+      break;
+    case "sector":
+      divideSector(shape, count, outShapes);
+      OutShapeCtor = Sector;
+      break;
+    case "circle":
+      divideSector({
+        r0: 0,
+        r: shape.r,
+        startAngle: 0,
+        endAngle: Math.PI * 2,
+        cx: shape.cx,
+        cy: shape.cy
+      }, count, outShapes);
+      OutShapeCtor = Sector;
+      break;
+    default:
+      var m = path.getComputedTransform();
+      var scale = m ? Math.sqrt(Math.max(m[0] * m[0] + m[1] * m[1], m[2] * m[2] + m[3] * m[3])) : 1;
+      var polygons = map(pathToPolygons(path.getUpdatedPathProxy(), scale), function(poly) {
+        return polygonConvert(poly);
+      });
+      var polygonCount = polygons.length;
+      if (polygonCount === 0) {
+        binaryDivideRecursive(binaryDividePolygon, {
+          points: polygons[0]
+        }, count, outShapes);
+      } else if (polygonCount === count) {
+        for (var i = 0; i < polygonCount; i++) {
+          outShapes.push({
+            points: polygons[i]
+          });
+        }
+      } else {
+        var totalArea_1 = 0;
+        var items = map(polygons, function(poly) {
+          var min = [];
+          var max = [];
+          fromPoints(poly, min, max);
+          var area = (max[1] - min[1]) * (max[0] - min[0]);
+          totalArea_1 += area;
+          return { poly, area };
+        });
+        items.sort(function(a, b) {
+          return b.area - a.area;
+        });
+        var left = count;
+        for (var i = 0; i < polygonCount; i++) {
+          var item = items[i];
+          if (left <= 0) {
+            break;
+          }
+          var selfCount = i === polygonCount - 1 ? left : Math.ceil(item.area / totalArea_1 * count);
+          if (selfCount < 0) {
+            continue;
+          }
+          binaryDivideRecursive(binaryDividePolygon, {
+            points: item.poly
+          }, selfCount, outShapes);
+          left -= selfCount;
+        }
+      }
+      OutShapeCtor = Polygon;
+      break;
+  }
+  if (!OutShapeCtor) {
+    return clone(path, count);
+  }
+  var out = [];
+  for (var i = 0; i < outShapes.length; i++) {
+    var subPath = new OutShapeCtor();
+    subPath.setShape(outShapes[i]);
+    copyPathProps(path, subPath);
+    out.push(subPath);
+  }
+  return out;
 }
 export {
-  fixNanhai as default
+  clone,
+  split
 };

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

@@ -1,23 +1,198 @@
-var coordsOffsetMap = {
-  "南海诸岛": [32, 80],
-  // 全国
-  "广东": [0, -10],
-  "香港": [10, 5],
-  "澳门": [-10, 10],
-  // '北京': [-10, 0],
-  "天津": [5, 5]
-};
-function fixTextCoords(mapType, region) {
-  if (mapType === "china") {
-    var coordFix = coordsOffsetMap[region.name];
-    if (coordFix) {
-      var cp = region.getCenter();
-      cp[0] += coordFix[0] / 10.5;
-      cp[1] += -coordFix[1] / (10.5 / 0.75);
-      region.setCenter(cp);
+import { cubicSubdivide } from "./sun-card-design-pc.es2168.js";
+import PathProxy from "./sun-card-design-pc.es2032.js";
+var CMD = PathProxy.CMD;
+function aroundEqual(a, b) {
+  return Math.abs(a - b) < 1e-5;
+}
+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];
+  }
+  function addLine(x02, y02, x12, y12) {
+    if (!(aroundEqual(x02, x12) && aroundEqual(y02, y12))) {
+      currentSubpath.push(x02, y02, x12, y12, x12, y12);
+    }
+  }
+  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 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];
+      }
+    }
+    switch (cmd) {
+      case CMD.M:
+        xi = x0 = data[i++];
+        yi = y0 = data[i++];
+        createNewSubpath(x0, y0);
+        break;
+      case CMD.L:
+        x1 = data[i++];
+        y1 = data[i++];
+        addLine(xi, yi, x1, y1);
+        xi = x1;
+        yi = y1;
+        break;
+      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);
+        }
+        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;
+    }
+  }
+  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;
+  }
+  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 {
-  fixTextCoords as default
+  pathToBezierCurves,
+  pathToPolygons
 };