@tscircuit/core 0.0.1429 → 0.0.1431

package/dist/index.d.ts

@@ -135849,6 +135849,9 @@ declare class Mosfet extends NormalComponent<typeof mosfetProps> {
         } & {
             channelType: zod.ZodEnum<["n", "p"]>;
             mosfetMode: zod.ZodEnum<["enhancement", "depletion"]>;
+            symbolDrainSide: zod.ZodOptional<zod.ZodEnum<["left", "right", "top", "bottom"]>>;
+            symbolSourceSide: zod.ZodOptional<zod.ZodEnum<["left", "right", "top", "bottom"]>>;
+            symbolGateSide: zod.ZodOptional<zod.ZodEnum<["left", "right", "top", "bottom"]>>;
             connections: zod.ZodOptional<zod.ZodRecord<zod.ZodEnum<["pin1", "drain", "pin2", "source", "pin3", "gate"]>, zod.ZodUnion<[zod.ZodUnion<[zod.ZodString, zod.ZodReadonly<zod.ZodArray<zod.ZodString, "many">>]>, zod.ZodArray<zod.ZodString, "many">]>>>;
         }, "strip", zod.ZodTypeAny, {
             name: string;
@@ -136431,6 +136434,9 @@ declare class Mosfet extends NormalComponent<typeof mosfetProps> {
             schSectionName?: string | undefined;
             schSheetName?: string | undefined;
             connections?: Partial<Record<"pin1" | "pin2" | "source" | "pin3" | "gate" | "drain", string | readonly string[] | string[]>> | undefined;
+            symbolDrainSide?: "left" | "right" | "top" | "bottom" | undefined;
+            symbolSourceSide?: "left" | "right" | "top" | "bottom" | undefined;
+            symbolGateSide?: "left" | "right" | "top" | "bottom" | undefined;
         }, {
             name: string;
             channelType: "n" | "p";
@@ -137014,6 +137020,9 @@ declare class Mosfet extends NormalComponent<typeof mosfetProps> {
             schSectionName?: string | undefined;
             schSheetName?: string | undefined;
             connections?: Partial<Record<"pin1" | "pin2" | "source" | "pin3" | "gate" | "drain", string | readonly string[] | string[]>> | undefined;
+            symbolDrainSide?: "left" | "right" | "top" | "bottom" | undefined;
+            symbolSourceSide?: "left" | "right" | "top" | "bottom" | undefined;
+            symbolGateSide?: "left" | "right" | "top" | "bottom" | undefined;
         }>;
         shouldRenderAsSchematicBox: boolean;
     };

package/dist/index.js

@@ -2546,51 +2546,29 @@ var isRouteOutsideBoard = ({
   );
 };
 
-// lib/utils/obstacles/getObstaclesFromRoute.ts
-var isCloseTo = (a, b) => Math.abs(a - b) < 1e-4;
-var getObstaclesFromRoute = (route, source_trace_id, { viaDiameter = 0.5 } = {}) => {
-  const obstacles = [];
-  for (let i = 0; i < route.length - 1; i++) {
-    const [start, end] = [route[i], route[i + 1]];
-    const prev = i - 1 >= 0 ? route[i - 1] : null;
-    const isHorz = isCloseTo(start.y, end.y);
-    const isVert = isCloseTo(start.x, end.x);
-    if (!isHorz && !isVert) {
-      throw new Error(
-        `getObstaclesFromTrace currently only supports horizontal and vertical traces (not diagonals) Conflicting trace: ${source_trace_id}, start: (${start.x}, ${start.y}), end: (${end.x}, ${end.y})`
-      );
-    }
-    const obstacle = {
-      type: "rect",
-      layers: [start.layer],
-      center: {
-        x: (start.x + end.x) / 2,
-        y: (start.y + end.y) / 2
-      },
-      width: isHorz ? Math.abs(start.x - end.x) : 0.1,
-      // TODO use route width
-      height: isVert ? Math.abs(start.y - end.y) : 0.1,
-      // TODO use route width
-      connectedTo: [source_trace_id]
-    };
-    obstacles.push(obstacle);
-    if (prev && prev.layer === start.layer && start.layer !== end.layer) {
-      const via = {
-        type: "rect",
-        layers: [start.layer, end.layer],
+// lib/utils/obstacles/fillCircleWithRects.ts
+function fillCircleWithRects(circle, options = {}) {
+  const { center, radius } = circle;
+  const { rectHeight = 0.1 } = options;
+  const rects = [];
+  const numSlices = Math.ceil(radius * 2 / rectHeight);
+  for (let i = 0; i < numSlices; i++) {
+    const y = center.y - radius + (i + 0.5) * rectHeight;
+    const dy = y - center.y;
+    const halfWidth = Math.sqrt(radius * radius - dy * dy);
+    if (halfWidth > 0) {
+      rects.push({
         center: {
-          x: start.x,
-          y: start.y
+          x: center.x,
+          y
         },
-        connectedTo: [source_trace_id],
-        width: viaDiameter,
-        height: viaDiameter
-      };
-      obstacles.push(via);
+        width: halfWidth * 2,
+        height: rectHeight
+      });
     }
   }
-  return obstacles;
-};
+  return rects;
+}
 
 // lib/utils/obstacles/fillPolygonWithRects.ts
 function fillPolygonWithRects(polygon, options = {}) {
@@ -2633,29 +2611,88 @@ function fillPolygonWithRects(polygon, options = {}) {
   return rects;
 }
 
-// lib/utils/obstacles/fillCircleWithRects.ts
-function fillCircleWithRects(circle, options = {}) {
-  const { center, radius } = circle;
-  const { rectHeight = 0.1 } = options;
-  const rects = [];
-  const numSlices = Math.ceil(radius * 2 / rectHeight);
-  for (let i = 0; i < numSlices; i++) {
-    const y = center.y - radius + (i + 0.5) * rectHeight;
-    const dy = y - center.y;
-    const halfWidth = Math.sqrt(radius * radius - dy * dy);
-    if (halfWidth > 0) {
-      rects.push({
+// lib/utils/obstacles/getAxisAlignedRectFromPolygon.ts
+var AXIS_ALIGNED_RECT_TOLERANCE_MM = 1e-3;
+var getAxisAlignedRectFromPolygon = (points) => {
+  const isCloseTo2 = (a, b) => Math.abs(a - b) <= AXIS_ALIGNED_RECT_TOLERANCE_MM;
+  const normalizedPoints = points.filter(
+    (point6, index) => index === 0 || !isCloseTo2(point6.x, points[index - 1].x) || !isCloseTo2(point6.y, points[index - 1].y)
+  );
+  if (normalizedPoints.length > 1 && isCloseTo2(normalizedPoints[0].x, normalizedPoints.at(-1).x) && isCloseTo2(normalizedPoints[0].y, normalizedPoints.at(-1).y)) {
+    normalizedPoints.pop();
+  }
+  if (normalizedPoints.length < 4) return null;
+  const minX = Math.min(...normalizedPoints.map((point6) => point6.x));
+  const maxX = Math.max(...normalizedPoints.map((point6) => point6.x));
+  const minY = Math.min(...normalizedPoints.map((point6) => point6.y));
+  const maxY = Math.max(...normalizedPoints.map((point6) => point6.y));
+  const expectedCorners = [
+    { x: minX, y: minY },
+    { x: minX, y: maxY },
+    { x: maxX, y: minY },
+    { x: maxX, y: maxY }
+  ];
+  if (!normalizedPoints.every(
+    (point6) => isCloseTo2(point6.x, minX) || isCloseTo2(point6.x, maxX) || isCloseTo2(point6.y, minY) || isCloseTo2(point6.y, maxY)
+  ) || !expectedCorners.every(
+    (corner) => normalizedPoints.some(
+      (point6) => isCloseTo2(point6.x, corner.x) && isCloseTo2(point6.y, corner.y)
+    )
+  )) {
+    return null;
+  }
+  return {
+    center: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 },
+    width: maxX - minX,
+    height: maxY - minY
+  };
+};
+
+// lib/utils/obstacles/getObstaclesFromRoute.ts
+var isCloseTo = (a, b) => Math.abs(a - b) < 1e-4;
+var getObstaclesFromRoute = (route, source_trace_id, { viaDiameter = 0.5 } = {}) => {
+  const obstacles = [];
+  for (let i = 0; i < route.length - 1; i++) {
+    const [start, end] = [route[i], route[i + 1]];
+    const prev = i - 1 >= 0 ? route[i - 1] : null;
+    const isHorz = isCloseTo(start.y, end.y);
+    const isVert = isCloseTo(start.x, end.x);
+    if (!isHorz && !isVert) {
+      throw new Error(
+        `getObstaclesFromTrace currently only supports horizontal and vertical traces (not diagonals) Conflicting trace: ${source_trace_id}, start: (${start.x}, ${start.y}), end: (${end.x}, ${end.y})`
+      );
+    }
+    const obstacle = {
+      type: "rect",
+      layers: [start.layer],
+      center: {
+        x: (start.x + end.x) / 2,
+        y: (start.y + end.y) / 2
+      },
+      width: isHorz ? Math.abs(start.x - end.x) : 0.1,
+      // TODO use route width
+      height: isVert ? Math.abs(start.y - end.y) : 0.1,
+      // TODO use route width
+      connectedTo: [source_trace_id]
+    };
+    obstacles.push(obstacle);
+    if (prev && prev.layer === start.layer && start.layer !== end.layer) {
+      const via = {
+        type: "rect",
+        layers: [start.layer, end.layer],
         center: {
-          x: center.x,
-          y
+          x: start.x,
+          y: start.y
         },
-        width: halfWidth * 2,
-        height: rectHeight
-      });
+        connectedTo: [source_trace_id],
+        width: viaDiameter,
+        height: viaDiameter
+      };
+      obstacles.push(via);
     }
   }
-  return rects;
-}
+  return obstacles;
+};
 
 // lib/utils/obstacles/getObstaclesFromCircuitJson.ts
 var EVERY_LAYER = ["top", "inner1", "inner2", "bottom"];
@@ -2729,7 +2766,7 @@ var getObstaclesFromCircuitJson = (circuitJson, connMap) => {
           center: rect.center,
           width: rect.width,
           height: rect.height,
-          ccwRotationDegrees: element.ccw_rotation,
+          ccwRotationDegrees: axisAlignedRect ? void 0 : element.ccw_rotation,
           connectedTo: withNetId([element.pcb_smtpad_id])
         });
       } else if (element.shape === "pill" || element.shape === "rotated_pill") {
@@ -2747,24 +2784,31 @@ var getObstaclesFromCircuitJson = (circuitJson, connMap) => {
           connectedTo: withNetId([element.pcb_smtpad_id])
         });
       } else if (element.shape === "polygon") {
-        const xs = element.points.map((point6) => point6.x);
-        const ys = element.points.map((point6) => point6.y);
-        const minX = Math.min(...xs);
-        const maxX = Math.max(...xs);
-        const minY = Math.min(...ys);
-        const maxY = Math.max(...ys);
-        obstacles.push({
-          componentId: pcbComponentId,
-          type: "rect",
-          layers: [element.layer],
-          center: {
-            x: (minX + maxX) / 2,
-            y: (minY + maxY) / 2
-          },
-          width: maxX - minX,
-          height: maxY - minY,
-          connectedTo: withNetId([element.pcb_smtpad_id])
+        const axisAlignedRect = getAxisAlignedRectFromPolygon(element.points);
+        if (axisAlignedRect) {
+          obstacles.push({
+            componentId: pcbComponentId,
+            type: "rect",
+            layers: [element.layer],
+            ...axisAlignedRect,
+            connectedTo: withNetId([element.pcb_smtpad_id])
+          });
+          continue;
+        }
+        const approximatingRects = fillPolygonWithRects(element.points, {
+          rectHeight: 0.1
         });
+        for (const rect of approximatingRects) {
+          obstacles.push({
+            componentId: pcbComponentId,
+            type: "rect",
+            layers: [element.layer],
+            center: rect.center,
+            width: rect.width,
+            height: rect.height,
+            connectedTo: withNetId([element.pcb_smtpad_id])
+          });
+        }
       }
     } else if (element.type === "pcb_keepout") {
       if (element.shape === "circle") {
@@ -22352,7 +22396,7 @@ function Group_getRoutingPhasePlans(group) {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.1428",
+  version: "0.0.1430",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -22401,7 +22445,7 @@ var package_default = {
     "@tscircuit/math-utils": "^0.0.36",
     "@tscircuit/miniflex": "^0.0.4",
     "@tscircuit/ngspice-spice-engine": "^0.0.19",
-    "@tscircuit/props": "^0.0.571",
+    "@tscircuit/props": "^0.0.574",
     "@tscircuit/schematic-match-adapt": "^0.0.18",
     "@tscircuit/schematic-trace-solver": "^0.0.96",
     "@tscircuit/solver-utils": "^0.0.16",
@@ -22436,7 +22480,7 @@ var package_default = {
     poppygl: "^0.0.25",
     react: "^19.1.0",
     "react-dom": "^19.1.0",
-    "schematic-symbols": "^0.0.231",
+    "schematic-symbols": "^0.0.232",
     spicets: "^0.0.2",
     spicey: "^0.0.14",
     "stack-svgs": "^0.0.1",
@@ -31741,14 +31785,72 @@ var Crystal = class extends NormalComponent3 {
 
 // lib/components/normal-components/Mosfet.ts
 import { mosfetProps } from "@tscircuit/props";
+
+// lib/components/normal-components/get-mosfet-schematic-symbol-name.ts
+var possibleOrientations = [
+  { gate: "left", drain: "top", source: "bottom" },
+  { gate: "left", drain: "bottom", source: "top" },
+  { gate: "right", drain: "top", source: "bottom" },
+  { gate: "right", drain: "bottom", source: "top" },
+  { gate: "top", drain: "left", source: "right" },
+  { gate: "top", drain: "right", source: "left" },
+  { gate: "bottom", drain: "left", source: "right" },
+  { gate: "bottom", drain: "right", source: "left" }
+];
+var getBaselineOrientation = (rotation4) => {
+  const normalizedRotation = (rotation4 % 360 + 360) % 360;
+  if (normalizedRotation % 90 !== 0) {
+    throw new Error(
+      `Schematic rotation ${rotation4} is not supported for Mosfet`
+    );
+  }
+  return [
+    { gate: "left", drain: "top", source: "bottom" },
+    { gate: "top", drain: "right", source: "left" },
+    { gate: "right", drain: "bottom", source: "top" },
+    { gate: "bottom", drain: "left", source: "right" }
+  ][normalizedRotation / 90];
+};
+var getRequestedOrientation = (props) => {
+  const requestedSides = {
+    drain: props.symbolDrainSide,
+    source: props.symbolSourceSide,
+    gate: props.symbolGateSide
+  };
+  const baseline = getBaselineOrientation(Number(props.schRotation ?? 0));
+  const matchingOrientations = possibleOrientations.filter(
+    (orientation) => Object.keys(requestedSides).every(
+      (portName) => requestedSides[portName] === void 0 || requestedSides[portName] === orientation[portName]
+    )
+  );
+  if (matchingOrientations.length === 0) {
+    const requestedDescription = Object.entries(requestedSides).filter(([, side]) => side !== void 0).map(([portName, side]) => `${portName}=${side}`).join(", ");
+    throw new Error(
+      `Invalid MOSFET symbol port side combination (${requestedDescription}). The gate must be perpendicular to the drain and source, and the drain and source must be opposite.`
+    );
+  }
+  return matchingOrientations.sort((a, b) => {
+    const score = (orientation) => Object.keys(baseline).filter(
+      (portName) => orientation[portName] !== baseline[portName]
+    ).length;
+    return score(a) - score(b);
+  })[0];
+};
+var getMosfetSchematicSymbolName = (props) => {
+  const mosfetMode = props.mosfetMode === "depletion" ? "d" : "e";
+  const baseSymbolName = `${props.channelType}_channel_${mosfetMode}_mosfet_transistor`;
+  const hasSymbolSideProps = props.symbolDrainSide !== void 0 || props.symbolSourceSide !== void 0 || props.symbolGateSide !== void 0;
+  if (!hasSymbolSideProps) return baseSymbolName;
+  const { gate, drain } = getRequestedOrientation(props);
+  return `${baseSymbolName}_gate_${gate}_drain_${drain}`;
+};
+
+// lib/components/normal-components/Mosfet.ts
 var Mosfet = class extends NormalComponent3 {
   get config() {
-    const mosfetMode = this.props.mosfetMode === "depletion" ? "d" : "e";
-    const channelType = this.props.channelType;
-    const baseSymbolName = `${channelType}_channel_${mosfetMode}_mosfet_transistor`;
     return {
       componentName: "Mosfet",
-      schematicSymbolName: this.props.symbolName ?? baseSymbolName,
+      schematicSymbolName: this.props.symbolName ?? getMosfetSchematicSymbolName(this.props),
       zodProps: mosfetProps,
       shouldRenderAsSchematicBox: false
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.1429",
+  "version": "0.0.1431",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -50,7 +50,7 @@
     "@tscircuit/math-utils": "^0.0.36",
     "@tscircuit/miniflex": "^0.0.4",
     "@tscircuit/ngspice-spice-engine": "^0.0.19",
-    "@tscircuit/props": "^0.0.571",
+    "@tscircuit/props": "^0.0.574",
     "@tscircuit/schematic-match-adapt": "^0.0.18",
     "@tscircuit/schematic-trace-solver": "^0.0.96",
     "@tscircuit/solver-utils": "^0.0.16",
@@ -85,7 +85,7 @@
     "poppygl": "^0.0.25",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
-    "schematic-symbols": "^0.0.231",
+    "schematic-symbols": "^0.0.232",
     "spicets": "^0.0.2",
     "spicey": "^0.0.14",
     "stack-svgs": "^0.0.1",