@tscircuit/pcb-viewer 1.11.260 → 1.11.262

package/dist/index.js

@@ -7573,6 +7573,88 @@ var convertElementToPrimitives = (element, allElements) => {
             ccw_rotation: hole_ccw_rotation
           }
         ];
+      } else if (element.shape === "hole_with_polygon_pad") {
+        const {
+          x,
+          y,
+          pad_outline,
+          hole_shape,
+          hole_diameter,
+          hole_width,
+          hole_height,
+          layers
+        } = element;
+        const hole_offset_x = distance2.parse(
+          element.hole_offset_x ?? 0
+        );
+        const hole_offset_y = distance2.parse(
+          element.hole_offset_y ?? 0
+        );
+        const pcb_outline = pad_outline;
+        const padPrimitives = [];
+        if (pcb_outline && Array.isArray(pcb_outline)) {
+          const translatedPoints = normalizePolygonPoints(pcb_outline).map(
+            (p) => ({ x: p.x + x, y: p.y + y })
+          );
+          for (const layer of layers || ["top", "bottom"]) {
+            padPrimitives.push({
+              _pcb_drawing_object_id: `polygon_${globalPcbDrawingObjectCount++}`,
+              pcb_drawing_type: "polygon",
+              points: translatedPoints,
+              layer,
+              _element: element,
+              _parent_pcb_component,
+              _parent_source_component,
+              _source_port
+            });
+          }
+        }
+        const holeCenter = {
+          x: x + hole_offset_x,
+          y: y + hole_offset_y
+        };
+        const holePrimitives = [];
+        if (hole_shape === "circle") {
+          holePrimitives.push({
+            _pcb_drawing_object_id: `circle_${globalPcbDrawingObjectCount++}`,
+            pcb_drawing_type: "circle",
+            x: holeCenter.x,
+            y: holeCenter.y,
+            r: (hole_diameter ?? 0) / 2,
+            layer: "drill",
+            _element: element,
+            _parent_pcb_component,
+            _parent_source_component
+          });
+        } else if (hole_shape === "oval") {
+          holePrimitives.push({
+            _pcb_drawing_object_id: `oval_${globalPcbDrawingObjectCount++}`,
+            pcb_drawing_type: "oval",
+            x: holeCenter.x,
+            y: holeCenter.y,
+            rX: (hole_width ?? 0) / 2,
+            rY: (hole_height ?? 0) / 2,
+            layer: "drill",
+            _element: element,
+            _parent_pcb_component,
+            _parent_source_component
+          });
+        } else if (hole_shape === "pill" || hole_shape === "rotated_pill") {
+          holePrimitives.push({
+            _pcb_drawing_object_id: `pill_${globalPcbDrawingObjectCount++}`,
+            pcb_drawing_type: "pill",
+            x: holeCenter.x,
+            y: holeCenter.y,
+            w: hole_width ?? 0,
+            h: hole_height ?? 0,
+            layer: "drill",
+            _element: element,
+            _parent_pcb_component,
+            _parent_source_component,
+            ccw_rotation: element.ccw_rotation
+          });
+        }
+        return [...padPrimitives, ...holePrimitives];
       } else {
         return [];
       }
@@ -10150,6 +10232,133 @@ function useDiagonalLabel(params) {
   );
 }
 
