@tscircuit/core 0.0.869 → 0.0.871

package/dist/index.d.ts

@@ -2720,6 +2720,7 @@ declare class Board extends Group<typeof boardProps> {
 
 declare class Panel extends Group<typeof panelProps> {
     pcb_panel_id: string | null;
+    _tabsAndMouseBitesGenerated: boolean;
     get config(): {
         componentName: string;
         zodProps: zod.ZodObject<Omit<{
@@ -3734,6 +3735,7 @@ declare class Panel extends Group<typeof panelProps> {
     get isGroup(): boolean;
     get isSubcircuit(): boolean;
     add(component: PrimitiveComponent): void;
+    doInitialPcbComponentAnchorAlignment(): void;
     runRenderCycle(): void;
     doInitialPcbComponentRender(): void;
     updatePcbComponentRender(): void;

package/dist/index.js

@@ -14298,8 +14298,243 @@ var Board = class extends Group6 {
 // lib/components/normal-components/Panel.ts
 import { panelProps } from "@tscircuit/props";
 import { distance as distance7 } from "circuit-json";
+
+// lib/utils/panels/generate-panel-tabs-and-mouse-bites.ts
+var TAB_CONFIG = {
+  TAB_WIDTH: 4,
+  TAB_DEPTH: 0.5,
+  TAB_TO_SPACE_RATIO: 5,
+  MOUSE_BITE_DIAMETER: 0.2,
+  MOUSE_BITE_SPACING: 0.1,
+  MOUSE_BITES_PER_GAP: 5
+};
+function rectanglesOverlap(rect1, rect2) {
+  const r1Left = rect1.center.x - rect1.width / 2;
+  const r1Right = rect1.center.x + rect1.width / 2;
+  const r1Bottom = rect1.center.y - rect1.height / 2;
+  const r1Top = rect1.center.y + rect1.height / 2;
+  const r2Left = rect2.center.x - rect2.width / 2;
+  const r2Right = rect2.center.x + rect2.width / 2;
+  const r2Bottom = rect2.center.y - rect2.height / 2;
+  const r2Top = rect2.center.y + rect2.height / 2;
+  return !(r1Right <= r2Left || r1Left >= r2Right || r1Top <= r2Bottom || r1Bottom >= r2Top);
+}
+function pointOverlapsRectangle(point, 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;
+  return distanceX * distanceX + distanceY * distanceY <= radius * radius;
+}
+function generateTabsForEdge(board, edge, existingTabs, otherBoards) {
+  const tabs = [];
+  if (!board.width || !board.height) return tabs;
+  const boardLeft = board.center.x - board.width / 2;
+  const boardRight = board.center.x + board.width / 2;
+  const boardBottom = board.center.y - board.height / 2;
+  const boardTop = board.center.y + board.height / 2;
+  let edgeLength;
+  let isHorizontal;
+  let edgeCenter;
+  if (edge === "top" || edge === "bottom") {
+    edgeLength = board.width;
+    isHorizontal = true;
+    edgeCenter = edge === "top" ? boardTop : boardBottom;
+  } else {
+    edgeLength = board.height;
+    isHorizontal = false;
+    edgeCenter = edge === "right" ? boardRight : boardLeft;
+  }
+  const totalTabWidth = TAB_CONFIG.TAB_WIDTH;
+  const minSpacingForMouseBites = TAB_CONFIG.MOUSE_BITES_PER_GAP * TAB_CONFIG.MOUSE_BITE_DIAMETER + (TAB_CONFIG.MOUSE_BITES_PER_GAP - 1) * TAB_CONFIG.MOUSE_BITE_SPACING;
+  const fixedSpacing = minSpacingForMouseBites * 1.1;
+  let numTabs = Math.floor(
+    (edgeLength - fixedSpacing) / (totalTabWidth + fixedSpacing)
+  );
+  if (numTabs < 1 && edgeLength >= totalTabWidth) {
+    numTabs = 1;
+  }
+  if (numTabs === 0) return tabs;
+  const actualSpacing = fixedSpacing;
+  const boardStart = -edgeLength / 2;
+  const boardEnd = edgeLength / 2;
+  for (let i = 0; i < numTabs; i++) {
+    const offsetAlongEdge = boardStart + actualSpacing + i * (totalTabWidth + actualSpacing) + totalTabWidth / 2;
+    const isFirstTab = i === 0;
+    const isLastTab = i === numTabs - 1;
+    const isCornerTab = isFirstTab || isLastTab;
+    let axisStart = offsetAlongEdge - totalTabWidth / 2;
+    let axisEnd = offsetAlongEdge + totalTabWidth / 2;
+    if (isCornerTab) {
+      if (isFirstTab) axisStart = boardStart;
+      if (isLastTab) axisEnd = boardEnd;
+    }
+    axisStart = Math.max(axisStart, boardStart);
+    axisEnd = Math.min(axisEnd, boardEnd);
+    if (isCornerTab) {
+      if (isFirstTab) axisStart -= TAB_CONFIG.TAB_DEPTH;
+      if (isLastTab) axisEnd += TAB_CONFIG.TAB_DEPTH;
+    }
+    if (axisEnd <= axisStart) continue;
+    const axisCenterOffset = (axisStart + axisEnd) / 2;
+    const axisLength = axisEnd - axisStart;
+    const crossAxisOffset = edge === "top" || edge === "right" ? TAB_CONFIG.TAB_DEPTH / 2 : -TAB_CONFIG.TAB_DEPTH / 2;
+    const tabCenter = isHorizontal ? {
+      x: board.center.x + axisCenterOffset,
+      y: edgeCenter + crossAxisOffset
+    } : {
+      x: edgeCenter + crossAxisOffset,
+      y: board.center.y + axisCenterOffset
+    };
+    const tabWidth = isHorizontal ? axisLength : TAB_CONFIG.TAB_DEPTH;
+    const tabHeight = isHorizontal ? TAB_CONFIG.TAB_DEPTH : axisLength;
+    const newTab = {
+      center: tabCenter,
+      width: tabWidth,
+      height: tabHeight,
+      boardId: `${board.center.x}_${board.center.y}`
+    };
+    let overlapsBoard = false;
+    for (const otherBoard of otherBoards) {
+      if (!otherBoard.width || !otherBoard.height) continue;
+      const boardRect = {
+        center: otherBoard.center,
+        width: otherBoard.width,
+        height: otherBoard.height
+      };
+      if (rectanglesOverlap(newTab, boardRect)) {
+        overlapsBoard = true;
+        break;
+      }
+    }
+    if (overlapsBoard && !isCornerTab) continue;
+    tabs.push(newTab);
+  }
+  return tabs;
+}
+function generateMouseBitesForEdge(board, edge, edgeTabs, allTabs, allBoards, existingMouseBites) {
+  const mouseBites = [];
+  if (edgeTabs.length === 0) return mouseBites;
+  if (!board.width || !board.height) return mouseBites;
+  const boardLeft = board.center.x - board.width / 2;
+  const boardRight = board.center.x + board.width / 2;
+  const boardBottom = board.center.y - board.height / 2;
+  const boardTop = board.center.y + board.height / 2;
+  const isHorizontal = edge === "top" || edge === "bottom";
+  let mouseBitePosition;
+  const radius = TAB_CONFIG.MOUSE_BITE_DIAMETER / 2;
+  if (edge === "top") {
+    mouseBitePosition = boardTop;
+  } else if (edge === "bottom") {
+    mouseBitePosition = boardBottom;
+  } else if (edge === "right") {
+    mouseBitePosition = boardRight;
+  } else {
+    mouseBitePosition = boardLeft;
+  }
+  const sortedTabs = [...edgeTabs].sort((a, b) => {
+    if (isHorizontal) {
+      return a.center.x - b.center.x;
+    } else {
+      return a.center.y - b.center.y;
+    }
+  });
+  for (let i = 0; i < sortedTabs.length - 1; i++) {
+    const tab1 = sortedTabs[i];
+    const tab2 = sortedTabs[i + 1];
+    let gapStart;
+    let gapEnd;
+    if (isHorizontal) {
+      gapStart = tab1.center.x + tab1.width / 2;
+      gapEnd = tab2.center.x - tab2.width / 2;
+    } else {
+      gapStart = tab1.center.y + tab1.height / 2;
+      gapEnd = tab2.center.y - tab2.height / 2;
+    }
+    const gapLength = gapEnd - gapStart;
+    const totalMouseBiteWidth = TAB_CONFIG.MOUSE_BITES_PER_GAP * TAB_CONFIG.MOUSE_BITE_DIAMETER;
+    const totalSpacing = (TAB_CONFIG.MOUSE_BITES_PER_GAP - 1) * TAB_CONFIG.MOUSE_BITE_SPACING;
+    if (gapLength < totalMouseBiteWidth + totalSpacing) continue;
+    const gapCenter = (gapStart + gapEnd) / 2;
+    for (let j = 0; j < TAB_CONFIG.MOUSE_BITES_PER_GAP; j++) {
+      const posOffset = (j - (TAB_CONFIG.MOUSE_BITES_PER_GAP - 1) / 2) * (TAB_CONFIG.MOUSE_BITE_DIAMETER + TAB_CONFIG.MOUSE_BITE_SPACING);
+      const newMouseBite = isHorizontal ? { x: gapCenter + posOffset, y: mouseBitePosition } : { x: mouseBitePosition, y: gapCenter + posOffset };
+      const radius2 = TAB_CONFIG.MOUSE_BITE_DIAMETER / 2;
+      let overlapsBoard = false;
+      for (const otherBoard of allBoards) {
+        if (!otherBoard.width || !otherBoard.height) continue;
+        const boardRect = {
+          center: otherBoard.center,
+          width: otherBoard.width,
+          height: otherBoard.height
+        };
+        if (pointOverlapsRectangle(newMouseBite, radius2, boardRect)) {
+          overlapsBoard = true;
+          break;
+        }
+      }
+      if (overlapsBoard) continue;
+      mouseBites.push(newMouseBite);
+    }
+  }
+  return mouseBites;
+}
+function generatePanelTabsAndMouseBites(boards) {
+  const allTabCutouts = [];
+  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,
+        allTabCutouts,
+        otherBoards
+      );
+      allTabCutouts.push(...edgeTabs);
+      const edgeMouseBites = generateMouseBitesForEdge(
+        board,
+        edge,
+        edgeTabs,
+        allTabCutouts,
+        otherBoards,
+        allMouseBites
+      );
+      allMouseBites.push(...edgeMouseBites);
+    }
+  }
+  const tabCutouts = allTabCutouts.map((tab, index) => ({
+    type: "pcb_cutout",
+    pcb_cutout_id: `panel_tab_${index}`,
+    shape: "rect",
+    center: tab.center,
+    width: tab.width,
+    height: tab.height,
+    corner_radius: 0.25
+  }));
+  const mouseBiteHoles = allMouseBites.map((bite, index) => ({
+    type: "pcb_hole",
+    pcb_hole_id: `panel_mouse_bite_${index}`,
+    hole_shape: "circle",
+    hole_diameter: TAB_CONFIG.MOUSE_BITE_DIAMETER,
+    x: bite.x,
+    y: bite.y
+  }));
+  return {
+    tabCutouts,
+    mouseBiteHoles
+  };
+}
+
+// lib/components/normal-components/Panel.ts
 var Panel = class extends Group6 {
   pcb_panel_id = null;
+  _tabsAndMouseBitesGenerated = false;
   get config() {
     return {
       componentName: "Panel",
@@ -14318,6 +14553,99 @@ var Panel = class extends Group6 {
     }
     super.add(component);
   }
+  doInitialPcbComponentAnchorAlignment() {
+    if (this.root?.pcbDisabled) return;
+    super.doInitialPcbComponentAnchorAlignment();
+    const { db } = this.root;
+    const childBoardInstances = this.children.filter(
+      (c) => c instanceof Board
+    );
+    const hasAnyPositionedBoards = childBoardInstances.some(
+      (b) => b.props.pcbX !== void 0 || b.props.pcbY !== void 0
+    );
+    const unpositionedBoards = childBoardInstances.filter(
+      (b) => b.props.pcbX === void 0 && b.props.pcbY === void 0
+    );
+    if (unpositionedBoards.length > 0 && !hasAnyPositionedBoards) {
+      const gridCols = Math.ceil(Math.sqrt(unpositionedBoards.length));
+      const gridRows = Math.ceil(unpositionedBoards.length / gridCols);
+      const colWidths = Array(gridCols).fill(0);
+      const rowHeights = Array(gridRows).fill(0);
+      unpositionedBoards.forEach((board, i) => {
+        const col = i % gridCols;
+        const row = Math.floor(i / gridCols);
+        const pcbBoard = db.pcb_board.get(board.pcb_board_id);
+        if (!pcbBoard || pcbBoard.width === void 0 || pcbBoard.height === void 0)
+          return;
+        colWidths[col] = Math.max(colWidths[col], pcbBoard.width);
+        rowHeights[row] = Math.max(rowHeights[row], pcbBoard.height);
+      });
+      const totalGridWidth = colWidths.reduce((a, b) => a + b, 0) + (gridCols > 1 ? (gridCols - 1) * TAB_CONFIG.TAB_DEPTH : 0);
+      const totalGridHeight = rowHeights.reduce((a, b) => a + b, 0) + (gridRows > 1 ? (gridRows - 1) * TAB_CONFIG.TAB_DEPTH : 0);
+      const startX = -totalGridWidth / 2;
+      const startY = -totalGridHeight / 2;
+      const rowYOffsets = [startY];
+      for (let i = 0; i < gridRows - 1; i++) {
+        rowYOffsets.push(rowYOffsets[i] + rowHeights[i] + TAB_CONFIG.TAB_DEPTH);
+      }
+      const colXOffsets = [startX];
+      for (let i = 0; i < gridCols - 1; i++) {
+        colXOffsets.push(colXOffsets[i] + colWidths[i] + TAB_CONFIG.TAB_DEPTH);
+      }
+      unpositionedBoards.forEach((board, i) => {
+        const col = i % gridCols;
+        const row = Math.floor(i / gridCols);
+        const pcbBoard = db.pcb_board.get(board.pcb_board_id);
+        if (!pcbBoard || !pcbBoard.width || !pcbBoard.height) return;
+        const xPos = colXOffsets[col] + colWidths[col] / 2;
+        const yPos = rowYOffsets[row] + rowHeights[row] / 2;
+        db.pcb_board.update(board.pcb_board_id, {
+          center: { x: xPos, y: yPos }
+        });
+      });
+      const allBoardPcbIds = childBoardInstances.map((b) => b.pcb_board_id).filter((id) => !!id);
+      const allBoardsInPanel = db.pcb_board.list().filter((b) => allBoardPcbIds.includes(b.pcb_board_id));
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (const board of allBoardsInPanel) {
+        if (board.width === void 0 || board.height === void 0 || !isFinite(board.width) || !isFinite(board.height))
+          continue;
+        const left = board.center.x - board.width / 2;
+        const right = board.center.x + board.width / 2;
+        const bottom = board.center.y - board.height / 2;
+        const top = board.center.y + board.height / 2;
+        minX = Math.min(minX, left);
+        maxX = Math.max(maxX, right);
+        minY = Math.min(minY, bottom);
+        maxY = Math.max(maxY, top);
+      }
+      if (isFinite(minX)) {
+        const boundsWidth = maxX - minX;
+        const boundsHeight = maxY - minY;
+        const margin = TAB_CONFIG.TAB_DEPTH * 3;
+        const newPanelWidth = boundsWidth + 2 * margin;
+        const newPanelHeight = boundsHeight + 2 * margin;
+        db.pcb_panel.update(this.pcb_panel_id, {
+          width: newPanelWidth,
+          height: newPanelHeight
+        });
+      }
+    }
+    if (this._tabsAndMouseBitesGenerated) return;
+    const childBoardIds = childBoardInstances.map((c) => c.pcb_board_id).filter((id) => !!id);
+    const boardsInPanel = db.pcb_board.list().filter((b) => childBoardIds.includes(b.pcb_board_id));
+    if (boardsInPanel.length === 0) return;
+    const { tabCutouts, mouseBiteHoles } = generatePanelTabsAndMouseBites(boardsInPanel);
+    for (const tabCutout of tabCutouts) {
+      db.pcb_cutout.insert(tabCutout);
+    }
+    for (const mouseBiteHole of mouseBiteHoles) {
+      db.pcb_hole.insert(mouseBiteHole);
+    }
+    this._tabsAndMouseBitesGenerated = true;
+  }
   runRenderCycle() {
     if (!this.children.some((child) => child.componentName === "Board")) {
       throw new Error("<panel> must contain at least one <board>");
@@ -18132,7 +18460,7 @@ import { identity as identity6 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.868",
+  version: "0.0.870",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -18190,13 +18518,13 @@ var package_default = {
     "bun-match-svg": "0.0.12",
     "calculate-elbow": "^0.0.12",
     "chokidar-cli": "^3.0.0",
-    "circuit-json": "^0.0.316",
+    "circuit-json": "^0.0.317",
     "circuit-json-to-bpc": "^0.0.13",
     "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.24",
-    "circuit-to-svg": "^0.0.271",
+    "circuit-to-svg": "^0.0.274",
     concurrently: "^9.1.2",
     "connectivity-map": "^1.0.0",
     debug: "^4.3.6",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.869",
+  "version": "0.0.871",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -59,13 +59,13 @@
     "bun-match-svg": "0.0.12",
     "calculate-elbow": "^0.0.12",
     "chokidar-cli": "^3.0.0",
-    "circuit-json": "^0.0.316",
+    "circuit-json": "^0.0.317",
     "circuit-json-to-bpc": "^0.0.13",
     "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.24",
-    "circuit-to-svg": "^0.0.271",
+    "circuit-to-svg": "^0.0.274",
     "concurrently": "^9.1.2",
     "connectivity-map": "^1.0.0",
     "debug": "^4.3.6",