@tscircuit/pcb-viewer 1.7.0 → 1.8.0

package/dist/index.js

@@ -9818,6 +9818,7 @@ var require_dist = __commonJS({
             schematic_component_id: import_zod23.z.string(),
             pin_spacing: length.optional(),
             box_width: length.optional(),
+            symbol_name: import_zod23.z.string().optional(),
             port_arrangement: import_zod23.z.union([
                 import_zod23.z.object({
                     left_size: import_zod23.z.number(),
@@ -10094,6 +10095,11 @@ var require_dist = __commonJS({
             source_trace_id: import_zod39.z.string().optional(),
             pcb_component_id: import_zod39.z.string().optional(),
             pcb_trace_id: import_zod39.z.string(),
+            route_thickness_mode: import_zod39.z.enum([
+                "constant",
+                "interpolated"
+            ]).default("interpolated"),
+            should_round_corners: import_zod39.z.boolean().optional(),
             route: import_zod39.z.array(import_zod39.z.union([
                 import_zod39.z.object({
                     route_type: import_zod39.z.literal("wire"),
@@ -10147,9 +10153,11 @@ var require_dist = __commonJS({
         var import_zod43 = require_lib2();
         var pcb_board = import_zod43.z.object({
             type: import_zod43.z.literal("pcb_board"),
+            pcb_board_id: import_zod43.z.string().default("pcb_board_0"),
             width: length,
             height: length,
-            center: point
+            center: point,
+            outline: import_zod43.z.array(point).optional()
         }).describe("Defines the board outline of the PCB");
         var import_zod44 = require_lib2();
         var pcb_placement_error = import_zod44.z.object({
@@ -11786,6 +11794,12 @@ var drawPill = function(drawer, pill) {
     });
     drawer.pill(pill.x, pill.y, pill.w, pill.h);
 };
+var drawPolygon = function(drawer, polygon) {
+    drawer.equip({
+        color: polygon.layer
+    });
+    drawer.polygon(polygon.points);
+};
 var drawPrimitive = function(drawer, primitive) {
     switch(primitive.pcb_drawing_type){
         case "line":
@@ -11800,6 +11814,8 @@ var drawPrimitive = function(drawer, primitive) {
             return drawOval(drawer, primitive);
         case "pill":
             return drawPill(drawer, primitive);
+        case "polygon":
+            return drawPolygon(drawer, primitive);
     }
 };
 var drawPrimitives = function(drawer, primitives) {
@@ -12225,6 +12241,34 @@ var Drawer = /*#__PURE__*/ function() {
                 ctx.closePath();
             }
         },
+        {
+            key: "polygon",
+            value: function polygon(points) {
+                var _this = this;
+                if (points.length < 3) {
+                    console.warn("Polygon must have at least 3 points");
+                    return;
+                }
+                this.applyAperture();
+                var ctx = this.getLayerCtx();
+                var transformedPoints = points.map(function(point) {
+                    return (0, import_transformation_matrix.applyToPoint)(_this.transform, [
+                        point.x,
+                        point.y
+                    ]);
+                });
+                ctx.beginPath();
+                ctx.moveTo(transformedPoints[0][0], transformedPoints[0][1]);
+                for(var i = 1; i < transformedPoints.length; i++){
+                    ctx.lineTo(transformedPoints[i][0], transformedPoints[i][1]);
+                }
+                ctx.closePath();
+                ctx.fill();
+                var lineWidth = scaleOnly(this.transform, this.aperture.size);
+                ctx.lineWidth = lineWidth;
+                ctx.stroke();
+            }
+        },
         {
             /* NOTE: This is not gerber compatible */ key: "debugText",
             value: function debugText(text, x, y) {
@@ -12488,6 +12532,85 @@ var CanvasPrimitiveRenderer = function(param) {
 var import_react14 = require("react");
 // src/lib/convert-element-to-primitive.ts
 var import_soup_util = __toESM(require_dist2());
+// src/lib/util/expand-stroke.ts
+function getExpandedStroke(strokeInput, defaultWidth) {
+    if (strokeInput.length < 2) {
+        throw new Error("Stroke must have at least two points");
+    }
+    var stroke = strokeInput.map(function(point) {
+        if (Array.isArray(point)) {
+            return {
+                x: point[0],
+                y: point[1]
+            };
+        }
+        return point;
+    });
+    var leftSide = [];
+    var rightSide = [];
+    function getNormal(p1, p2) {
+        var dx = p2.x - p1.x;
+        var dy = p2.y - p1.y;
+        var length = Math.sqrt(dx * dx + dy * dy);
+        return {
+            x: -dy / length,
+            y: dx / length
+        };
+    }
+    function addPoint(point, normal, factor, width) {
+        var halfWidth = width / 2;
+        var newPoint = {
+            x: point.x + normal.x * halfWidth * factor,
+            y: point.y + normal.y * halfWidth * factor
+        };
+        if (factor > 0) {
+            leftSide.push(newPoint);
+        } else {
+            rightSide.unshift(newPoint);
+        }
+    }
+    var firstNormal = getNormal(stroke[0], stroke[1]);
+    var _stroke__trace_width;
+    var firstWidth = (_stroke__trace_width = stroke[0].trace_width) !== null && _stroke__trace_width !== void 0 ? _stroke__trace_width : defaultWidth;
+    addPoint(stroke[0], firstNormal, 1, firstWidth);
+    addPoint(stroke[0], firstNormal, -1, firstWidth);
+    for(var i = 1; i < stroke.length - 1; i++){
+        var prev = stroke[i - 1];
+        var current = stroke[i];
+        var next = stroke[i + 1];
+        var normalPrev = getNormal(prev, current);
+        var normalNext = getNormal(current, next);
+        var miterX = normalPrev.x + normalNext.x;
+        var miterY = normalPrev.y + normalNext.y;
+        var miterLength = Math.sqrt(miterX * miterX + miterY * miterY);
+        var _current_trace_width;
+        var currentWidth = (_current_trace_width = current.trace_width) !== null && _current_trace_width !== void 0 ? _current_trace_width : defaultWidth;
+        var miterLimit = 2;
+        if (miterLength / 2 > miterLimit * (currentWidth / 2)) {
+            addPoint(current, normalPrev, 1, currentWidth);
+            addPoint(current, normalNext, 1, currentWidth);
+            addPoint(current, normalPrev, -1, currentWidth);
+            addPoint(current, normalNext, -1, currentWidth);
+        } else {
+            var scale2 = 1 / miterLength;
+            addPoint(current, {
+                x: miterX * scale2,
+                y: miterY * scale2
+            }, 1, currentWidth);
+            addPoint(current, {
+                x: miterX * scale2,
+                y: miterY * scale2
+            }, -1, currentWidth);
+        }
+    }
+    var lastNormal = getNormal(stroke[stroke.length - 2], stroke[stroke.length - 1]);
+    var _stroke__trace_width1;
+    var lastWidth = (_stroke__trace_width1 = stroke[stroke.length - 1].trace_width) !== null && _stroke__trace_width1 !== void 0 ? _stroke__trace_width1 : defaultWidth;
+    addPoint(stroke[stroke.length - 1], lastNormal, 1, lastWidth);
+    addPoint(stroke[stroke.length - 1], lastNormal, -1, lastWidth);
+    return _to_consumable_array(leftSide).concat(_to_consumable_array(rightSide));
+}
+// src/lib/convert-element-to-primitive.ts
 var convertElementToPrimitives = function(element, allElements) {
     var _pcb_port_get;
     var _parent_pcb_component = "pcb_component_id" in element ? allElements.find(function(elm) {
@@ -12693,42 +12816,70 @@ var convertElementToPrimitives = function(element, allElements) {
         case "pcb_trace":
             {
                 var primitives = [];
-                var prevX = null;
-                var prevY = null;
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    for(var _iterator = element.route[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                        var route = _step.value;
-                        if (route.route_type === "wire") {
-                            if (prevX !== null && prevY !== null) {
-                                primitives.push({
-                                    pcb_drawing_type: "line",
-                                    x1: prevX,
-                                    y1: prevY,
-                                    x2: route.x,
-                                    y2: route.y,
-                                    width: route.width,
-                                    squareCap: false,
-                                    layer: route.layer
-                                });
-                            }
-                            prevX = route.x;
-                            prevY = route.y;
-                        }
-                    }
-                } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                } finally{
+                if (element.route_thickness_mode === "constant") {
+                    var prevX = null;
+                    var prevY = null;
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                     try {
-                        if (!_iteratorNormalCompletion && _iterator.return != null) {
-                            _iterator.return();
+                        for(var _iterator = element.route[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var route = _step.value;
+                            if (route.route_type === "wire") {
+                                if (prevX !== null && prevY !== null) {
+                                    primitives.push({
+                                        pcb_drawing_type: "line",
+                                        x1: prevX,
+                                        y1: prevY,
+                                        x2: route.x,
+                                        y2: route.y,
+                                        width: route.width,
+                                        squareCap: false,
+                                        layer: route.layer
+                                    });
+                                }
+                                prevX = route.x;
+                                prevY = route.y;
+                            }
                         }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
                     } finally{
-                        if (_didIteratorError) {
-                            throw _iteratorError;
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
                         }
                     }
+                } else if (element.route_thickness_mode === "interpolated") {
+                    var strokeInput = element.route.map(function(r) {
+                        return {
+                            x: r.x,
+                            y: r.y,
+                            trace_width: r.route_type === "wire" ? r.width : 0.5
+                        };
+                    });
+                    var expandedStroke = getExpandedStroke(strokeInput, 0.5);
+                    primitives.push({
+                        pcb_drawing_type: "polygon",
+                        points: expandedStroke,
+                        layer: element.route[0].layer
+                    });
+                    element.route.forEach(function(r) {
+                        if (r.route_type === "via") {
+                            primitives.push({
+                                pcb_drawing_type: "circle",
+                                x: r.x,
+                                y: r.y,
+                                radius: r.outer_diameter / 2,
+                                fill: true,
+                                layer: element.route.layer
+                            });
+                        }
+                    });
                 }
                 return primitives;
             }
@@ -13390,7 +13541,7 @@ var import_soup2 = __toESM(require_dist());
 // package.json
 var package_default = {
     name: "@tscircuit/pcb-viewer",
-    version: "1.6.0",
+    version: "1.7.0",
     main: "dist/index.js",
     repository: "tscircuit/pcb-viewer",
     license: "MIT",
@@ -13417,7 +13568,7 @@ var package_default = {
         "@tscircuit/eagle-xml-converter": "^0.0.6",
         "@tscircuit/props": "^0.0.31",
         "@tscircuit/react-fiber": "^1.1.25",
-        "@tscircuit/soup": "^0.0.50",
+        "@tscircuit/soup": "^0.0.56",
         "@tscircuit/soup-util": "^0.0.13",
         "@types/node": "18.7.23",
         "@types/react": "^18.3.3",
@@ -14258,57 +14409,40 @@ var EditTraceHintOverlay = function(param) {
                     var route = e.route;
                     var pcb_port = (0, import_soup_util2.su)(soup).pcb_port.get(e.pcb_port_id);
                     var pcb_port_screen = (0, import_transformation_matrix6.applyToPoint)(transform, pcb_port);
-                    var strokeInput = [
-                        {
-                            x: pcb_port_screen.x,
-                            y: pcb_port_screen.y,
-                            trace_width: 0.5
-                        }
-                    ].concat(// Start with a small width
-                    _to_consumable_array(route.map(function(r) {
-                        if (r === void 0) {
-                            throw new Error("route contains undefined point");
-                        }
-                        return {
-                            x: (0, import_transformation_matrix6.applyToPoint)(transform, r).x,
-                            y: (0, import_transformation_matrix6.applyToPoint)(transform, r).y,
-                            trace_width: r.trace_width
-                        };
-                    })));
-                    var expandedStroke = getExpandedStroke(strokeInput, 0.5);
-                    var expandedPath = expandedStroke.map(function(point, index) {
-                        return "".concat(index === 0 ? "M" : "L", " ").concat(point.x, ",").concat(point.y);
-                    }).join(" ") + " Z";
-                    var originalPath = strokeInput.map(function(point, index) {
-                        return "".concat(index === 0 ? "M" : "L", " ").concat(point.x, ",").concat(point.y);
-                    }).join(" ");
-                    return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("g", {
+                    return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_react13.Fragment, {
                         children: [
-                            /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("path", {
-                                d: expandedPath,
-                                fill: "red"
-                            }, "expanded-path-".concat(e.pcb_port_id)),
-                            /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("path", {
-                                d: originalPath,
-                                style: {
-                                    mixBlendMode: "difference"
-                                },
+                            /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("rect", {
+                                x: pcb_port_screen.x - 10,
+                                y: pcb_port_screen.y - 10,
+                                width: 20,
+                                height: 20,
                                 stroke: "red"
-                            }, "original-path-".concat(e.pcb_port_id)),
-                            strokeInput.map(function(r, i) {
-                                return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)("g", {
+                            }, "rect-".concat(e.pcb_port_id)),
+                            /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("path", {
+                                stroke: "red",
+                                d: "M ".concat(pcb_port_screen.x, " ").concat(pcb_port_screen.y, " ").concat(route.map(function(r) {
+                                    return (0, import_transformation_matrix6.applyToPoint)(transform, r);
+                                }).map(function(r) {
+                                    return "L ".concat(r.x, " ").concat(r.y);
+                                }).join(" "))
+                            }, "path-".concat(e.pcb_port_id)),
+                            route.map(function(r) {
+                                return _object_spread({}, r, (0, import_transformation_matrix6.applyToPoint)(transform, r));
+                            }).map(function(r, i) {
+                                return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_react13.Fragment, {
                                     children: [
                                         /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("circle", {
                                             cx: r.x,
                                             cy: r.y,
-                                            r: r.trace_width ? r.trace_width / 2 : 8,
+                                            r: 8,
                                             stroke: "red"
                                         }),
                                         r.via && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("circle", {
                                             cx: r.x,
                                             cy: r.y,
-                                            r: r.trace_width ? r.trace_width / 2 : 8,
-                                            stroke: "red"
+                                            r: 16,
+                                            stroke: "red",
+                                            fill: "transparent"
                                         })
                                     ]
                                 }, i);
@@ -14338,83 +14472,6 @@ var EditTraceHintOverlay = function(param) {
         ]
     });
 };
-function getExpandedStroke(strokeInput, defaultWidth) {
-    if (strokeInput.length < 2) {
-        throw new Error("Stroke must have at least two points");
-    }
-    var stroke = strokeInput.map(function(point) {
-        if (Array.isArray(point)) {
-            return {
-                x: point[0],
-                y: point[1]
-            };
-        }
-        return point;
-    });
-    var leftSide = [];
-    var rightSide = [];
-    function getNormal(p1, p2) {
-        var dx = p2.x - p1.x;
-        var dy = p2.y - p1.y;
-        var length = Math.sqrt(dx * dx + dy * dy);
-        return {
-            x: -dy / length,
-            y: dx / length
-        };
-    }
-    function addPoint(point, normal, factor, width) {
-        var halfWidth = width / 2;
-        var newPoint = {
-            x: point.x + normal.x * halfWidth * factor,
-            y: point.y + normal.y * halfWidth * factor
-        };
-        if (factor > 0) {
-            leftSide.push(newPoint);
-        } else {
-            rightSide.unshift(newPoint);
-        }
-    }
-    var firstNormal = getNormal(stroke[0], stroke[1]);
-    var _stroke__trace_width;
-    var firstWidth = (_stroke__trace_width = stroke[0].trace_width) !== null && _stroke__trace_width !== void 0 ? _stroke__trace_width : defaultWidth;
-    addPoint(stroke[0], firstNormal, 1, firstWidth);
-    addPoint(stroke[0], firstNormal, -1, firstWidth);
-    for(var i = 1; i < stroke.length - 1; i++){
-        var prev = stroke[i - 1];
-        var current = stroke[i];
-        var next = stroke[i + 1];
-        var normalPrev = getNormal(prev, current);
-        var normalNext = getNormal(current, next);
-        var miterX = normalPrev.x + normalNext.x;
-        var miterY = normalPrev.y + normalNext.y;
-        var miterLength = Math.sqrt(miterX * miterX + miterY * miterY);
-        var _current_trace_width;
-        var currentWidth = (_current_trace_width = current.trace_width) !== null && _current_trace_width !== void 0 ? _current_trace_width : defaultWidth;
-        var miterLimit = 2;
-        if (miterLength / 2 > miterLimit * (currentWidth / 2)) {
-            addPoint(current, normalPrev, 1, currentWidth);
-            addPoint(current, normalNext, 1, currentWidth);
-            addPoint(current, normalPrev, -1, currentWidth);
-            addPoint(current, normalNext, -1, currentWidth);
-        } else {
-            var scale2 = 1 / miterLength;
-            addPoint(current, {
-                x: miterX * scale2,
-                y: miterY * scale2
-            }, 1, currentWidth);
-            addPoint(current, {
-                x: miterX * scale2,
-                y: miterY * scale2
-            }, -1, currentWidth);
-        }
-    }
-    var lastNormal = getNormal(stroke[stroke.length - 2], stroke[stroke.length - 1]);
-    var _stroke__trace_width1;
-    var lastWidth = (_stroke__trace_width1 = stroke[stroke.length - 1].trace_width) !== null && _stroke__trace_width1 !== void 0 ? _stroke__trace_width1 : defaultWidth;
-    addPoint(stroke[stroke.length - 1], lastNormal, 1, lastWidth);
-    addPoint(stroke[stroke.length - 1], lastNormal, -1, lastWidth);
-    return _to_consumable_array(leftSide).concat(_to_consumable_array(rightSide));
-}
 // src/components/RatsNestOverlay.tsx
 var import_transformation_matrix7 = require("transformation-matrix");
 var import_soup_util3 = __toESM(require_dist2());