circuit-json-to-tscircuit 0.0.83 → 0.0.84

package/dist/{chunk-B56TEDTF.js → chunk-ZIXVXH64.js}

@@ -1628,20 +1628,91 @@ var convertHoles = (circuitJson) => {
 
 // lib/generate-footprint-tsx/convert-keepouts.ts
 import { su as su12 } from "@tscircuit/soup-util";
+
+// lib/generate-footprint-tsx/get-filled-circle-from-keepout-outline.ts
+var MINIMUM_CIRCLE_VERTEX_COUNT = 8;
+var CIRCLE_RADIUS_TOLERANCE = 1e-3;
+var MAXIMUM_ANGULAR_STEP_RATIO = 1.5;
+var FULL_ROTATION_RADIANS = Math.PI * 2;
+var getNormalizedAngleDelta = (angleDelta) => {
+  if (angleDelta > Math.PI) return angleDelta - FULL_ROTATION_RADIANS;
+  if (angleDelta <= -Math.PI) return angleDelta + FULL_ROTATION_RADIANS;
+  return angleDelta;
+};
+var completesCircularTraversal = ({
+  center,
+  outline,
+  radius
+}) => {
+  const firstPoint = outline[0];
+  const lastPoint = outline.at(-1);
+  if (!firstPoint || !lastPoint) return false;
+  if (Math.hypot(firstPoint.x - lastPoint.x, firstPoint.y - lastPoint.y) > radius * CIRCLE_RADIUS_TOLERANCE) {
+    return false;
+  }
+  const traversalPoints = outline.slice(0, -1);
+  const maximumAngularStep = FULL_ROTATION_RADIANS / traversalPoints.length * MAXIMUM_ANGULAR_STEP_RATIO;
+  const angleDeltas = traversalPoints.map((point, pointIndex) => {
+    const nextPoint = traversalPoints[(pointIndex + 1) % traversalPoints.length];
+    const pointAngle = Math.atan2(point.y - center.y, point.x - center.x);
+    const nextPointAngle = Math.atan2(
+      nextPoint.y - center.y,
+      nextPoint.x - center.x
+    );
+    return getNormalizedAngleDelta(nextPointAngle - pointAngle);
+  });
+  const traversalDirection = Math.sign(angleDeltas[0] ?? 0);
+  return traversalDirection !== 0 && angleDeltas.every(
+    (angleDelta) => Math.sign(angleDelta) === traversalDirection && Math.abs(angleDelta) <= maximumAngularStep
+  );
+};
+var getFilledCircleFromKeepoutOutline = (keepout) => {
+  const outline = keepout.outline;
+  if (outline.length < MINIMUM_CIRCLE_VERTEX_COUNT) return null;
+  const minX = Math.min(...outline.map((point) => point.x));
+  const maxX = Math.max(...outline.map((point) => point.x));
+  const minY = Math.min(...outline.map((point) => point.y));
+  const maxY = Math.max(...outline.map((point) => point.y));
+  const center = { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+  const horizontalRadius = (maxX - minX) / 2;
+  const verticalRadius = (maxY - minY) / 2;
+  const centerlineRadius = (horizontalRadius + verticalRadius) / 2;
+  if (!Number.isFinite(centerlineRadius) || centerlineRadius <= 0) return null;
+  if (Math.abs(horizontalRadius - verticalRadius) > centerlineRadius * CIRCLE_RADIUS_TOLERANCE) {
+    return null;
+  }
+  const isCircular = outline.every((point) => {
+    const pointRadius = Math.hypot(point.x - center.x, point.y - center.y);
+    return Math.abs(pointRadius - centerlineRadius) <= centerlineRadius * CIRCLE_RADIUS_TOLERANCE;
+  });
+  if (!isCircular) return null;
+  if (!completesCircularTraversal({ center, outline, radius: centerlineRadius }))
+    return null;
+  const strokeRadius = keepout.stroke_width / 2;
+  if (strokeRadius < centerlineRadius) return null;
+  return { center, radius: centerlineRadius + strokeRadius };
+};
+
+// lib/generate-footprint-tsx/convert-keepouts.ts
+var formatLayersAttribute = (layers) => ` layers={${JSON.stringify(layers)}}`;
 var convertKeepouts = (circuitJson) => {
   const pcbKeepouts = su12(circuitJson).pcb_keepout.list();
   const elementStrings = [];
   for (const keepout of pcbKeepouts) {
     if (keepout.shape === "rect") {
       elementStrings.push(
-        `<keepout shape="rect" pcbX="${formatMm(keepout.center.x)}" pcbY="${formatMm(keepout.center.y)}" width="${formatMm(keepout.width)}" height="${formatMm(keepout.height)}" />`
+        `<keepout shape="rect" pcbX="${formatMm(keepout.center.x)}" pcbY="${formatMm(keepout.center.y)}" width="${formatMm(keepout.width)}" height="${formatMm(keepout.height)}"${formatLayersAttribute(keepout.layers)} />`
       );
     } else if (keepout.shape === "circle") {
       elementStrings.push(
-        `<keepout shape="circle" pcbX="${formatMm(keepout.center.x)}" pcbY="${formatMm(keepout.center.y)}" radius="${formatMm(keepout.radius)}" />`
+        `<keepout shape="circle" pcbX="${formatMm(keepout.center.x)}" pcbY="${formatMm(keepout.center.y)}" radius="${formatMm(keepout.radius)}"${formatLayersAttribute(keepout.layers)} />`
+      );
+    } else if (keepout.shape === "outline") {
+      const circle = getFilledCircleFromKeepoutOutline(keepout);
+      if (!circle) continue;
+      elementStrings.push(
+        `<keepout shape="circle" pcbX="${formatMm(circle.center.x)}" pcbY="${formatMm(circle.center.y)}" radius="${formatMm(circle.radius)}"${formatLayersAttribute(keepout.layers)} />`
       );
-    } else {
-      console.warn(`Unhandled pcb_keepout shape: ${keepout.shape}`);
     }
   }
   return elementStrings;

package/dist/cli/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   convertCircuitJsonToTscircuit
-} from "../chunk-B56TEDTF.js";
+} from "../chunk-ZIXVXH64.js";
 
 // cli/main.ts
 import { Command } from "commander";
@@ -16,7 +16,7 @@ var package_default = {
     "./cli": "./dist/cli/main.js"
   },
   type: "module",
-  version: "0.0.82",
+  version: "0.0.83",
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/circuit-json-to-tscircuit.git"

package/dist/lib/index.js

@@ -1,6 +1,6 @@
 import {
   convertCircuitJsonToTscircuit
-} from "../chunk-B56TEDTF.js";
+} from "../chunk-ZIXVXH64.js";
 export {
   convertCircuitJsonToTscircuit
 };

