@tscircuit/props 0.0.113 → 0.0.115

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   route_hint_point as route_hint_point4,
   voltage
 } from "circuit-json";
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 
 // lib/typecheck.ts
 var expectTypesMatch = (shouldBe) => {
@@ -341,33 +341,43 @@ var crystalProps = commonComponentProps.extend({
 var crystalPins = lrPins;
 expectTypesMatch(true);
 
-// lib/components/capacitor.ts
-import { capacitance as capacitance2 } from "circuit-json";
+// lib/components/resonator.ts
+import { frequency as frequency2, capacitance as capacitance2 } from "circuit-json";
 import { z as z17 } from "zod";
+var resonatorProps = commonComponentProps.extend({
+  frequency: frequency2,
+  loadCapacitance: capacitance2,
+  pinVariant: z17.literal("3pin")
+});
+expectTypesMatch(true);
+
+// lib/components/capacitor.ts
+import { capacitance as capacitance3 } from "circuit-json";
+import { z as z18 } from "zod";
 var capacitorProps = commonComponentProps.extend({
-  capacitance: capacitance2,
-  polarized: z17.boolean().optional().default(false),
-  decouplingFor: z17.string().optional(),
-  decouplingTo: z17.string().optional(),
-  bypassFor: z17.string().optional(),
-  bypassTo: z17.string().optional()
+  capacitance: capacitance3,
+  polarized: z18.boolean().optional().default(false),
+  decouplingFor: z18.string().optional(),
+  decouplingTo: z18.string().optional(),
+  bypassFor: z18.string().optional(),
+  bypassTo: z18.string().optional()
 });
 var capacitorPins = lrPolarPins;
 expectTypesMatch(true);
 
 // lib/components/net.ts
-import { z as z18 } from "zod";
-var netProps = z18.object({
-  name: z18.string()
+import { z as z19 } from "zod";
+var netProps = z19.object({
+  name: z19.string()
 });
 expectTypesMatch(true);
 
 // lib/components/constrainedlayout.ts
-import { z as z19 } from "zod";
-var constrainedLayoutProps = z19.object({
-  name: z19.string().optional(),
-  pcbOnly: z19.boolean().optional(),
-  schOnly: z19.boolean().optional()
+import { z as z20 } from "zod";
+var constrainedLayoutProps = z20.object({
+  name: z20.string().optional(),
+  pcbOnly: z20.boolean().optional(),
+  schOnly: z20.boolean().optional()
 });
 expectTypesMatch(true);
 
@@ -376,46 +386,46 @@ import "zod";
 import { distance as distance9, length as length2 } from "circuit-json";
 
 // lib/components/constraint.ts
-import { z as z21 } from "zod";
-var pcbXDistConstraintProps = z21.object({
-  pcb: z21.literal(true).optional(),
+import { z as z22 } from "zod";
+var pcbXDistConstraintProps = z22.object({
+  pcb: z22.literal(true).optional(),
   xDist: distance9,
-  left: z21.string(),
-  right: z21.string(),
-  edgeToEdge: z21.literal(true).optional(),
-  centerToCenter: z21.literal(true).optional()
+  left: z22.string(),
+  right: z22.string(),
+  edgeToEdge: z22.literal(true).optional(),
+  centerToCenter: z22.literal(true).optional()
 });
 expectTypesMatch(
   true
 );
-var pcbYDistConstraintProps = z21.object({
-  pcb: z21.literal(true).optional(),
+var pcbYDistConstraintProps = z22.object({
+  pcb: z22.literal(true).optional(),
   yDist: distance9,
-  top: z21.string(),
-  bottom: z21.string(),
-  edgeToEdge: z21.literal(true).optional(),
-  centerToCenter: z21.literal(true).optional()
+  top: z22.string(),
+  bottom: z22.string(),
+  edgeToEdge: z22.literal(true).optional(),
+  centerToCenter: z22.literal(true).optional()
 });
 expectTypesMatch(
   true
 );
-var pcbSameYConstraintProps = z21.object({
-  pcb: z21.literal(true).optional(),
-  sameY: z21.literal(true).optional(),
-  for: z21.array(z21.string())
+var pcbSameYConstraintProps = z22.object({
+  pcb: z22.literal(true).optional(),
+  sameY: z22.literal(true).optional(),
+  for: z22.array(z22.string())
 });
 expectTypesMatch(
   true
 );
-var pcbSameXConstraintProps = z21.object({
-  pcb: z21.literal(true).optional(),
-  sameX: z21.literal(true).optional(),
-  for: z21.array(z21.string())
+var pcbSameXConstraintProps = z22.object({
+  pcb: z22.literal(true).optional(),
+  sameX: z22.literal(true).optional(),
+  for: z22.array(z22.string())
 });
 expectTypesMatch(
   true
 );
-var constraintProps = z21.union([
+var constraintProps = z22.union([
   pcbXDistConstraintProps,
   pcbYDistConstraintProps,
   pcbSameYConstraintProps,
@@ -424,29 +434,29 @@ var constraintProps = z21.union([
 expectTypesMatch(true);
 
 // lib/components/smtpad.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var rectSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z22.literal("rect"),
+  shape: z23.literal("rect"),
   width: distance9,
   height: distance9,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
 var rotatedRectSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z22.literal("rotated_rect"),
+  shape: z23.literal("rotated_rect"),
   width: distance9,
   height: distance9,
-  ccwRotation: z22.number(),
+  ccwRotation: z23.number(),
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
 var circleSmtPadProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z22.literal("circle"),
+  shape: z23.literal("circle"),
   radius: distance9,
   portHints: portHints.optional()
 });
 expectTypesMatch(true);
-var smtPadProps = z22.union([
+var smtPadProps = z23.union([
   circleSmtPadProps,
   rectSmtPadProps,
   rotatedRectSmtPadProps
@@ -454,28 +464,28 @@ var smtPadProps = z22.union([
 expectTypesMatch(true);
 
 // lib/components/solderpaste.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var rectSolderPasteProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z23.literal("rect"),
+  shape: z24.literal("rect"),
   width: distance9,
   height: distance9
 });
 expectTypesMatch(true);
 var circleSolderPasteProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  shape: z23.literal("circle"),
+  shape: z24.literal("circle"),
   radius: distance9
 });
 expectTypesMatch(true);
-var solderPasteProps = z23.union([
+var solderPasteProps = z24.union([
   circleSolderPasteProps,
   rectSolderPasteProps
 ]);
 expectTypesMatch(true);
 
 // lib/components/hole.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var holeProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  name: z24.string().optional(),
+  name: z25.string().optional(),
   diameter: distance9.optional(),
   radius: distance9.optional()
 }).transform((d) => ({
@@ -487,23 +497,23 @@ expectTypesMatch(true);
 
 // lib/components/trace.ts
 import { distance as distance10, route_hint_point } from "circuit-json";
-import { z as z25 } from "zod";
-var portRef = z25.union([
-  z25.string(),
-  z25.custom(
+import { z as z26 } from "zod";
+var portRef = z26.union([
+  z26.string(),
+  z26.custom(
     (v) => Boolean(v.getPortSelector)
   )
 ]);
-var baseTraceProps = z25.object({
-  key: z25.string().optional(),
+var baseTraceProps = z26.object({
+  key: z26.string().optional(),
   thickness: distance10.optional(),
-  schematicRouteHints: z25.array(point).optional(),
-  pcbRouteHints: z25.array(route_hint_point).optional(),
-  schDisplayLabel: z25.string().optional()
+  schematicRouteHints: z26.array(point).optional(),
+  pcbRouteHints: z26.array(route_hint_point).optional(),
+  schDisplayLabel: z26.string().optional()
 });
-var traceProps = z25.union([
+var traceProps = z26.union([
   baseTraceProps.extend({
-    path: z25.array(portRef)
+    path: z26.array(portRef)
   }),
   baseTraceProps.extend({
     from: portRef,
@@ -513,15 +523,15 @@ var traceProps = z25.union([
 
 // lib/components/footprint.ts
 import { layer_ref as layer_ref2 } from "circuit-json";
-import { z as z26 } from "zod";
-var footprintProps = z26.object({
+import { z as z27 } from "zod";
+var footprintProps = z27.object({
   originalLayer: layer_ref2.default("top").optional()
 });
 expectTypesMatch(true);
 
 // lib/components/battery.ts
-import { z as z27 } from "zod";
-var capacity = z27.number().or(z27.string().endsWith("mAh")).transform((v) => {
+import { z as z28 } from "zod";
+var capacity = z28.number().or(z28.string().endsWith("mAh")).transform((v) => {
   if (typeof v === "string") {
     const valString = v.replace("mAh", "");
     const num = Number.parseFloat(valString);
@@ -540,29 +550,29 @@ expectTypesMatch(true);
 
 // lib/components/pin-header.ts
 import { distance as distance11 } from "circuit-json";
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var pinHeaderProps = commonComponentProps.extend({
-  pinCount: z28.number(),
+  pinCount: z29.number(),
   pitch: distance11.optional(),
-  gender: z28.enum(["male", "female"]).optional().default("male"),
-  showSilkscreenPinLabels: z28.boolean().optional(),
-  doubleRow: z28.boolean().optional(),
+  gender: z29.enum(["male", "female"]).optional().default("male"),
+  showSilkscreenPinLabels: z29.boolean().optional(),
+  doubleRow: z29.boolean().optional(),
   holeDiameter: distance11.optional(),
   platedDiameter: distance11.optional(),
-  pinLabels: z28.array(z28.string()).optional(),
-  facingDirection: z28.enum(["left", "right"]).optional()
+  pinLabels: z29.array(z29.string()).optional(),
+  facingDirection: z29.enum(["left", "right"]).optional()
 });
 expectTypesMatch(true);
 
 // lib/components/netalias.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 import { rotation as rotation2 } from "circuit-json";
-var netAliasProps = z29.object({
-  net: z29.string().optional(),
+var netAliasProps = z30.object({
+  net: z30.string().optional(),
   schX: distance9.optional(),
   schY: distance9.optional(),
   schRotation: rotation2.optional(),
-  anchorSide: z29.enum(["left", "up", "right", "down"]).optional()
+  anchorSide: z30.enum(["left", "up", "right", "down"]).optional()
 });
 expectTypesMatch(true);
 
@@ -575,37 +585,38 @@ var subcircuitProps = subcircuitGroupProps;
 expectTypesMatch(true);
 
 // lib/manual-edits/manual-edit-events/base_manual_edit_event.ts
-import { z as z31 } from "zod";
-var base_manual_edit_event = z31.object({
-  edit_event_id: z31.string(),
-  in_progress: z31.boolean().optional(),
-  created_at: z31.number()
+import { z as z32 } from "zod";
+var base_manual_edit_event = z32.object({
+  edit_event_id: z32.string(),
+  in_progress: z32.boolean().optional(),
+  created_at: z32.number()
 });
 expectTypesMatch(
   true
 );
 
 // lib/manual-edits/manual-edit-events/edit_pcb_component_location_event.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var edit_pcb_component_location_event = base_manual_edit_event.extend({
-  pcb_edit_event_type: z32.literal("edit_component_location").describe("deprecated"),
-  edit_event_type: z32.literal("edit_pcb_component_location"),
-  pcb_component_id: z32.string(),
-  original_center: z32.object({ x: z32.number(), y: z32.number() }),
-  new_center: z32.object({ x: z32.number(), y: z32.number() })
+  pcb_edit_event_type: z33.literal("edit_component_location").describe("deprecated"),
+  edit_event_type: z33.literal("edit_pcb_component_location"),
+  pcb_component_id: z33.string(),
+  original_center: z33.object({ x: z33.number(), y: z33.number() }),
+  new_center: z33.object({ x: z33.number(), y: z33.number() })
 });
 var edit_component_location_event = edit_pcb_component_location_event;
 expectTypesMatch(true);
 
 // lib/manual-edits/manual-edit-events/edit_trace_hint_event.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 import "circuit-json";
 var edit_trace_hint_event = base_manual_edit_event.extend({
-  pcb_edit_event_type: z33.literal("edit_trace_hint"),
-  pcb_port_id: z33.string(),
-  pcb_trace_hint_id: z33.string().optional(),
-  route: z33.array(
-    z33.object({ x: z33.number(), y: z33.number(), via: z33.boolean().optional() })
+  pcb_edit_event_type: z34.literal("edit_trace_hint").describe("deprecated"),
+  edit_event_type: z34.literal("edit_pcb_trace_hint").optional(),
+  pcb_port_id: z34.string(),
+  pcb_trace_hint_id: z34.string().optional(),
+  route: z34.array(
+    z34.object({ x: z34.number(), y: z34.number(), via: z34.boolean().optional() })
   )
 });
 expectTypesMatch(
@@ -613,18 +624,18 @@ expectTypesMatch(
 );
 
 // lib/manual-edits/manual-edit-events/edit_schematic_component_location_event.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var edit_schematic_component_location_event = base_manual_edit_event.extend({
-  edit_event_type: z34.literal("edit_schematic_component_location"),
-  schematic_component_id: z34.string(),
-  original_center: z34.object({ x: z34.number(), y: z34.number() }),
-  new_center: z34.object({ x: z34.number(), y: z34.number() })
+  edit_event_type: z35.literal("edit_schematic_component_location"),
+  schematic_component_id: z35.string(),
+  original_center: z35.object({ x: z35.number(), y: z35.number() }),
+  new_center: z35.object({ x: z35.number(), y: z35.number() })
 });
 expectTypesMatch(true);
 
 // lib/manual-edits/manual_edit_event.ts
-import { z as z35 } from "zod";
-var manual_edit_event = z35.union([
+import { z as z36 } from "zod";
+var manual_edit_event = z36.union([
   edit_pcb_component_location_event,
   edit_trace_hint_event,
   edit_schematic_component_location_event
@@ -632,33 +643,33 @@ var manual_edit_event = z35.union([
 expectTypesMatch(true);
 
 // lib/manual-edits/manual_edit_file.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 
 // lib/manual-edits/manual_pcb_placement.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 import { point as point2 } from "circuit-json";
-var manual_pcb_placement = z36.object({
-  selector: z36.string(),
-  relative_to: z36.string().optional().default("group_center").describe("Can be a selector or 'group_center'"),
+var manual_pcb_placement = z37.object({
+  selector: z37.string(),
+  relative_to: z37.string().optional().default("group_center").describe("Can be a selector or 'group_center'"),
   center: point2
 });
 expectTypesMatch(true);
 
 // lib/manual-edits/manual_trace_hint.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 import { route_hint_point as route_hint_point3 } from "circuit-json";
-var manual_trace_hint = z37.object({
-  pcb_port_selector: z37.string(),
-  offsets: z37.array(route_hint_point3)
+var manual_trace_hint = z38.object({
+  pcb_port_selector: z38.string(),
+  offsets: z38.array(route_hint_point3)
 });
 expectTypesMatch(true);
 
 // lib/manual-edits/manual_schematic_placement.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 import { point as point4 } from "circuit-json";
-var manual_schematic_placement = z38.object({
-  selector: z38.string(),
-  relative_to: z38.string().optional().default("group_center").describe("Can be a selector or 'group_center'"),
+var manual_schematic_placement = z39.object({
+  selector: z39.string(),
+  relative_to: z39.string().optional().default("group_center").describe("Can be a selector or 'group_center'"),
   center: point4
 });
 expectTypesMatch(
@@ -666,10 +677,10 @@ expectTypesMatch(
 );
 
 // lib/manual-edits/manual_edit_file.ts
-var manual_edit_file = z39.object({
-  pcb_placements: z39.array(manual_pcb_placement).optional(),
-  manual_trace_hints: z39.array(manual_trace_hint).optional(),
-  schematic_placements: z39.array(manual_schematic_placement).optional()
+var manual_edit_file = z40.object({
+  pcb_placements: z40.array(manual_pcb_placement).optional(),
+  manual_trace_hints: z40.array(manual_trace_hint).optional(),
+  schematic_placements: z40.array(manual_schematic_placement).optional()
 });
 
 // lib/index.ts
@@ -680,72 +691,72 @@ var inductorPins = lrPins;
 var diodeProps = commonComponentProps.extend({});
 var diodePins = lrPolarPins;
 var ledProps = commonComponentProps.extend({
-  color: z40.string().optional()
+  color: z41.string().optional()
 });
 var ledPins = lrPolarPins;
 var switchProps = commonComponentProps.extend({
-  ftype: z40.literal("switch"),
-  switchType: z40.enum(["spst"]).default("spst"),
-  isNormallyClosed: z40.boolean().default(false)
+  ftype: z41.literal("switch"),
+  switchType: z41.enum(["spst"]).default("spst"),
+  isNormallyClosed: z41.boolean().default(false)
 });
-var distanceOrMultiplier2 = distance12.or(z40.enum(["2x", "3x", "4x"]));
+var distanceOrMultiplier2 = distance12.or(z41.enum(["2x", "3x", "4x"]));
 var viaProps = commonLayoutProps.extend({
   fromLayer: layer_ref4,
   toLayer: layer_ref4,
   holeDiameter: distance12,
   outerDiameter: distance12
 });
-var pcbKeepoutProps = z40.union([
+var pcbKeepoutProps = z41.union([
   pcbLayoutProps.omit({ pcbRotation: true }).extend({
-    shape: z40.literal("circle"),
+    shape: z41.literal("circle"),
     radius: distance12
   }),
   pcbLayoutProps.extend({
-    shape: z40.literal("rect"),
+    shape: z41.literal("rect"),
     width: distance12,
     height: distance12
   })
 ]);
-var schematicBoxProps = z40.object({
+var schematicBoxProps = z41.object({
   schX: distance12,
   schY: distance12,
   width: distance12,
   height: distance12
 });
-var schematicTextProps = z40.object({
+var schematicTextProps = z41.object({
   schX: distance12,
   schY: distance12,
-  text: z40.string()
+  text: z41.string()
 });
-var schematicLineProps = z40.object({
+var schematicLineProps = z41.object({
   x1: distance12,
   y1: distance12,
   x2: distance12,
   y2: distance12
 });
-var schematicPathProps = z40.object({
-  points: z40.array(point5),
-  isFilled: z40.boolean().optional().default(false),
-  fillColor: z40.enum(["red", "blue"]).optional()
+var schematicPathProps = z41.object({
+  points: z41.array(point5),
+  isFilled: z41.boolean().optional().default(false),
+  fillColor: z41.enum(["red", "blue"]).optional()
 });
 var componentProps = commonComponentProps;
 var powerSourceProps = commonComponentProps.extend({
   voltage
 });
 var portProps = commonLayoutProps.extend({
-  name: z40.string(),
-  pinNumber: z40.number().optional(),
-  aliases: z40.array(z40.string()).optional(),
+  name: z41.string(),
+  pinNumber: z41.number().optional(),
+  aliases: z41.array(z41.string()).optional(),
   direction
 });
 var silkscreenTextProps = pcbLayoutProps.extend({
-  text: z40.string(),
-  anchorAlignment: z40.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: z40.enum(["tscircuit2024"]).optional(),
+  text: z41.string(),
+  anchorAlignment: z41.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: z41.enum(["tscircuit2024"]).optional(),
   fontSize: length3.optional()
 });
 var silkscreenPathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: z40.array(route_hint_point4),
+  route: z41.array(route_hint_point4),
   strokeWidth: length3.optional()
 });
 var silkscreenLineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
@@ -756,49 +767,49 @@ var silkscreenLineProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotat
   y2: distance12
 });
 var silkscreenRectProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: z40.boolean().optional(),
-  isOutline: z40.boolean().optional(),
+  isFilled: z41.boolean().optional(),
+  isOutline: z41.boolean().optional(),
   strokeWidth: distance12.optional(),
   width: distance12,
   height: distance12
 });
 var silkscreenCircleProps = pcbLayoutProps.omit({ pcbRotation: true }).extend({
-  isFilled: z40.boolean().optional(),
-  isOutline: z40.boolean().optional(),
+  isFilled: z41.boolean().optional(),
+  isOutline: z41.boolean().optional(),
   strokeWidth: distance12.optional(),
   radius: distance12
 });
-var routeHintPointProps = z40.object({
+var routeHintPointProps = z41.object({
   x: distance12,
   y: distance12,
-  via: z40.boolean().optional(),
+  via: z41.boolean().optional(),
   toLayer: layer_ref4.optional()
 });
-var traceHintProps = z40.object({
-  for: z40.string().optional().describe(
+var traceHintProps = z41.object({
+  for: z41.string().optional().describe(
     "Selector for the port you're targeting, not required if you're inside a trace"
   ),
-  order: z40.number().optional(),
+  order: z41.number().optional(),
   offset: route_hint_point4.or(routeHintPointProps).optional(),
-  offsets: z40.array(route_hint_point4).or(z40.array(routeHintPointProps)).optional(),
-  traceWidth: z40.number().optional()
+  offsets: z41.array(route_hint_point4).or(z41.array(routeHintPointProps)).optional(),
+  traceWidth: z41.number().optional()
 });
-var pcbTraceProps = z40.object({
-  layer: z40.string().optional(),
+var pcbTraceProps = z41.object({
+  layer: z41.string().optional(),
   thickness: distance12.optional(),
-  route: z40.array(route_hint_point4)
+  route: z41.array(route_hint_point4)
 });
 var fabricationNoteTextProps = pcbLayoutProps.extend({
-  text: z40.string(),
-  anchorAlignment: z40.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
-  font: z40.enum(["tscircuit2024"]).optional(),
+  text: z41.string(),
+  anchorAlignment: z41.enum(["center", "top_left", "top_right", "bottom_left", "bottom_right"]).default("center"),
+  font: z41.enum(["tscircuit2024"]).optional(),
   fontSize: length3.optional(),
-  color: z40.string().optional()
+  color: z41.string().optional()
 });
 var fabricationNotePathProps = pcbLayoutProps.omit({ pcbX: true, pcbY: true, pcbRotation: true }).extend({
-  route: z40.array(route_hint_point4),
+  route: z41.array(route_hint_point4),
   strokeWidth: length3.optional(),
-  color: z40.string().optional()
+  color: z41.string().optional()
 });
 export {
   autorouterConfig,
@@ -878,6 +889,7 @@ export {
   rectSolderPasteProps,
   resistorPins,
   resistorProps,
+  resonatorProps,
   rotatedRectSmtPadProps,
   rotationPoint3,
   routeHintPointProps,