@tscircuit/props 0.0.63 → 0.0.64

package/dist/index.js

@@ -23,6 +23,11 @@ __export(lib_exports, {
   baseGroupProps: () => baseGroupProps,
   boardProps: () => boardProps,
   bugProps: () => bugProps,
+  cadModelBase: () => cadModelBase,
+  cadModelJscad: () => cadModelJscad,
+  cadModelObj: () => cadModelObj,
+  cadModelProp: () => cadModelProp,
+  cadModelStl: () => cadModelStl,
   capacitorPins: () => capacitorPins,
   capacitorProps: () => capacitorProps,
   chipProps: () => chipProps,
@@ -69,6 +74,7 @@ __export(lib_exports, {
   rectSmtPadProps: () => rectSmtPadProps,
   resistorPins: () => resistorPins,
   resistorProps: () => resistorProps,
+  rotationPoint3: () => rotationPoint3,
   routeHintPointProps: () => routeHintPointProps,
   schematicBoxProps: () => schematicBoxProps,
   schematicLineProps: () => schematicLineProps,
@@ -90,8 +96,8 @@ __export(lib_exports, {
   viaProps: () => viaProps
 });
 module.exports = __toCommonJS(lib_exports);
-var import_soup11 = require("@tscircuit/soup");
-var import_zod22 = require("zod");
+var import_soup13 = require("@tscircuit/soup");
+var import_zod23 = require("zod");
 
 // lib/typecheck.ts
 var expectTypesMatch = (shouldBe) => {
@@ -186,6 +192,7 @@ var supplierProps = import_zod6.z.object({
 });
 expectTypesMatch(true);
 var commonComponentProps = commonLayoutProps.merge(supplierProps).extend({
+  key: import_zod6.z.any().optional(),
   name: import_zod6.z.string(),
   cadModel: cadModelProp.optional(),
   children: import_zod6.z.any().optional(),
@@ -272,7 +279,8 @@ var boardProps = import_zod10.z.object({
   pcbY: import_soup5.distance.optional().default(0),
   layout: import_zod10.z.any().optional(),
   routingDisabled: import_zod10.z.boolean().optional(),
-  children: import_zod10.z.any()
+  children: import_zod10.z.any(),
+  defaultTraceWidth: import_soup5.distance.optional()
 });
 expectTypesMatch(true);
 
@@ -334,6 +342,7 @@ expectTypesMatch(true);
 
 // lib/components/group.ts
 var import_zod15 = require("zod");
+var import_soup10 = require("@tscircuit/soup");
 var baseGroupProps = commonLayoutProps.extend({
   name: import_zod15.z.string().optional(),
   children: import_zod15.z.any().optional()
@@ -341,7 +350,8 @@ var baseGroupProps = commonLayoutProps.extend({
 var subcircuitGroupProps = baseGroupProps.extend({
   subcircuit: import_zod15.z.literal(true),
   layout: import_zod15.z.custom((v) => true).optional(),
-  routingDisabled: import_zod15.z.boolean().optional()
+  routingDisabled: import_zod15.z.boolean().optional(),
+  defaultTraceWidth: import_soup10.length.optional()
 });
 var groupProps = import_zod15.z.union([baseGroupProps, subcircuitGroupProps]);
 expectTypesMatch(true);
@@ -366,13 +376,13 @@ expectTypesMatch(true);
 
 // lib/common/distance.ts
 var import_zod18 = require("zod");
-var import_soup10 = require("@tscircuit/soup");
+var import_soup11 = require("@tscircuit/soup");
 
 // lib/components/constraint.ts
 var import_zod19 = require("zod");
 var pcbXDistConstraintProps = import_zod19.z.object({
   pcb: import_zod19.z.literal(true).optional(),
-  xDist: import_soup10.distance,
+  xDist: import_soup11.distance,
   left: import_zod19.z.string(),
   right: import_zod19.z.string(),
   edgeToEdge: import_zod19.z.literal(true).optional(),
@@ -383,7 +393,7 @@ expectTypesMatch(
 );
 var pcbYDistConstraintProps = import_zod19.z.object({
   pcb: import_zod19.z.literal(true).optional(),
-  yDist: import_soup10.distance,
+  yDist: import_soup11.distance,
   top: import_zod19.z.string(),
   bottom: import_zod19.z.string(),
   edgeToEdge: import_zod19.z.literal(true).optional(),
@@ -420,14 +430,14 @@ expectTypesMatch(true);
 var import_zod20 = require("zod");
 var rectSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   shape: import_zod20.z.literal("rect"),
-  width: import_soup10.distance,
-  height: import_soup10.distance,
+  width: import_soup11.distance,
+  height: import_soup11.distance,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
 var circleSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   shape: import_zod20.z.literal("circle"),
-  radius: import_soup10.distance,
+  radius: import_soup11.distance,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
@@ -438,8 +448,8 @@ expectTypesMatch(true);
 var import_zod21 = require("zod");
 var holeProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
   name: import_zod21.z.string().optional(),
-  diameter: import_soup10.distance.optional(),
-  radius: import_soup10.distance.optional()
+  diameter: import_soup11.distance.optional(),
+  radius: import_soup11.distance.optional()
 }).transform((d) => ({
   ...d,
   diameter: d.diameter ?? 2 * d.radius,
@@ -447,181 +457,192 @@ var holeProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
 }));
 expectTypesMatch(true);
 
+// lib/components/trace.ts
+var import_zod22 = require("zod");
+var import_soup12 = require("@tscircuit/soup");
+var portRef = import_zod22.z.union([
+  import_zod22.z.string(),
+  import_zod22.z.custom(
+    (v) => Boolean(v.getPortSelector)
+  )
+]);
+var baseTraceProps = import_zod22.z.object({
+  key: import_zod22.z.string().optional(),
+  path: import_zod22.z.array(portRef),
+  thickness: import_soup12.distance.optional(),
+  schematicRouteHints: import_zod22.z.array(point).optional(),
+  pcbRouteHints: import_zod22.z.array(import_soup12.route_hint_point).optional()
+});
+var traceProps = import_zod22.z.union([
+  baseTraceProps.extend({
+    path: import_zod22.z.array(portRef)
+  }),
+  baseTraceProps.extend({
+    from: portRef,
+    to: portRef
+  })
+]);
+
 // lib/index.ts
 var inductorProps = commonComponentProps.extend({
-  inductance: import_soup11.inductance
+  inductance: import_soup13.inductance
 });
 var inductorPins = lrPins;
 var diodeProps = commonComponentProps.extend({});
 var diodePins = lrPolarPins;
 var ledProps = commonComponentProps.extend({
-  color: import_zod22.z.string().optional()
+  color: import_zod23.z.string().optional()
 });
 var ledPins = lrPolarPins;
 var switchProps = commonComponentProps.extend({
-  ftype: import_zod22.z.literal("switch"),
-  switchType: import_zod22.z.enum(["spst"]).default("spst"),
-  isNormallyClosed: import_zod22.z.boolean().default(false)
+  ftype: import_zod23.z.literal("switch"),
+  switchType: import_zod23.z.enum(["spst"]).default("spst"),
+  isNormallyClosed: import_zod23.z.boolean().default(false)
 });
-var distanceOrMultiplier2 = import_soup11.distance.or(import_zod22.z.enum(["2x", "3x", "4x"]));
+var distanceOrMultiplier2 = import_soup13.distance.or(import_zod23.z.enum(["2x", "3x", "4x"]));
 var viaProps = commonLayoutProps.extend({
-  fromLayer: import_soup11.layer_ref,
-  toLayer: import_soup11.layer_ref,
-  holeDiameter: import_soup11.distance,
-  outerDiameter: import_soup11.distance
+  fromLayer: import_soup13.layer_ref,
+  toLayer: import_soup13.layer_ref,
+  holeDiameter: import_soup13.distance,
+  outerDiameter: import_soup13.distance
 });
 var netAliasProps = commonLayoutProps.extend({
-  net: import_zod22.z.string().optional()
+  net: import_zod23.z.string().optional()
 });
-var portRef = import_zod22.z.union([
-  import_zod22.z.string(),
-  import_zod22.z.custom(
-    (v) => Boolean(v.getPortSelector)
-  )
-]);
-var traceProps = import_zod22.z.object({
-  path: import_zod22.z.array(portRef),
-  thickness: import_soup11.distance.optional(),
-  schematicRouteHints: import_zod22.z.array(import_soup11.point).optional(),
-  pcbRouteHints: import_zod22.z.array(import_soup11.route_hint_point).optional()
-}).or(
-  import_zod22.z.object({
-    from: portRef,
-    to: portRef,
-    thickness: import_soup11.distance.optional(),
-    schematicRouteHints: import_zod22.z.array(import_soup11.point).optional(),
-    pcbRouteHints: import_zod22.z.array(import_soup11.route_hint_point).optional()
-  })
-);
-var platedHoleProps = import_zod22.z.union([
+var platedHoleProps = import_zod23.z.union([
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: import_zod22.z.string().optional(),
-    shape: import_zod22.z.literal("circle"),
-    holeDiameter: import_soup11.distance,
-    outerDiameter: import_soup11.distance,
+    name: import_zod23.z.string().optional(),
+    shape: import_zod23.z.literal("circle"),
+    holeDiameter: import_soup13.distance,
+    outerDiameter: import_soup13.distance,
     portHints: portHints.optional()
   }),
   pcbLayoutProps.omit({ pcbRotation: true, layer: true }).extend({
-    name: import_zod22.z.string().optional(),
-    shape: import_zod22.z.literal("oval"),
-    outerWidth: import_soup11.distance,
-    outerHeight: import_soup11.distance,
-    innerWidth: import_soup11.distance,
-    innerHeight: import_soup11.distance,
+    name: import_zod23.z.string().optional(),
+    shape: import_zod23.z.literal("oval"),
+    outerWidth: import_soup13.distance,
+    outerHeight: import_soup13.distance,
+    innerWidth: import_soup13.distance,
+    innerHeight: import_soup13.distance,
     portHints: portHints.optional()
   })
 ]);
-var pcbKeepoutProps = import_zod22.z.union([
+var pcbKeepoutProps = import_zod23.z.union([
   pcbLayoutProps.omit({ pcbRotation: true }).extend({
-    shape: import_zod22.z.literal("circle"),
-    radius: import_soup11.distance
+    shape: import_zod23.z.literal("circle"),
+    radius: import_soup13.distance
   }),
   pcbLayoutProps.extend({
-    shape: import_zod22.z.literal("rect"),
-    width: import_soup11.distance,
-    height: import_soup11.distance
+    shape: import_zod23.z.literal("rect"),
+    width: import_soup13.distance,
+    height: import_soup13.distance
   })
 ]);
-var schematicBoxProps = import_zod22.z.object({
-  schX: import_soup11.distance,
-  schY: import_soup11.distance,
-  width: import_soup11.distance,
-  height: import_soup11.distance
-});
-var schematicTextProps = import_zod22.z.object({
-  schX: import_soup11.distance,
-  schY: import_soup11.distance,
-  text: import_zod22.z.string()
-});
-var schematicLineProps = import_zod22.z.object({
-  x1: import_soup11.distance,
-  y1: import_soup11.distance,
-  x2: import_soup11.distance,
-  y2: import_soup11.distance
-});
-var schematicPathProps = import_zod22.z.object({
-  points: import_zod22.z.array(import_soup11.point),
-  isFilled: import_zod22.z.boolean().optional().default(false),
-  fillColor: import_zod22.z.enum(["red", "blue"]).optional()
-});
-var footprintProps = import_zod22.z.object({});
+var schematicBoxProps = import_zod23.z.object({
+  schX: import_soup13.distance,
+  schY: import_soup13.distance,
+  width: import_soup13.distance,
+  height: import_soup13.distance
+});
+var schematicTextProps = import_zod23.z.object({
+  schX: import_soup13.distance,
+  schY: import_soup13.distance,
+  text: import_zod23.z.string()
+});
+var schematicLineProps = import_zod23.z.object({
+  x1: import_soup13.distance,
+  y1: import_soup13.distance,
+  x2: import_soup13.distance,
+  y2: import_soup13.distance
+});
+var schematicPathProps = import_zod23.z.object({
+  points: import_zod23.z.array(import_soup13.point),
+  isFilled: import_zod23.z.boolean().optional().default(false),
+  fillColor: import_zod23.z.enum(["red", "blue"]).optional()
+});
+var footprintProps = import_zod23.z.object({});
 var componentProps = commonComponentProps;
 var powerSourceProps = commonComponentProps.extend({
-  voltage: import_soup11.voltage
+  voltage: import_soup13.voltage
 });
 var portProps = commonLayoutProps.extend({
-  name: import_zod22.z.string(),
-  pinNumber: import_zod22.z.number().optional(),
-  aliases: import_zod22.z.array(import_zod22.z.string()).optional(),
+  name: import_zod23.z.string(),
+  pinNumber: import_zod23.z.number().optional(),
+  aliases: import_zod23.z.array(import_zod23.z.string()).optional(),
   direction
 });
 var silkscreenTextProps = pcbLayoutProps.extend({
-  text: import_zod22.z.string(),
-  anchorAlignment: import_zod22.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: import_zod22.z.enum(["tscircuit2024"]).optional(),
-  fontSize: import_soup11.length.optional()
+  text: import_zod23.z.string(),
+  anchorAlignment: import_zod23.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: import_zod23.z.enum(["tscircuit2024"]).optional(),
+  fontSize: import_soup13.length.optional()
 });
 var silkscreenPathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: import_zod22.z.array(import_soup11.route_hint_point),
-  strokeWidth: import_soup11.length.optional()
+  route: import_zod23.z.array(import_soup13.route_hint_point),
+  strokeWidth: import_soup13.length.optional()
 });
 var silkscreenLineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  strokeWidth: import_soup11.distance,
-  x1: import_soup11.distance,
-  y1: import_soup11.distance,
-  x2: import_soup11.distance,
-  y2: import_soup11.distance
+  strokeWidth: import_soup13.distance,
+  x1: import_soup13.distance,
+  y1: import_soup13.distance,
+  x2: import_soup13.distance,
+  y2: import_soup13.distance
 });
 var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: import_zod22.z.boolean().optional(),
-  isOutline: import_zod22.z.boolean().optional(),
-  strokeWidth: import_soup11.distance.optional(),
-  width: import_soup11.distance,
-  height: import_soup11.distance
+  isFilled: import_zod23.z.boolean().optional(),
+  isOutline: import_zod23.z.boolean().optional(),
+  strokeWidth: import_soup13.distance.optional(),
+  width: import_soup13.distance,
+  height: import_soup13.distance
 });
 var silkscreenCircleProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: import_zod22.z.boolean().optional(),
-  isOutline: import_zod22.z.boolean().optional(),
-  strokeWidth: import_soup11.distance.optional(),
-  radius: import_soup11.distance
-});
-var routeHintPointProps = import_zod22.z.object({
-  x: import_soup11.distance,
-  y: import_soup11.distance,
-  via: import_zod22.z.boolean().optional(),
-  toLayer: import_soup11.layer_ref.optional()
-});
-var traceHintProps = import_zod22.z.object({
-  for: import_zod22.z.string().optional().describe(
+  isFilled: import_zod23.z.boolean().optional(),
+  isOutline: import_zod23.z.boolean().optional(),
+  strokeWidth: import_soup13.distance.optional(),
+  radius: import_soup13.distance
+});
+var routeHintPointProps = import_zod23.z.object({
+  x: import_soup13.distance,
+  y: import_soup13.distance,
+  via: import_zod23.z.boolean().optional(),
+  toLayer: import_soup13.layer_ref.optional()
+});
+var traceHintProps = import_zod23.z.object({
+  for: import_zod23.z.string().optional().describe(
     "Selector for the port you're targeting, not required if you're inside a trace"
   ),
-  order: import_zod22.z.number().optional(),
-  offset: import_soup11.route_hint_point.or(routeHintPointProps).optional(),
-  offsets: import_zod22.z.array(import_soup11.route_hint_point).or(import_zod22.z.array(routeHintPointProps)).optional(),
-  traceWidth: import_zod22.z.number().optional()
+  order: import_zod23.z.number().optional(),
+  offset: import_soup13.route_hint_point.or(routeHintPointProps).optional(),
+  offsets: import_zod23.z.array(import_soup13.route_hint_point).or(import_zod23.z.array(routeHintPointProps)).optional(),
+  traceWidth: import_zod23.z.number().optional()
 });
-var pcbTraceProps = import_zod22.z.object({
-  layer: import_zod22.z.string().optional(),
-  thickness: import_soup11.distance.optional(),
-  route: import_zod22.z.array(import_soup11.route_hint_point)
+var pcbTraceProps = import_zod23.z.object({
+  layer: import_zod23.z.string().optional(),
+  thickness: import_soup13.distance.optional(),
+  route: import_zod23.z.array(import_soup13.route_hint_point)
 });
 var fabricationNoteTextProps = pcbLayoutProps.extend({
-  text: import_zod22.z.string(),
-  anchorAlignment: import_zod22.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: import_zod22.z.enum(["tscircuit2024"]).optional(),
-  fontSize: import_soup11.length.optional(),
-  color: import_zod22.z.string().optional()
+  text: import_zod23.z.string(),
+  anchorAlignment: import_zod23.z.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: import_zod23.z.enum(["tscircuit2024"]).optional(),
+  fontSize: import_soup13.length.optional(),
+  color: import_zod23.z.string().optional()
 });
 var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: import_zod22.z.array(import_soup11.route_hint_point),
-  strokeWidth: import_soup11.length.optional(),
-  color: import_zod22.z.string().optional()
+  route: import_zod23.z.array(import_soup13.route_hint_point),
+  strokeWidth: import_soup13.length.optional(),
+  color: import_zod23.z.string().optional()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   baseGroupProps,
   boardProps,
   bugProps,
+  cadModelBase,
+  cadModelJscad,
+  cadModelObj,
+  cadModelProp,
+  cadModelStl,
   capacitorPins,
   capacitorProps,
   chipProps,
@@ -668,6 +689,7 @@ var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcb
   rectSmtPadProps,
   resistorPins,
   resistorProps,
+  rotationPoint3,
   routeHintPointProps,
   schematicBoxProps,
   schematicLineProps,