package/lib/generate-footprint-tsx/convert-keepouts.ts

@@ -1,6 +1,10 @@
 import { su } from "@tscircuit/soup-util"
 import type { FootprintElementConverter } from "./converter-types"
 import { formatMm } from "./footprint-tsx-attribute-formatters/format-mm"
+import { getFilledCircleFromKeepoutOutline } from "./get-filled-circle-from-keepout-outline"
+
+const formatLayersAttribute = (layers: string[]): string =>
+  ` layers={${JSON.stringify(layers)}}`
 
 export const convertKeepouts: FootprintElementConverter = (circuitJson) => {
   const pcbKeepouts = su(circuitJson).pcb_keepout.list()
@@ -9,14 +13,18 @@ export const convertKeepouts: FootprintElementConverter = (circuitJson) => {
   for (const keepout of pcbKeepouts) {
     if (keepout.shape === "rect") {
       elementStrings.push(
-        `<keepout shape="rect" pcbX="${formatMm(keepout.center.x)}" pcbY="${formatMm(keepout.center.y)}" width="${formatMm(keepout.width)}" height="${formatMm(keepout.height)}" />`,
+        `<keepout shape="rect" pcbX="${formatMm(keepout.center.x)}" pcbY="${formatMm(keepout.center.y)}" width="${formatMm(keepout.width)}" height="${formatMm(keepout.height)}"${formatLayersAttribute(keepout.layers)} />`,
       )
     } else if (keepout.shape === "circle") {
       elementStrings.push(
-        `<keepout shape="circle" pcbX="${formatMm(keepout.center.x)}" pcbY="${formatMm(keepout.center.y)}" radius="${formatMm(keepout.radius)}" />`,
+        `<keepout shape="circle" pcbX="${formatMm(keepout.center.x)}" pcbY="${formatMm(keepout.center.y)}" radius="${formatMm(keepout.radius)}"${formatLayersAttribute(keepout.layers)} />`,
+      )
+    } else if (keepout.shape === "outline") {
+      const circle = getFilledCircleFromKeepoutOutline(keepout)
+      if (!circle) continue
+      elementStrings.push(
+        `<keepout shape="circle" pcbX="${formatMm(circle.center.x)}" pcbY="${formatMm(circle.center.y)}" radius="${formatMm(circle.radius)}"${formatLayersAttribute(keepout.layers)} />`,
       )
-    } else {
-      console.warn(`Unhandled pcb_keepout shape: ${(keepout as any).shape}`)
     }
   }
 

package/lib/generate-footprint-tsx/get-filled-circle-from-keepout-outline.ts

@@ -0,0 +1,104 @@
+import type { PcbKeepoutOutline } from "circuit-json"
+
+interface FilledKeepoutCircle {
+  center: { x: number; y: number }
+  radius: number
+}
+
+const MINIMUM_CIRCLE_VERTEX_COUNT = 8
+const CIRCLE_RADIUS_TOLERANCE = 0.001
+const MAXIMUM_ANGULAR_STEP_RATIO = 1.5
+const FULL_ROTATION_RADIANS = Math.PI * 2
+
+const getNormalizedAngleDelta = (angleDelta: number): number => {
+  if (angleDelta > Math.PI) return angleDelta - FULL_ROTATION_RADIANS
+  if (angleDelta <= -Math.PI) return angleDelta + FULL_ROTATION_RADIANS
+  return angleDelta
+}
+
+const completesCircularTraversal = ({
+  center,
+  outline,
+  radius,
+}: {
+  center: { x: number; y: number }
+  outline: PcbKeepoutOutline["outline"]
+  radius: number
+}): boolean => {
+  const firstPoint = outline[0]
+  const lastPoint = outline.at(-1)
+  if (!firstPoint || !lastPoint) return false
+  if (
+    Math.hypot(firstPoint.x - lastPoint.x, firstPoint.y - lastPoint.y) >
+    radius * CIRCLE_RADIUS_TOLERANCE
+  ) {
+    return false
+  }
+
+  const traversalPoints = outline.slice(0, -1)
+  const maximumAngularStep =
+    (FULL_ROTATION_RADIANS / traversalPoints.length) *
+    MAXIMUM_ANGULAR_STEP_RATIO
+  const angleDeltas = traversalPoints.map((point, pointIndex) => {
+    const nextPoint =
+      traversalPoints[(pointIndex + 1) % traversalPoints.length]!
+    const pointAngle = Math.atan2(point.y - center.y, point.x - center.x)
+    const nextPointAngle = Math.atan2(
+      nextPoint.y - center.y,
+      nextPoint.x - center.x,
+    )
+    return getNormalizedAngleDelta(nextPointAngle - pointAngle)
+  })
+  const traversalDirection = Math.sign(angleDeltas[0] ?? 0)
+
+  return (
+    traversalDirection !== 0 &&
+    angleDeltas.every(
+      (angleDelta) =>
+        Math.sign(angleDelta) === traversalDirection &&
+        Math.abs(angleDelta) <= maximumAngularStep,
+    )
+  )
+}
+
+export const getFilledCircleFromKeepoutOutline = (
+  keepout: PcbKeepoutOutline,
+): FilledKeepoutCircle | null => {
+  const outline = keepout.outline
+  if (outline.length < MINIMUM_CIRCLE_VERTEX_COUNT) return null
+
+  const minX = Math.min(...outline.map((point) => point.x))
+  const maxX = Math.max(...outline.map((point) => point.x))
+  const minY = Math.min(...outline.map((point) => point.y))
+  const maxY = Math.max(...outline.map((point) => point.y))
+  const center = { x: (minX + maxX) / 2, y: (minY + maxY) / 2 }
+  const horizontalRadius = (maxX - minX) / 2
+  const verticalRadius = (maxY - minY) / 2
+  const centerlineRadius = (horizontalRadius + verticalRadius) / 2
+
+  if (!Number.isFinite(centerlineRadius) || centerlineRadius <= 0) return null
+  if (
+    Math.abs(horizontalRadius - verticalRadius) >
+    centerlineRadius * CIRCLE_RADIUS_TOLERANCE
+  ) {
+    return null
+  }
+
+  const isCircular = outline.every((point) => {
+    const pointRadius = Math.hypot(point.x - center.x, point.y - center.y)
+    return (
+      Math.abs(pointRadius - centerlineRadius) <=
+      centerlineRadius * CIRCLE_RADIUS_TOLERANCE
+    )
+  })
+  if (!isCircular) return null
+  if (
+    !completesCircularTraversal({ center, outline, radius: centerlineRadius })
+  )
+    return null
+
+  const strokeRadius = keepout.stroke_width / 2
+  if (strokeRadius < centerlineRadius) return null
+
+  return { center, radius: centerlineRadius + strokeRadius }
+}

package/package.json

@@ -6,7 +6,7 @@
     "./cli": "./dist/cli/main.js"
   },
   "type": "module",
-  "version": "0.0.83",
+  "version": "0.0.84",
   "repository": {
     "type": "git",
     "url": "https://github.com/tscircuit/circuit-json-to-tscircuit.git"

package/tests/get-filled-circle-from-keepout-outline.test.ts

@@ -0,0 +1,49 @@
+import { expect, test } from "bun:test"
+import type { PcbKeepoutOutline } from "circuit-json"
+import { getFilledCircleFromKeepoutOutline } from "../lib/generate-footprint-tsx/get-filled-circle-from-keepout-outline"
+
+const createCircularKeepout = ({
+  closeOutline,
+  sweepDegrees,
+}: {
+  closeOutline: boolean
+  sweepDegrees: number
+}): PcbKeepoutOutline => {
+  const segmentCount = 48
+  const outline = Array.from({ length: segmentCount + 1 }, (_, pointIndex) => {
+    const angle = ((pointIndex / segmentCount) * sweepDegrees * Math.PI) / 180
+    return { x: Math.cos(angle), y: Math.sin(angle) }
+  })
+  if (closeOutline && sweepDegrees < 360) outline.push(outline[0]!)
+
+  return {
+    type: "pcb_keepout",
+    pcb_keepout_id: "circular_outline_keepout",
+    shape: "outline",
+    outline,
+    stroke_width: 2,
+    layers: ["top"],
+  }
+}
+
+test("only complete closed circular outlines become filled disks", () => {
+  const fullCircle = createCircularKeepout({
+    closeOutline: true,
+    sweepDegrees: 360,
+  })
+  const openPartialArc = createCircularKeepout({
+    closeOutline: false,
+    sweepDegrees: 270,
+  })
+  const closedPartialArc = createCircularKeepout({
+    closeOutline: true,
+    sweepDegrees: 270,
+  })
+
+  expect(getFilledCircleFromKeepoutOutline(fullCircle)).toEqual({
+    center: { x: 0, y: 0 },
+    radius: 2,
+  })
+  expect(getFilledCircleFromKeepoutOutline(openPartialArc)).toBeNull()
+  expect(getFilledCircleFromKeepoutOutline(closedPartialArc)).toBeNull()
+})

package/tests/test17-support-pcb-keepouts.test.tsx

@@ -14,8 +14,8 @@ test("test17 support pcb keepouts", async () => {
     export const Test17Component = (props: ChipProps) => (
       <chip
         footprint={<footprint>
-            <keepout shape="rect" pcbX="-1.5mm" pcbY="2mm" width="3.2mm" height="1.4mm" />
-    <keepout shape="circle" pcbX="2.5mm" pcbY="-1mm" radius="0.9mm" />
+            <keepout shape="rect" pcbX="-1.5mm" pcbY="2mm" width="3.2mm" height="1.4mm" layers={["top"]} />
+    <keepout shape="circle" pcbX="2.5mm" pcbY="-1mm" radius="0.9mm" layers={["top"]} />
           </footprint>}
         {...props}
       />