@tscircuit/core 0.0.905 → 0.0.907

package/dist/index.js

@@ -2335,10 +2335,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((point) => {
+      const transformedPoints = props.points.map((point2) => {
         const transformed = applyToPoint2(globalTransform, {
-          x: distance.parse(point.x),
-          y: distance.parse(point.y)
+          x: distance.parse(point2.x),
+          y: distance.parse(point2.y)
         });
         return {
           x: transformed.x,
@@ -2546,18 +2546,18 @@ var SilkscreenPath = class extends PrimitiveComponent2 {
     if (!currentPath) return;
     let currentCenterX = 0;
     let currentCenterY = 0;
-    for (const point of currentPath.route) {
-      currentCenterX += point.x;
-      currentCenterY += point.y;
+    for (const point2 of currentPath.route) {
+      currentCenterX += point2.x;
+      currentCenterY += point2.y;
     }
     currentCenterX /= currentPath.route.length;
     currentCenterY /= currentPath.route.length;
     const offsetX = newCenter.x - currentCenterX;
     const offsetY = newCenter.y - currentCenterY;
-    const newRoute = currentPath.route.map((point) => ({
-      ...point,
-      x: point.x + offsetX,
-      y: point.y + offsetY
+    const newRoute = currentPath.route.map((point2) => ({
+      ...point2,
+      x: point2.x + offsetX,
+      y: point2.y + offsetY
     }));
     db.pcb_silkscreen_path.update(this.pcb_silkscreen_path_id, {
       route: newRoute
@@ -2569,11 +2569,11 @@ var SilkscreenPath = class extends PrimitiveComponent2 {
       return { width: 0, height: 0 };
     }
     let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-    for (const point of props.route) {
-      minX = Math.min(minX, point.x);
-      maxX = Math.max(maxX, point.x);
-      minY = Math.min(minY, point.y);
-      maxY = Math.max(maxY, point.y);
+    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);
     }
     return {
       width: maxX - minX,
@@ -2609,14 +2609,14 @@ var PcbTrace = class extends PrimitiveComponent2 {
     const subcircuit = this.getSubcircuit();
     const { maybeFlipLayer } = this._getPcbPrimitiveFlippedHelpers();
     const parentTransform = this._computePcbGlobalTransformBeforeLayout();
-    const transformedRoute = props.route.map((point) => {
-      const { x, y, ...restOfPoint } = point;
+    const transformedRoute = props.route.map((point2) => {
+      const { x, y, ...restOfPoint } = point2;
       const transformedPoint = applyToPoint4(parentTransform, { x, y });
-      if (point.route_type === "wire" && point.layer) {
+      if (point2.route_type === "wire" && point2.layer) {
         return {
           ...transformedPoint,
           ...restOfPoint,
-          layer: maybeFlipLayer(point.layer)
+          layer: maybeFlipLayer(point2.layer)
         };
       }
       return { ...transformedPoint, ...restOfPoint };
@@ -2636,16 +2636,16 @@ var PcbTrace = class extends PrimitiveComponent2 {
       return { width: 0, height: 0 };
     }
     let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-    for (const point of props.route) {
-      minX = Math.min(minX, point.x);
-      maxX = Math.max(maxX, point.x);
-      minY = Math.min(minY, point.y);
-      maxY = Math.max(maxY, point.y);
-      if (point.route_type === "wire") {
-        minX = Math.min(minX, point.x - point.width / 2);
-        maxX = Math.max(maxX, point.x + point.width / 2);
-        minY = Math.min(minY, point.y - point.width / 2);
-        maxY = Math.max(maxY, point.y + point.width / 2);
+    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);
       }
     }
     if (minX === Infinity || maxX === -Infinity || minY === Infinity || maxY === -Infinity) {
@@ -2911,9 +2911,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((point) => {
-        const x = typeof point.x === "number" ? point.x : parseFloat(String(point.x));
-        const y = typeof point.y === "number" ? point.y : parseFloat(String(point.y));
+      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));
         return {
           x,
           y
@@ -3273,11 +3273,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 point of props.points) {
-        minX = Math.min(minX, point.x);
-        maxX = Math.max(maxX, point.x);
-        minY = Math.min(minY, point.y);
-        maxY = Math.max(maxY, point.y);
+      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);
       }
       return { width: maxX - minX, height: maxY - minY };
     }
@@ -3316,11 +3316,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 point of cutout.points) {
-        minX = Math.min(minX, point.x);
-        maxX = Math.max(maxX, point.x);
-        minY = Math.min(minY, point.y);
-        maxY = Math.max(maxY, point.y);
+      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);
       }
       return {
         center: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 },
@@ -5324,13 +5324,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(point, candidates) {
+function getClosest(point2, 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(point, candidate);
+    const dist = getDistance(point2, candidate);
     if (dist < closestDist) {
       closest = candidate;
       closestDist = dist;
@@ -5464,24 +5464,24 @@ var isRouteOutsideBoard = (mergedRoute, { db }) => {
   const pcbBoard = db.pcb_board.list()[0];
   if (pcbBoard.outline) {
     const boardOutline = pcbBoard.outline;
-    const isInsidePolygon = (point, polygon) => {
+    const isInsidePolygon = (point2, 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 > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi) + xi;
+        const intersect = yi > point2.y !== yj > point2.y && point2.x < (xj - xi) * (point2.y - yi) / (yj - yi) + xi;
         if (intersect) inside = !inside;
       }
       return inside;
     };
-    return mergedRoute.some((point) => !isInsidePolygon(point, boardOutline));
+    return mergedRoute.some((point2) => !isInsidePolygon(point2, boardOutline));
   }
   const boardWidth = pcbBoard.width;
   const boardHeight = pcbBoard.height;
   const boardCenterX = pcbBoard.center.x;
   const boardCenterY = pcbBoard.center.y;
-  const outsideBoard = mergedRoute.some((point) => {
-    return point.x < boardCenterX - boardWidth / 2 || point.y < boardCenterY - boardHeight / 2 || point.x > boardCenterX + boardWidth / 2 || point.y > boardCenterY + boardHeight / 2;
+  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;
   });
   return outsideBoard;
 };
@@ -6063,12 +6063,12 @@ var createSchematicTraceCrossingSegments = ({
 
 // lib/components/primitive-components/Trace/trace-utils/create-schematic-trace-junctions.ts
 var TOLERANCE = 1e-3;
-var isPointWithinEdge = (point, edge) => {
+var isPointWithinEdge = (point2, 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 point.x >= minX && point.x <= maxX && point.y >= minY && point.y <= maxY;
+  return point2.x >= minX && point2.x <= maxX && point2.y >= minY && point2.y <= maxY;
 };
 var getEdgeOrientation = (edge) => {
   const isVertical = Math.abs(edge.from.x - edge.to.x) < TOLERANCE;
@@ -6673,15 +6673,15 @@ import { getFullConnectivityMapFromCircuitJson } from "circuit-json-to-connectiv
 function getTraceLength(route) {
   let totalLength = 0;
   for (let i = 0; i < route.length; i++) {
-    const point = route[i];
-    if (point.route_type === "wire") {
+    const point2 = route[i];
+    if (point2.route_type === "wire") {
       const nextPoint = route[i + 1];
       if (nextPoint) {
-        const dx = nextPoint.x - point.x;
-        const dy = nextPoint.y - point.y;
+        const dx = nextPoint.x - point2.x;
+        const dy = nextPoint.y - point2.y;
         totalLength += Math.sqrt(dx * dx + dy * dy);
       }
-    } else if (point.route_type === "via") {
+    } else if (point2.route_type === "via") {
       totalLength += 1.6;
     }
   }
@@ -6991,17 +6991,17 @@ function Trace_doInitialPcbTraceRender(trace) {
   });
   trace._portsRoutedOnPcb = ports;
   trace.pcb_trace_id = pcb_trace.pcb_trace_id;
-  for (const point of mergedRoute) {
-    if (point.route_type === "via") {
+  for (const point2 of mergedRoute) {
+    if (point2.route_type === "via") {
       db.pcb_via.insert({
         pcb_trace_id: pcb_trace.pcb_trace_id,
-        x: point.x,
-        y: point.y,
+        x: point2.x,
+        y: point2.y,
         hole_diameter: holeDiameter,
         outer_diameter: padDiameter,
-        layers: [point.from_layer, point.to_layer],
-        from_layer: point.from_layer,
-        to_layer: point.to_layer
+        layers: [point2.from_layer, point2.to_layer],
+        from_layer: point2.from_layer,
+        to_layer: point2.to_layer
       });
     }
   }
@@ -10247,7 +10247,7 @@ var getSimpleRouteJsonFromCircuitJson = ({
       // subcircuit
       layerCount: board?.num_layers ?? 2,
       minTraceWidth,
-      outline: board?.outline?.map((point) => ({ ...point }))
+      outline: board?.outline?.map((point2) => ({ ...point2 }))
     },
     connMap
   };
@@ -13735,9 +13735,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((point) => ({
-      x: distance8.parse(point.x),
-      y: distance8.parse(point.y)
+    const numericOutline = hasOutline ? groupProps2.outline.map((point2) => ({
+      x: distance8.parse(point2.x),
+      y: distance8.parse(point2.y)
     })) : void 0;
     const pcb_group = db.pcb_group.insert({
       is_subcircuit: this.isSubcircuit,
@@ -13766,9 +13766,9 @@ var Group6 = class extends NormalComponent3 {
     if (this.pcb_group_id) {
       const hasExplicitPositioning = this._parsedProps.pcbX !== void 0 || this._parsedProps.pcbY !== void 0;
       if (hasOutline) {
-        const numericOutline = props.outline.map((point) => ({
-          x: distance8.parse(point.x),
-          y: distance8.parse(point.y)
+        const numericOutline = props.outline.map((point2) => ({
+          x: distance8.parse(point2.x),
+          y: distance8.parse(point2.y)
         }));
         const outlineBounds = getBoundsFromPoints3(numericOutline);
         if (!outlineBounds) return;
@@ -14183,20 +14183,20 @@ var Group6 = class extends NormalComponent3 {
         continue;
       }
       if (pcb_trace.type === "pcb_trace") {
-        for (const point of pcb_trace.route) {
-          if (point.route_type === "via") {
+        for (const point2 of pcb_trace.route) {
+          if (point2.route_type === "via") {
             db.pcb_via.insert({
               pcb_trace_id: pcb_trace.pcb_trace_id,
-              x: point.x,
-              y: point.y,
+              x: point2.x,
+              y: point2.y,
               hole_diameter: holeDiameter,
               outer_diameter: padDiameter,
               layers: [
-                point.from_layer,
-                point.to_layer
+                point2.from_layer,
+                point2.to_layer
               ],
-              from_layer: point.from_layer,
-              to_layer: point.to_layer
+              from_layer: point2.from_layer,
+              to_layer: point2.to_layer
             });
           }
         }
@@ -15047,7 +15047,8 @@ var Inductor = class extends NormalComponent3 {
     const source_component = db.source_component.insert({
       name: this.name,
       ftype: FTYPE.simple_inductor,
-      inductance: props.inductance,
+      inductance: this.props.inductance,
+      display_inductance: this._getSchematicSymbolDisplayValue(),
       supplier_part_numbers: props.supplierPartNumbers,
       are_pins_interchangeable: true
     });
@@ -15635,9 +15636,9 @@ var Board = class extends Group6 {
       center
     };
     if (outline) {
-      update.outline = outline.map((point) => ({
-        x: point.x + (props.outlineOffsetX ?? 0),
-        y: point.y + (props.outlineOffsetY ?? 0)
+      update.outline = outline.map((point2) => ({
+        x: point2.x + (props.outlineOffsetX ?? 0),
+        y: point2.y + (props.outlineOffsetY ?? 0)
       }));
     }
     db.pcb_board.update(this.pcb_board_id, update);
@@ -15716,8 +15717,8 @@ var Board = class extends Group6 {
       });
     }
     if (props.outline) {
-      const xValues = props.outline.map((point) => point.x);
-      const yValues = props.outline.map((point) => point.y);
+      const xValues = props.outline.map((point2) => point2.x);
+      const yValues = props.outline.map((point2) => point2.y);
       const minX = Math.min(...xValues);
       const maxX = Math.max(...xValues);
       const minY = Math.min(...yValues);
@@ -15743,9 +15744,9 @@ var Board = class extends Group6 {
       num_layers: this.allLayers.length,
       width: computedWidth,
       height: computedHeight,
-      outline: outline?.map((point) => ({
-        x: point.x + (props.outlineOffsetX ?? 0),
-        y: point.y + (props.outlineOffsetY ?? 0)
+      outline: outline?.map((point2) => ({
+        x: point2.x + (props.outlineOffsetX ?? 0),
+        y: point2.y + (props.outlineOffsetY ?? 0)
       })),
       material: props.material
     });
@@ -15821,6 +15822,7 @@ import { panelProps } from "@tscircuit/props";
 import { distance as distance9 } from "circuit-json";
 
 // lib/utils/panels/generate-panel-tabs-and-mouse-bites.ts
+import * as Flatten from "@flatten-js/core";
 var DEFAULT_PANEL_MARGIN = 5;
 var DEFAULT_TAB_LENGTH = 5;
 var DEFAULT_TAB_WIDTH = 2;
@@ -15835,15 +15837,15 @@ function rectanglesOverlap(rect1, rect2) {
   const r2Top = rect2.center.y + rect2.height / 2;
   return !(r1Right <= r2Left || r1Left >= r2Right || r1Top <= r2Bottom || r1Bottom >= r2Top);
 }
-function pointOverlapsRectangle(point, radius, rect) {
+function pointOverlapsRectangle(point2, radius, rect) {
   const rectLeft = rect.center.x - rect.width / 2;
   const rectRight = rect.center.x + rect.width / 2;
   const rectBottom = rect.center.y - rect.height / 2;
   const rectTop = rect.center.y + rect.height / 2;
-  const closestX = Math.max(rectLeft, Math.min(point.x, rectRight));
-  const closestY = Math.max(rectBottom, Math.min(point.y, rectTop));
-  const distanceX = point.x - closestX;
-  const distanceY = point.y - closestY;
+  const closestX = Math.max(rectLeft, Math.min(point2.x, rectRight));
+  const closestY = Math.max(rectBottom, Math.min(point2.y, rectTop));
+  const distanceX = point2.x - closestX;
+  const distanceY = point2.y - closestY;
   return distanceX * distanceX + distanceY * distanceY <= radius * radius;
 }
 function generateTabsForEdge({
@@ -16019,44 +16021,199 @@ function generateMouseBitesForEdge({
   }
   return mouseBites;
 }
+var generatePanelTabsAndMouseBitesForOutlines = (outline, otherBoards, options) => {
+  const {
+    boardGap,
+    tabLength,
+    // along edge
+    tabWidth,
+    // extrusion
+    mouseBites,
+    mouseBiteHoleDiameter,
+    mouseBiteHoleSpacing
+  } = options;
+  const tabCutouts = [];
+  const mouseBiteHoles = [];
+  if (outline.length < 2) {
+    return { tabCutouts, mouseBiteHoles };
+  }
+  const outlinePolygon = new Flatten.Polygon(
+    outline.map((p) => Flatten.point(p.x, p.y))
+  );
+  const otherBoardGeometries = otherBoards.map(
+    (b) => b.outline ? new Flatten.Polygon(b.outline.map((p) => Flatten.point(p.x, p.y))) : b.width && b.height ? new Flatten.Box(
+      b.center.x - b.width / 2,
+      b.center.y - b.height / 2,
+      b.center.x + b.width / 2,
+      b.center.y + b.height / 2
+    ) : null
+  );
+  for (let i = 0; i < outline.length; i++) {
+    const p1 = outline[i];
+    const p2 = outline[(i + 1) % outline.length];
+    const segmentVector = Flatten.vector(p2.x - p1.x, p2.y - p1.y);
+    const segmentLength = segmentVector.length;
+    const physicalTabLength = boardGap;
+    const cutoutLength = tabLength;
+    if (segmentLength < physicalTabLength) continue;
+    const segmentDirVec = segmentVector.normalize();
+    const isHorizontal = Math.abs(segmentVector.y) < 1e-9;
+    const isVertical = Math.abs(segmentVector.x) < 1e-9;
+    const isAxisAligned = isHorizontal || isVertical;
+    let normalVec = segmentDirVec.rotate(Math.PI / 2);
+    const midPoint = Flatten.point(p1.x, p1.y).translate(
+      segmentDirVec.multiply(segmentLength / 2)
+    );
+    const testPointInward = midPoint.translate(normalVec.multiply(0.01));
+    if (outlinePolygon.contains(testPointInward)) {
+      normalVec = normalVec.multiply(-1);
+    }
+    const testPointOutward = midPoint.translate(
+      normalVec.multiply((tabWidth + physicalTabLength) / 2)
+    );
+    let isExterior = true;
+    for (const geom of otherBoardGeometries) {
+      if (geom?.contains(testPointOutward)) {
+        isExterior = false;
+        break;
+      }
+    }
+    if (!isExterior) continue;
+    const numTabs = Math.max(
+      1,
+      Math.floor(segmentLength / (physicalTabLength + cutoutLength))
+    );
+    const totalContentLength = numTabs * physicalTabLength;
+    const totalGapLength = segmentLength - totalContentLength;
+    const gapSize = totalGapLength / (numTabs + 1);
+    if (gapSize < 0) continue;
+    const tabsOnSegment = [];
+    for (let j = 0; j < numTabs; j++) {
+      const tabStartDist = gapSize * (j + 1) + physicalTabLength * j;
+      tabsOnSegment.push({
+        start: tabStartDist,
+        end: tabStartDist + physicalTabLength
+      });
+    }
+    const extrusion = normalVec.multiply(tabWidth);
+    for (let j = 0; j <= numTabs; j++) {
+      const gapStartDist = j === 0 ? 0 : tabsOnSegment[j - 1].end;
+      const gapEndDist = j === numTabs ? segmentLength : tabsOnSegment[j].start;
+      const gapLength = gapEndDist - gapStartDist;
+      if (gapLength < 1e-6) continue;
+      if (isAxisAligned) {
+        const width = isHorizontal ? gapLength : tabWidth;
+        const height = isHorizontal ? tabWidth : gapLength;
+        const gapCenterAlongSegment = Flatten.point(p1.x, p1.y).translate(
+          segmentDirVec.multiply(gapStartDist + gapLength / 2)
+        );
+        const center = gapCenterAlongSegment.translate(extrusion.multiply(0.5));
+        tabCutouts.push({
+          type: "pcb_cutout",
+          shape: "rect",
+          center,
+          width,
+          height,
+          corner_radius: Math.min(width, height) / 2
+        });
+      } else {
+        const width = gapLength;
+        const height = tabWidth;
+        const gapCenterAlongSegment = Flatten.point(p1.x, p1.y).translate(
+          segmentDirVec.multiply(gapStartDist + gapLength / 2)
+        );
+        const center = gapCenterAlongSegment.translate(extrusion.multiply(0.5));
+        const rotationDeg = segmentDirVec.slope * 180 / Math.PI;
+        tabCutouts.push({
+          type: "pcb_cutout",
+          shape: "rect",
+          center,
+          width,
+          height,
+          rotation: rotationDeg,
+          corner_radius: Math.min(width, height) / 2
+        });
+      }
+    }
+    if (mouseBites) {
+      const holeSpacing = mouseBiteHoleDiameter + mouseBiteHoleSpacing;
+      for (const tab of tabsOnSegment) {
+        const tabLength2 = tab.end - tab.start;
+        if (tabLength2 < holeSpacing) continue;
+        const numBitesInTab = Math.floor(tabLength2 / holeSpacing);
+        if (numBitesInTab <= 0) continue;
+        const biteStartOffset = tab.start + (tabLength2 - (numBitesInTab - 1) * holeSpacing) / 2;
+        for (let k = 0; k < numBitesInTab; k++) {
+          const biteDist = biteStartOffset + k * holeSpacing;
+          const pos = Flatten.point(p1.x, p1.y).translate(
+            segmentDirVec.multiply(biteDist)
+          );
+          mouseBiteHoles.push({
+            x: pos.x,
+            y: pos.y
+          });
+        }
+      }
+    }
+  }
+  return { tabCutouts, mouseBiteHoles };
+};
 function generatePanelTabsAndMouseBites(boards, options) {
-  const allTabCutouts = [];
+  const finalTabCutouts = [];
   const allMouseBites = [];
   for (let boardIndex = 0; boardIndex < boards.length; boardIndex++) {
     const board = boards[boardIndex];
     const otherBoards = boards.filter((_, i) => i !== boardIndex);
-    for (const edge of ["top", "bottom", "left", "right"]) {
-      const edgeTabs = generateTabsForEdge({
-        board,
-        edge,
+    if (board.outline && board.outline.length > 0) {
+      const mouseBiteDiameter2 = options.tabWidth * 0.45;
+      const mouseBiteSpacing = mouseBiteDiameter2 * 0.1;
+      const generated = generatePanelTabsAndMouseBitesForOutlines(
+        board.outline,
         otherBoards,
-        options
-      });
-      allTabCutouts.push(...edgeTabs);
-      if (options.mouseBites) {
-        const edgeMouseBites = generateMouseBitesForEdge({
+        {
+          ...options,
+          mouseBiteHoleDiameter: mouseBiteDiameter2,
+          mouseBiteHoleSpacing: mouseBiteSpacing
+        }
+      );
+      finalTabCutouts.push(...generated.tabCutouts);
+      allMouseBites.push(...generated.mouseBiteHoles);
+    } else {
+      for (const edge of ["top", "bottom", "left", "right"]) {
+        const edgeTabs = generateTabsForEdge({
           board,
           edge,
-          edgeTabs,
-          allBoards: otherBoards,
+          otherBoards,
           options
         });
-        allMouseBites.push(...edgeMouseBites);
+        for (const tab of edgeTabs) {
+          const tabWidthDimension = Math.min(tab.width, tab.height);
+          finalTabCutouts.push({
+            type: "pcb_cutout",
+            shape: "rect",
+            center: tab.center,
+            width: tab.width,
+            height: tab.height,
+            corner_radius: tabWidthDimension / 2
+          });
+        }
+        if (options.mouseBites) {
+          const edgeMouseBites = generateMouseBitesForEdge({
+            board,
+            edge,
+            edgeTabs,
+            allBoards: otherBoards,
+            options
+          });
+          allMouseBites.push(...edgeMouseBites);
+        }
       }
     }
   }
-  const tabCutouts = allTabCutouts.map((tab, index) => {
-    const tabWidthDimension = Math.min(tab.width, tab.height);
-    return {
-      type: "pcb_cutout",
-      pcb_cutout_id: `panel_tab_${index}`,
-      shape: "rect",
-      center: tab.center,
-      width: tab.width,
-      height: tab.height,
-      corner_radius: tabWidthDimension / 2
-    };
-  });
+  const tabCutouts = finalTabCutouts.map((tab, index) => ({
+    ...tab,
+    pcb_cutout_id: `panel_tab_${index}`
+  }));
   const mouseBiteDiameter = options.tabWidth * 0.45;
   const mouseBiteHoles = allMouseBites.map((bite, index) => ({
     type: "pcb_hole",
@@ -17211,8 +17368,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((point) => {
-      const { x, y, ...rest } = point;
+    const transformedRoute = props.route.map((point2) => {
+      const { x, y, ...rest } = point2;
       const numericX = typeof x === "string" ? parseFloat(x) : x;
       const numericY = typeof y === "string" ? parseFloat(y) : y;
       const transformed = applyToPoint15(transform, { x: numericX, y: numericY });
@@ -17232,10 +17389,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(
-      (point) => typeof point.x === "string" ? parseFloat(point.x) : point.x
+      (point2) => typeof point2.x === "string" ? parseFloat(point2.x) : point2.x
     );
     const ys = props.route.map(
-      (point) => typeof point.y === "string" ? parseFloat(point.y) : point.y
+      (point2) => typeof point2.y === "string" ? parseFloat(point2.y) : point2.y
     );
     const minX = Math.min(...xs);
     const maxX = Math.max(...xs);
@@ -19261,7 +19418,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.904",
+  version: "0.0.906",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -19324,7 +19481,7 @@ var package_default = {
     "circuit-json-to-connectivity-map": "^0.0.22",
     "circuit-json-to-gltf": "^0.0.31",
     "circuit-json-to-simple-3d": "^0.0.9",
-    "circuit-json-to-spice": "^0.0.27",
+    "circuit-json-to-spice": "^0.0.30",
     "circuit-to-svg": "^0.0.284",
     concurrently: "^9.1.2",
     "connectivity-map": "^1.0.0",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.905",
+  "version": "0.0.907",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -64,7 +64,7 @@
     "circuit-json-to-connectivity-map": "^0.0.22",
     "circuit-json-to-gltf": "^0.0.31",
     "circuit-json-to-simple-3d": "^0.0.9",
-    "circuit-json-to-spice": "^0.0.27",
+    "circuit-json-to-spice": "^0.0.30",
     "circuit-to-svg": "^0.0.284",
     "concurrently": "^9.1.2",
     "connectivity-map": "^1.0.0",