@tscircuit/props 0.0.667 → 0.0.669

package/lib/common/fanoutTracePath.ts

@@ -13,6 +13,10 @@ const routePoint = z.discriminatedUnion("route_type", [
     x: coordinate,
     y: coordinate,
     width: positiveDistance,
+    width_interpolation_mode: z
+      .enum(["linear", "quadratic"])
+      .optional()
+      .describe("Interpolate width from this point to the next wire point."),
     layer: layer_ref,
   }),
   z.object({
@@ -31,6 +35,10 @@ const routePoint = z.discriminatedUnion("route_type", [
  * fanout's local PCB frame, in mm: +X right, +Y up, right-handed with +Z
  * above the board. They are points (placement adds translation), not
  * directions. Numeric distances are mm; unit strings are parsed to mm.
+ * A wire point's optional width_interpolation_mode interpolates its width to
+ * the next wire point's width. Omitted means the existing constant-width
+ * behavior; there are no aliases or migration requirements. Interpolation
+ * cannot terminate at a via directly: put a wire point at the via position.
  * Layers are physical board layers, independent of placement. Either endpoint
  * may be a via: the initial layer is its from_layer and the final layer is its
  * to_layer. Placement legality (including allowViaInPad) is checked by core,
@@ -44,7 +52,22 @@ export const fanoutTracePath = z.object({
     .superRefine((route, ctx) => {
       const first = route[0]
       let layer = first?.route_type === "via" ? first.from_layer : first?.layer
-      for (const point of route) {
+      for (const [index, point] of route.entries()) {
+        if (point.route_type === "wire" && point.width_interpolation_mode) {
+          const next = route[index + 1]
+          if (
+            next?.route_type !== "wire" ||
+            next.layer !== point.layer ||
+            (next.x === point.x && next.y === point.y)
+          ) {
+            ctx.addIssue({
+              code: "custom",
+              path: [index, "width_interpolation_mode"],
+              message:
+                "Width interpolation requires a distinct next wire point on the same layer",
+            })
+          }
+        }
         if (
           (point.route_type === "wire" ? point.layer : point.from_layer) !==
           layer

package/lib/common/schematicSize.ts

@@ -1,8 +1,9 @@
 import { distance } from "circuit-json"
 import { z } from "zod"
 
-export const schematicSymbolSize = distance
-  .or(z.enum(["xs", "sm", "default", "md"]))
+export const schematicSymbolSize = z
+  .enum(["xs", "sm", "default", "md"])
+  .or(distance.pipe(z.number().finite()))
   .describe("distance between pin1 and pin2 of the schematic symbol")
 
 export type SchematicSymbolSize = z.input<typeof schematicSymbolSize>

package/lib/components/diode.ts

@@ -11,6 +11,11 @@ import {
 } from "lib/common/schematicOrientation"
 import { schematicPinLabel } from "lib/common/schematicPinLabel"
 
+import {
+  schematicSymbolSize,
+  type SchematicSymbolSize,
+} from "lib/common/schematicSize"
+
 export const diodePins = lrPolarPins
 export type DiodePinLabels = (typeof diodePins)[number]
 export type DiodePinLabelsProp<PinLabel extends string = string> = Partial<
@@ -60,6 +65,7 @@ export const diodeProps = commonComponentProps
     photo: z.boolean().optional(),
     tvs: z.boolean().optional(),
     schOrientation: schematicOrientation.optional(),
+    schSize: schematicSymbolSize.optional(),
     pinLabels: diodePinLabelsProp.optional(),
   })
   .superRefine((data, ctx) => {
@@ -146,6 +152,8 @@ export interface DiodeProps<PinLabel extends string = string>
   photo?: boolean
   tvs?: boolean
   schOrientation?: SchematicOrientation
+  /** Select a compact schematic symbol; omitted, default, and md retain the standard symbol. */
+  schSize?: SchematicSymbolSize
 }
 
 export type InferredDiodeProps = z.input<typeof diodeProps>

package/lib/components/led.ts

@@ -5,6 +5,8 @@ import { createConnectionsProp } from "lib/common/connectionsProp"
 import { diodePinLabelsProp } from "lib/components/diode"
 import { schematicPinLabel } from "lib/common/schematicPinLabel"
 
+import { schematicSymbolSize } from "lib/common/schematicSize"
+
 export type LedPinLabels = (typeof lrPolarPins)[number]
 
 const legacyNumericLedPinLabelsProp = z
@@ -24,6 +26,8 @@ export const ledProps = commonComponentProps.extend({
   wavelength: z.string().optional(),
   schDisplayValue: z.string().optional(),
   schOrientation: schematicOrientation.optional(),
+  /** Select a compact schematic symbol; omitted, default, and md retain the standard symbol. */
+  schSize: schematicSymbolSize.optional(),
   // Numeric keys are accepted for compatibility with legacy generated LED
   // wrappers, then normalized to the canonical pin1/pin2 representation.
   pinLabels: diodePinLabelsProp.or(legacyNumericLedPinLabelsProp).optional(),

package/lib/components/trace.ts

@@ -22,6 +22,15 @@ const baseTraceProps = z.object({
   width: distance.optional().describe("Alias for trace thickness"),
   schematicRouteHints: z.array(point).optional(),
   pcbRouteHints: z.array(route_hint_point).optional(),
+  pcbTeardrops: z.boolean().optional().describe("Enable PCB trace teardrops."),
+  pcbTeardropStart: z
+    .boolean()
+    .optional()
+    .describe("Teardrop at the start (from) of trace"),
+  pcbTeardropEnd: z
+    .boolean()
+    .optional()
+    .describe("Teardrop at the end (to) of trace"),
   pcbPathRelativeTo: z.string().optional(),
   pcbPath: pcbPath.optional(),
   pcbPaths: z.array(pcbPath).optional(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/props",
-  "version": "0.0.667",
+  "version": "0.0.669",
   "description": "Props for tscircuit builtin component types",
   "main": "dist/index.js",
   "type": "module",