@tscircuit/core 0.0.976 → 0.0.977

package/dist/index.js

@@ -2355,10 +2355,10 @@ var SmtPad = class extends PrimitiveComponent2 {
           pcb_group_id: this.getGroup()?.pcb_group_id ?? void 0
         });
     } else if (props.shape === "polygon") {
-      const transformedPoints = props.points.map((point2) => {
+      const transformedPoints = props.points.map((point4) => {
         const transformed = applyToPoint2(globalTransform, {
-          x: distance.parse(point2.x),
-          y: distance.parse(point2.y)
+          x: distance.parse(point4.x),
+          y: distance.parse(point4.y)
         });
         return {
           x: transformed.x,
@@ -2590,18 +2590,18 @@ var SilkscreenPath = class extends PrimitiveComponent2 {
     if (!currentPath) return;
     let currentCenterX = 0;
     let currentCenterY = 0;
-    for (const point2 of currentPath.route) {
-      currentCenterX += point2.x;
-      currentCenterY += point2.y;
+    for (const point4 of currentPath.route) {
+      currentCenterX += point4.x;
+      currentCenterY += point4.y;
     }
     currentCenterX /= currentPath.route.length;
     currentCenterY /= currentPath.route.length;
     const offsetX = newCenter.x - currentCenterX;
     const offsetY = newCenter.y - currentCenterY;
-    const newRoute = currentPath.route.map((point2) => ({
-      ...point2,
-      x: point2.x + offsetX,
-      y: point2.y + offsetY
+    const newRoute = currentPath.route.map((point4) => ({
+      ...point4,
+      x: point4.x + offsetX,
+      y: point4.y + offsetY
     }));
     db.pcb_silkscreen_path.update(this.pcb_silkscreen_path_id, {
       route: newRoute
@@ -2631,11 +2631,11 @@ var SilkscreenPath = class extends PrimitiveComponent2 {
       return { width: 0, height: 0 };
     }
     let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-    for (const point2 of props.route) {
-      minX = Math.min(minX, point2.x);
-      maxX = Math.max(maxX, point2.x);
-      minY = Math.min(minY, point2.y);
-      maxY = Math.max(maxY, point2.y);
+    for (const point4 of props.route) {
+      minX = Math.min(minX, point4.x);
+      maxX = Math.max(maxX, point4.x);
+      minY = Math.min(minY, point4.y);
+      maxY = Math.max(maxY, point4.y);
     }
     return {
       width: maxX - minX,
@@ -2671,14 +2671,14 @@ var PcbTrace = class extends PrimitiveComponent2 {
     const subcircuit = this.getSubcircuit();
     const { maybeFlipLayer } = this._getPcbPrimitiveFlippedHelpers();
     const parentTransform = this._computePcbGlobalTransformBeforeLayout();
-    const transformedRoute = props.route.map((point2) => {
-      const { x, y, ...restOfPoint } = point2;
+    const transformedRoute = props.route.map((point4) => {
+      const { x, y, ...restOfPoint } = point4;
       const transformedPoint = applyToPoint4(parentTransform, { x, y });
-      if (point2.route_type === "wire" && point2.layer) {
+      if (point4.route_type === "wire" && point4.layer) {
         return {
           ...transformedPoint,
           ...restOfPoint,
-          layer: maybeFlipLayer(point2.layer)
+          layer: maybeFlipLayer(point4.layer)
         };
       }
       return { ...transformedPoint, ...restOfPoint };
@@ -2698,16 +2698,16 @@ var PcbTrace = class extends PrimitiveComponent2 {
       return { width: 0, height: 0 };
     }
     let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-    for (const point2 of props.route) {
-      minX = Math.min(minX, point2.x);
-      maxX = Math.max(maxX, point2.x);
-      minY = Math.min(minY, point2.y);
-      maxY = Math.max(maxY, point2.y);
-      if (point2.route_type === "wire") {
-        minX = Math.min(minX, point2.x - point2.width / 2);
-        maxX = Math.max(maxX, point2.x + point2.width / 2);
-        minY = Math.min(minY, point2.y - point2.width / 2);
-        maxY = Math.max(maxY, point2.y + point2.width / 2);
+    for (const point4 of props.route) {
+      minX = Math.min(minX, point4.x);
+      maxX = Math.max(maxX, point4.x);
+      minY = Math.min(minY, point4.y);
+      maxY = Math.max(maxY, point4.y);
+      if (point4.route_type === "wire") {
+        minX = Math.min(minX, point4.x - point4.width / 2);
+        maxX = Math.max(maxX, point4.x + point4.width / 2);
+        minY = Math.min(minY, point4.y - point4.width / 2);
+        maxY = Math.max(maxY, point4.y + point4.width / 2);
       }
     }
     if (minX === Infinity || maxX === -Infinity || minY === Infinity || maxY === -Infinity) {
@@ -2974,9 +2974,9 @@ var PlatedHole = class extends PrimitiveComponent2 {
       });
       this.pcb_plated_hole_id = pcb_plated_hole.pcb_plated_hole_id;
     } else if (props.shape === "hole_with_polygon_pad") {
-      const padOutline = (props.padOutline || []).map((point2) => {
-        const x = typeof point2.x === "number" ? point2.x : parseFloat(String(point2.x));
-        const y = typeof point2.y === "number" ? point2.y : parseFloat(String(point2.y));
+      const padOutline = (props.padOutline || []).map((point4) => {
+        const x = typeof point4.x === "number" ? point4.x : parseFloat(String(point4.x));
+        const y = typeof point4.y === "number" ? point4.y : parseFloat(String(point4.y));
         return {
           x,
           y
@@ -3395,11 +3395,11 @@ var Cutout = class extends PrimitiveComponent2 {
     if (props.shape === "polygon") {
       if (props.points.length === 0) return { width: 0, height: 0 };
       let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-      for (const point2 of props.points) {
-        minX = Math.min(minX, point2.x);
-        maxX = Math.max(maxX, point2.x);
-        minY = Math.min(minY, point2.y);
-        maxY = Math.max(maxY, point2.y);
+      for (const point4 of props.points) {
+        minX = Math.min(minX, point4.x);
+        maxX = Math.max(maxX, point4.x);
+        minY = Math.min(minY, point4.y);
+        maxY = Math.max(maxY, point4.y);
       }
       return { width: maxX - minX, height: maxY - minY };
     }
@@ -3438,11 +3438,11 @@ var Cutout = class extends PrimitiveComponent2 {
     } else if (cutout.shape === "polygon") {
       if (cutout.points.length === 0) return super._getPcbCircuitJsonBounds();
       let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-      for (const point2 of cutout.points) {
-        minX = Math.min(minX, point2.x);
-        maxX = Math.max(maxX, point2.x);
-        minY = Math.min(minY, point2.y);
-        maxY = Math.max(maxY, point2.y);
+      for (const point4 of cutout.points) {
+        minX = Math.min(minX, point4.x);
+        maxX = Math.max(maxX, point4.x);
+        minY = Math.min(minY, point4.y);
+        maxY = Math.max(maxY, point4.y);
       }
       return {
         center: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 },
@@ -5485,13 +5485,13 @@ var getDistance = (a, b) => {
   const bPos = "_getGlobalPcbPositionBeforeLayout" in b ? b._getGlobalPcbPositionBeforeLayout() : b;
   return Math.sqrt((aPos.x - bPos.x) ** 2 + (aPos.y - bPos.y) ** 2);
 };
-function getClosest(point2, candidates) {
+function getClosest(point4, candidates) {
   if (candidates.length === 0)
     throw new Error("No candidates given to getClosest method");
   let closest = candidates[0];
   let closestDist = Infinity;
   for (const candidate of candidates) {
-    const dist = getDistance(point2, candidate);
+    const dist = getDistance(point4, candidate);
     if (dist < closestDist) {
       closest = candidate;
       closestDist = dist;
@@ -5625,24 +5625,24 @@ var isRouteOutsideBoard = (mergedRoute, { db }) => {
   const pcbBoard = db.pcb_board.list()[0];
   if (pcbBoard.outline) {
     const boardOutline = pcbBoard.outline;
-    const isInsidePolygon = (point2, polygon) => {
+    const isInsidePolygon = (point4, polygon) => {
       let inside = false;
       for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
         const xi = polygon[i].x, yi = polygon[i].y;
         const xj = polygon[j].x, yj = polygon[j].y;
-        const intersect = yi > point2.y !== yj > point2.y && point2.x < (xj - xi) * (point2.y - yi) / (yj - yi) + xi;
+        const intersect = yi > point4.y !== yj > point4.y && point4.x < (xj - xi) * (point4.y - yi) / (yj - yi) + xi;
         if (intersect) inside = !inside;
       }
       return inside;
     };
-    return mergedRoute.some((point2) => !isInsidePolygon(point2, boardOutline));
+    return mergedRoute.some((point4) => !isInsidePolygon(point4, boardOutline));
   }
   const boardWidth = pcbBoard.width;
   const boardHeight = pcbBoard.height;
   const boardCenterX = pcbBoard.center.x;
   const boardCenterY = pcbBoard.center.y;
-  const outsideBoard = mergedRoute.some((point2) => {
-    return point2.x < boardCenterX - boardWidth / 2 || point2.y < boardCenterY - boardHeight / 2 || point2.x > boardCenterX + boardWidth / 2 || point2.y > boardCenterY + boardHeight / 2;
+  const outsideBoard = mergedRoute.some((point4) => {
+    return point4.x < boardCenterX - boardWidth / 2 || point4.y < boardCenterY - boardHeight / 2 || point4.x > boardCenterX + boardWidth / 2 || point4.y > boardCenterY + boardHeight / 2;
   });
   return outsideBoard;
 };
@@ -6224,12 +6224,12 @@ var createSchematicTraceCrossingSegments = ({
 
 // lib/components/primitive-components/Trace/trace-utils/create-schematic-trace-junctions.ts
 var TOLERANCE = 1e-3;
-var isPointWithinEdge = (point2, edge) => {
+var isPointWithinEdge = (point4, edge) => {
   const minX = Math.min(edge.from.x, edge.to.x);
   const maxX = Math.max(edge.from.x, edge.to.x);
   const minY = Math.min(edge.from.y, edge.to.y);
   const maxY = Math.max(edge.from.y, edge.to.y);
-  return point2.x >= minX && point2.x <= maxX && point2.y >= minY && point2.y <= maxY;
+  return point4.x >= minX && point4.x <= maxX && point4.y >= minY && point4.y <= maxY;
 };
 var getEdgeOrientation = (edge) => {
   const isVertical = Math.abs(edge.from.x - edge.to.x) < TOLERANCE;
@@ -6837,15 +6837,15 @@ import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectiv
 function getTraceLength(route) {
   let totalLength = 0;
   for (let i = 0; i < route.length; i++) {
-    const point2 = route[i];
-    if (point2.route_type === "wire") {
+    const point4 = route[i];
+    if (point4.route_type === "wire") {
       const nextPoint = route[i + 1];
       if (nextPoint) {
-        const dx = nextPoint.x - point2.x;
-        const dy = nextPoint.y - point2.y;
+        const dx = nextPoint.x - point4.x;
+        const dy = nextPoint.y - point4.y;
         totalLength += Math.sqrt(dx * dx + dy * dy);
       }
-    } else if (point2.route_type === "via") {
+    } else if (point4.route_type === "via") {
       totalLength += 1.6;
     }
   }
@@ -7155,17 +7155,17 @@ function Trace_doInitialPcbTraceRender(trace) {
   });
   trace._portsRoutedOnPcb = ports;
   trace.pcb_trace_id = pcb_trace.pcb_trace_id;
-  for (const point2 of mergedRoute) {
-    if (point2.route_type === "via") {
+  for (const point4 of mergedRoute) {
+    if (point4.route_type === "via") {
       db.pcb_via.insert({
         pcb_trace_id: pcb_trace.pcb_trace_id,
-        x: point2.x,
-        y: point2.y,
+        x: point4.x,
+        y: point4.y,
         hole_diameter: holeDiameter,
         outer_diameter: padDiameter,
-        layers: [point2.from_layer, point2.to_layer],
-        from_layer: point2.from_layer,
-        to_layer: point2.to_layer
+        layers: [point4.from_layer, point4.to_layer],
+        from_layer: point4.from_layer,
+        to_layer: point4.to_layer
       });
     }
   }
@@ -10549,7 +10549,7 @@ var getSimpleRouteJsonFromCircuitJson = ({
       layerCount: board?.num_layers ?? 2,
       minTraceWidth,
       nominalTraceWidth,
-      outline: board?.outline?.map((point2) => ({ ...point2 }))
+      outline: board?.outline?.map((point4) => ({ ...point4 }))
     },
     connMap
   };
@@ -14245,16 +14245,16 @@ function splitRouteAtJumperPads(route, padInfos) {
   const segments = [];
   let currentSegment = [];
   for (let i = 0; i < route.length; i++) {
-    const point2 = route[i];
-    currentSegment.push(point2);
-    if (point2.route_type === "wire" && i > 0 && i < route.length - 1) {
-      const padInfo = findJumperPortContainingPoint(padInfos, point2.x, point2.y);
+    const point4 = route[i];
+    currentSegment.push(point4);
+    if (point4.route_type === "wire" && i > 0 && i < route.length - 1) {
+      const padInfo = findJumperPortContainingPoint(padInfos, point4.x, point4.y);
       if (padInfo) {
-        if (!point2.end_pcb_port_id) {
-          point2.end_pcb_port_id = padInfo.pcb_port_id;
+        if (!point4.end_pcb_port_id) {
+          point4.end_pcb_port_id = padInfo.pcb_port_id;
         }
         segments.push(currentSegment);
-        const newStartPoint = { ...point2 };
+        const newStartPoint = { ...point4 };
         delete newStartPoint.end_pcb_port_id;
         if (!newStartPoint.start_pcb_port_id) {
           newStartPoint.start_pcb_port_id = padInfo.pcb_port_id;
@@ -14392,9 +14392,9 @@ var Group6 = class extends NormalComponent3 {
     const { _parsedProps: props } = this;
     const groupProps2 = props;
     const hasOutline = groupProps2.outline && groupProps2.outline.length > 0;
-    const numericOutline = hasOutline ? groupProps2.outline.map((point2) => ({
-      x: distance8.parse(point2.x),
-      y: distance8.parse(point2.y)
+    const numericOutline = hasOutline ? groupProps2.outline.map((point4) => ({
+      x: distance8.parse(point4.x),
+      y: distance8.parse(point4.y)
     })) : void 0;
     const ctx = this.props;
     const anchorPosition = this._getGlobalPcbPositionBeforeLayout();
@@ -14431,9 +14431,9 @@ var Group6 = class extends NormalComponent3 {
     const hasOutline = props.outline && props.outline.length > 0;
     const hasExplicitPositioning = this._parsedProps.pcbX !== void 0 || this._parsedProps.pcbY !== void 0;
     if (hasOutline) {
-      const numericOutline = props.outline.map((point2) => ({
-        x: distance8.parse(point2.x),
-        y: distance8.parse(point2.y)
+      const numericOutline = props.outline.map((point4) => ({
+        x: distance8.parse(point4.x),
+        y: distance8.parse(point4.y)
       }));
       const outlineBounds = getBoundsFromPoints3(numericOutline);
       if (!outlineBounds) return;
@@ -14903,20 +14903,20 @@ var Group6 = class extends NormalComponent3 {
         continue;
       }
       if (pcb_trace.type === "pcb_trace") {
-        for (const point2 of pcb_trace.route) {
-          if (point2.route_type === "via") {
+        for (const point4 of pcb_trace.route) {
+          if (point4.route_type === "via") {
             db.pcb_via.insert({
               pcb_trace_id: pcb_trace.pcb_trace_id,
-              x: point2.x,
-              y: point2.y,
+              x: point4.x,
+              y: point4.y,
               hole_diameter: holeDiameter,
               outer_diameter: padDiameter,
               layers: [
-                point2.from_layer,
-                point2.to_layer
+                point4.from_layer,
+                point4.to_layer
               ],
-              from_layer: point2.from_layer,
-              to_layer: point2.to_layer
+              from_layer: point4.from_layer,
+              to_layer: point4.to_layer
             });
           }
         }
@@ -16400,9 +16400,9 @@ var Board = class extends Group6 {
       center
     };
     if (outline) {
-      update.outline = outline.map((point2) => ({
-        x: point2.x + (props.outlineOffsetX ?? 0),
-        y: point2.y + (props.outlineOffsetY ?? 0)
+      update.outline = outline.map((point4) => ({
+        x: point4.x + (props.outlineOffsetX ?? 0),
+        y: point4.y + (props.outlineOffsetY ?? 0)
       }));
     }
     db.pcb_board.update(this.pcb_board_id, update);
@@ -16489,8 +16489,8 @@ var Board = class extends Group6 {
       });
     }
     if (props.outline) {
-      const xValues = props.outline.map((point2) => point2.x);
-      const yValues = props.outline.map((point2) => point2.y);
+      const xValues = props.outline.map((point4) => point4.x);
+      const yValues = props.outline.map((point4) => point4.y);
       const minX = Math.min(...xValues);
       const maxX = Math.max(...xValues);
       const minY = Math.min(...yValues);
@@ -16525,9 +16525,9 @@ var Board = class extends Group6 {
       num_layers: this.allLayers.length,
       width: computedWidth,
       height: computedHeight,
-      outline: outline?.map((point2) => ({
-        x: point2.x + (props.outlineOffsetX ?? 0) + outlineTranslation.x,
-        y: point2.y + (props.outlineOffsetY ?? 0) + outlineTranslation.y
+      outline: outline?.map((point4) => ({
+        x: point4.x + (props.outlineOffsetX ?? 0) + outlineTranslation.x,
+        y: point4.y + (props.outlineOffsetY ?? 0) + outlineTranslation.y
       })),
       material: props.material
     });
@@ -16641,6 +16641,7 @@ import { distance as distance11 } from "circuit-json";
 
 // lib/utils/panels/generate-panel-tabs-and-mouse-bites.ts
 import * as Flatten from "@flatten-js/core";
+import { point as point2, Polygon as Polygon2 } from "@flatten-js/core";
 var DEFAULT_TAB_LENGTH = 5;
 var DEFAULT_TAB_WIDTH = 2;
 var generateCutoutsAndMousebitesForOutline = (outline, options) => {
@@ -16770,7 +16771,33 @@ var generateCutoutsAndMousebitesForOutline = (outline, options) => {
 function generatePanelTabsAndMouseBites(boards, options) {
   const finalTabCutouts = [];
   const allMouseBites = [];
-  const { tabWidth, tabLength, mouseBites: useMouseBites } = options;
+  let { tabWidth, tabLength, mouseBites: useMouseBites } = options;
+  const boardDimensions = [];
+  for (const board of boards) {
+    if (board.width && board.height) {
+      boardDimensions.push(Math.min(board.width, board.height));
+    } else if (board.outline && board.outline.length > 0) {
+      const outlinePolygon = new Polygon2(
+        board.outline.map((p) => point2(p.x, p.y))
+      );
+      const area = Math.abs(outlinePolygon.area());
+      if (area > 0) {
+        boardDimensions.push(Math.sqrt(area));
+      }
+    }
+  }
+  if (boardDimensions.length > 0) {
+    const minBoardDimension = Math.min(...boardDimensions);
+    const scaleFactor = minBoardDimension / 20;
+    tabWidth = Math.min(
+      tabWidth,
+      DEFAULT_TAB_WIDTH * Math.max(scaleFactor, 0.3)
+    );
+    tabLength = Math.min(
+      tabLength,
+      DEFAULT_TAB_LENGTH * Math.max(scaleFactor, 0.3)
+    );
+  }
   const processedBoards = boards.map((board) => {
     if ((!board.outline || board.outline.length === 0) && board.width && board.height) {
       const w2 = board.width / 2;
@@ -17963,10 +17990,10 @@ var FabricationNotePath = class extends PrimitiveComponent2 {
     const { _parsedProps: props } = this;
     if (props.route.length === 0) return { width: 0, height: 0 };
     const xs = props.route.map(
-      (point2) => typeof point2.x === "string" ? parseFloat(point2.x) : point2.x
+      (point4) => typeof point4.x === "string" ? parseFloat(point4.x) : point4.x
     );
     const ys = props.route.map(
-      (point2) => typeof point2.y === "string" ? parseFloat(point2.y) : point2.y
+      (point4) => typeof point4.y === "string" ? parseFloat(point4.y) : point4.y
     );
     const minX = Math.min(...xs);
     const maxX = Math.max(...xs);
@@ -18384,8 +18411,8 @@ var PcbNotePath = class extends PrimitiveComponent2 {
     const subcircuit = this.getSubcircuit();
     const group = this.getGroup();
     const pcb_component_id = this.parent?.pcb_component_id ?? this.getPrimitiveContainer()?.pcb_component_id ?? void 0;
-    const transformedRoute = props.route.map((point2) => {
-      const { x, y, ...rest } = point2;
+    const transformedRoute = props.route.map((point4) => {
+      const { x, y, ...rest } = point4;
       const numericX = typeof x === "string" ? parseFloat(x) : x;
       const numericY = typeof y === "string" ? parseFloat(y) : y;
       const transformed = applyToPoint15(transform, { x: numericX, y: numericY });
@@ -18405,10 +18432,10 @@ var PcbNotePath = class extends PrimitiveComponent2 {
     const { _parsedProps: props } = this;
     if (props.route.length === 0) return { width: 0, height: 0 };
     const xs = props.route.map(
-      (point2) => typeof point2.x === "string" ? parseFloat(point2.x) : point2.x
+      (point4) => typeof point4.x === "string" ? parseFloat(point4.x) : point4.x
     );
     const ys = props.route.map(
-      (point2) => typeof point2.y === "string" ? parseFloat(point2.y) : point2.y
+      (point4) => typeof point4.y === "string" ? parseFloat(point4.y) : point4.y
     );
     const minX = Math.min(...xs);
     const maxX = Math.max(...xs);
@@ -18684,11 +18711,11 @@ var BreakoutPoint = class extends PrimitiveComponent2 {
     if (this.root?.pcbDisabled) return;
     const { db } = this.root;
     if (!this.pcb_breakout_point_id) return;
-    const point2 = db.pcb_breakout_point.get(this.pcb_breakout_point_id);
-    if (point2) {
+    const point4 = db.pcb_breakout_point.get(this.pcb_breakout_point_id);
+    if (point4) {
       db.pcb_breakout_point.update(this.pcb_breakout_point_id, {
-        x: point2.x + deltaX,
-        y: point2.y + deltaY
+        x: point4.x + deltaX,
+        y: point4.y + deltaY
       });
     }
   }
@@ -20249,9 +20276,9 @@ var SchematicPath = class extends PrimitiveComponent2 {
     const schematic_component_id = this.getPrimitiveContainer()?.parent?.schematic_component_id;
     db.schematic_path.insert({
       schematic_component_id,
-      points: props.points.map((point2) => ({
-        x: point2.x + globalPos.x,
-        y: point2.y + globalPos.y
+      points: props.points.map((point4) => ({
+        x: point4.x + globalPos.x,
+        y: point4.y + globalPos.y
       })),
       is_filled: props.isFilled,
       fill_color: props.fillColor,
@@ -20926,7 +20953,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.975",
+  version: "0.0.976",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.976",
+  "version": "0.0.977",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",