+// src/lib/util/get-primitive-snap-points.ts
+var rotatePoint2 = (point, center, rotationDeg) => {
+  const radians = rotationDeg * Math.PI / 180;
+  const cos = Math.cos(radians);
+  const sin = Math.sin(radians);
+  const translatedX = point.x - center.x;
+  const translatedY = point.y - center.y;
+  const rotatedX = translatedX * cos - translatedY * sin;
+  const rotatedY = translatedX * sin + translatedY * cos;
+  return {
+    x: rotatedX + center.x,
+    y: rotatedY + center.y
+  };
+};
+var getNinePointAnchors = (center, halfWidth, halfHeight, rotationDeg) => {
+  const basePoints = {
+    top_left: { x: center.x - halfWidth, y: center.y - halfHeight },
+    top_center: { x: center.x, y: center.y - halfHeight },
+    top_right: { x: center.x + halfWidth, y: center.y - halfHeight },
+    center_left: { x: center.x - halfWidth, y: center.y },
+    center: { x: center.x, y: center.y },
+    center_right: { x: center.x + halfWidth, y: center.y },
+    bottom_left: { x: center.x - halfWidth, y: center.y + halfHeight },
+    bottom_center: { x: center.x, y: center.y + halfHeight },
+    bottom_right: { x: center.x + halfWidth, y: center.y + halfHeight }
+  };
+  if (rotationDeg === 0) {
+    return Object.entries(basePoints).map(([anchor, point]) => ({
+      anchor,
+      point
+    }));
+  }
+  return Object.entries(basePoints).map(([anchor, point]) => ({
+    anchor,
+    point: rotatePoint2(point, center, rotationDeg)
+  }));
+};
+var getPrimitiveSnapPoints = (primitive) => {
+  switch (primitive.pcb_drawing_type) {
+    case "rect": {
+      const rotation = primitive.ccw_rotation ?? 0;
+      return getNinePointAnchors(
+        { x: primitive.x, y: primitive.y },
+        primitive.w / 2,
+        primitive.h / 2,
+        rotation
+      );
+    }
+    case "pill": {
+      const rotation = primitive.ccw_rotation ?? 0;
+      return getNinePointAnchors(
+        { x: primitive.x, y: primitive.y },
+        primitive.w / 2,
+        primitive.h / 2,
+        rotation
+      );
+    }
+    case "circle": {
+      return [
+        { anchor: "circle_center", point: { x: primitive.x, y: primitive.y } },
+        {
+          anchor: "circle_right",
+          point: { x: primitive.x + primitive.r, y: primitive.y }
+        },
+        {
+          anchor: "circle_left",
+          point: { x: primitive.x - primitive.r, y: primitive.y }
+        },
+        {
+          anchor: "circle_top",
+          point: { x: primitive.x, y: primitive.y - primitive.r }
+        },
+        {
+          anchor: "circle_bottom",
+          point: { x: primitive.x, y: primitive.y + primitive.r }
+        }
+      ];
+    }
+    case "oval": {
+      return [
+        { anchor: "oval_center", point: { x: primitive.x, y: primitive.y } },
+        {
+          anchor: "oval_right",
+          point: { x: primitive.x + primitive.rX, y: primitive.y }
+        },
+        {
+          anchor: "oval_left",
+          point: { x: primitive.x - primitive.rX, y: primitive.y }
+        },
+        {
+          anchor: "oval_top",
+          point: { x: primitive.x, y: primitive.y - primitive.rY }
+        },
+        {
+          anchor: "oval_bottom",
+          point: { x: primitive.x, y: primitive.y + primitive.rY }
+        }
+      ];
+    }
+    case "line": {
+      const midPoint = {
+        x: (primitive.x1 + primitive.x2) / 2,
+        y: (primitive.y1 + primitive.y2) / 2
+      };
+      return [
+        { anchor: "line_start", point: { x: primitive.x1, y: primitive.y1 } },
+        { anchor: "line_mid", point: midPoint },
+        { anchor: "line_end", point: { x: primitive.x2, y: primitive.y2 } }
+      ];
+    }
+    case "polygon": {
+      return primitive.points.map((point, index) => ({
+        anchor: `polygon_vertex_${index}`,
+        point
+      }));
+    }
+    case "polygon_with_arcs": {
+      return primitive.brep_shape.outer_ring.vertices.map((vertex, index) => ({
+        anchor: `polygon_with_arcs_vertex_${index}`,
+        point: { x: vertex.x, y: vertex.y }
+      }));
+    }
+    default:
+      return [];
+  }
+};
+
 // src/components/DimensionOverlay.tsx
 import { Fragment, jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
 var SNAP_THRESHOLD_PX = 16;
@@ -10201,6 +10410,9 @@ var DimensionOverlay = ({
     for (const primitive of primitives) {
       if (!primitive._element) continue;
       if (shouldExcludePrimitiveFromSnapping(primitive)) continue;
+      if (primitive.pcb_drawing_type === "pill") continue;
+      if (primitive.pcb_drawing_type === "rect" && primitive.ccw_rotation && primitive.ccw_rotation !== 0)
+        continue;
       const bbox = getPrimitiveBoundingBox(primitive);
       if (!bbox) continue;
       const existing = boundingBoxes.get(primitive._element);
@@ -10211,6 +10423,23 @@ var DimensionOverlay = ({
     }
     return boundingBoxes;
   }, [primitives]);
+  const primitiveSnappingPoints = useMemo4(() => {
+    const snapPoints = [];
+    for (const primitive of primitives) {
+      if (!primitive._element) continue;
+      if (shouldExcludePrimitiveFromSnapping(primitive)) continue;
+      const primitivePoints = getPrimitiveSnapPoints(primitive);
+      if (primitivePoints.length === 0) continue;
+      for (const snap of primitivePoints) {
+        snapPoints.push({
+          anchor: snap.anchor,
+          point: snap.point,
+          element: primitive._element
+        });
+      }
+    }
+    return snapPoints;
+  }, [primitives]);
   const snappingPoints = useMemo4(() => {
     const points = [];
     elementBoundingBoxes.forEach((bounds, element) => {
@@ -10236,13 +10465,16 @@ var DimensionOverlay = ({
         });
       }
     });
+    for (const snap of primitiveSnappingPoints) {
+      points.push(snap);
+    }
     points.push({
       anchor: "origin",
       point: { x: 0, y: 0 },
       element: null
     });
     return points;
-  }, [elementBoundingBoxes]);
+  }, [elementBoundingBoxes, primitiveSnappingPoints]);
   const snappingPointsWithScreen = useMemo4(() => {
     return snappingPoints.map((snap, index) => ({
       ...snap,
@@ -12587,7 +12819,7 @@ import { css as css3 } from "@emotion/css";
 // package.json
 var package_default = {
   name: "@tscircuit/pcb-viewer",
-  version: "1.11.259",
+  version: "1.11.261",
   main: "dist/index.js",
   type: "module",
   repository: "tscircuit/pcb-viewer",
@@ -12640,7 +12872,7 @@ var package_default = {
     "@tscircuit/alphabet": "^0.0.3",
     "@vitejs/plugin-react": "^5.0.2",
     "circuit-json": "^0.0.307",
-    "circuit-to-svg": "^0.0.265",
+    "circuit-to-svg": "^0.0.271",
     color: "^4.2.3",
     "react-supergrid": "^1.0.10",
     "react-toastify": "^10.0.5",