@tscircuit/props 0.0.639 → 0.0.641

package/lib/common/pcbPath.ts

@@ -0,0 +1,41 @@
+import { layer_ref, type LayerRefInput } from "circuit-json"
+import { expectTypesMatch } from "lib/typecheck"
+import { z } from "zod"
+import { point, type Point } from "./point"
+
+export interface PcbPathPoint extends Point {
+  via?: boolean
+  fromLayer?: LayerRefInput
+  toLayer?: LayerRefInput
+}
+
+const basePcbPathPoint = point.extend({
+  via: z.boolean().optional(),
+  fromLayer: layer_ref.optional(),
+  toLayer: layer_ref.optional(),
+})
+
+export const pcbPathPoint = basePcbPathPoint.superRefine((value, ctx) => {
+  if (value.via) {
+    if (!value.toLayer) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "toLayer is required when via is true",
+        path: ["toLayer"],
+      })
+    }
+  } else if (value.fromLayer || value.toLayer) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "fromLayer/toLayer are only allowed when via is true",
+      path: ["via"],
+    })
+  }
+})
+
+export const pcbPath = z.array(z.union([pcbPathPoint, z.string()]))
+
+export type PcbPath = Array<PcbPathPoint | string>
+
+expectTypesMatch<PcbPathPoint, z.input<typeof pcbPathPoint>>(true)
+expectTypesMatch<PcbPath, z.input<typeof pcbPath>>(true)

package/lib/components/antenna.ts

@@ -0,0 +1,23 @@
+import {
+  type CommonComponentProps,
+  commonComponentProps,
+} from "lib/common/layout"
+import { type PcbPath, pcbPath } from "lib/common/pcbPath"
+import { expectTypesMatch } from "lib/typecheck"
+import { z } from "zod"
+
+/** Props for an antenna component with an optional explicit PCB path. */
+export interface AntennaProps extends CommonComponentProps {
+  /**
+   * Explicit antenna path. Entries use the same selector, point, and via
+   * syntax as trace pcbPath entries.
+   */
+  pcbPath?: PcbPath
+}
+
+export const antennaProps = commonComponentProps.extend({
+  pcbPath: pcbPath.optional(),
+})
+
+type InferredAntennaProps = z.input<typeof antennaProps>
+expectTypesMatch<AntennaProps, InferredAntennaProps>(true)

package/lib/components/schematic-graphic.ts

@@ -0,0 +1,62 @@
+import { z } from "zod"
+import { type Distance, distance } from "lib/common/distance"
+import { url } from "lib/common/url"
+import { expectTypesMatch } from "lib/typecheck"
+
+/**
+ * Props for embedding an image or raw SVG graphic in a schematic sheet.
+ * At least one source is required; both sources may be provided.
+ * When both are provided, imageUrl is the canonical asset source and
+ * svgContent is optional materialized fallback content.
+ */
+export interface SchematicGraphicProps {
+  /** URL or static-file import for the canonical source SVG asset. */
+  imageUrl?: string
+  /**
+   * Complete SVG markup, including its dimensions or viewBox. Used as the
+   * source when imageUrl is omitted, or as fallback content when both exist.
+   */
+  svgContent?: string
+  /** Optional rendered width of the graphic. */
+  width?: Distance
+  /** Optional rendered height of the graphic. */
+  height?: Distance
+}
+
+const nonemptyUrl = url.refine((value) => value.trim().length > 0, {
+  message: "imageUrl cannot be empty",
+})
+
+const positiveDistance = (fieldName: "width" | "height") =>
+  distance.refine((value) => Number.isFinite(value) && value > 0, {
+    message: `${fieldName} must be a positive finite distance`,
+  })
+
+export const schematicGraphicProps = z
+  .object({
+    imageUrl: nonemptyUrl.optional(),
+    svgContent: z
+      .string()
+      .refine((value) => value.trim().length > 0, {
+        message: "svgContent cannot be empty",
+      })
+      .optional(),
+    width: positiveDistance("width").optional(),
+    height: positiveDistance("height").optional(),
+  })
+  .superRefine(({ imageUrl, svgContent }, ctx) => {
+    if (imageUrl === undefined && svgContent === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "At least one of imageUrl or svgContent is required",
+      })
+    }
+  })
+
+export type InferredSchematicGraphicProps = z.input<
+  typeof schematicGraphicProps
+>
+
+expectTypesMatch<SchematicGraphicProps, z.input<typeof schematicGraphicProps>>(
+  true,
+)

package/lib/components/schematic-sheet.ts

@@ -6,8 +6,8 @@ import { expectTypesMatch } from "lib/typecheck"
 export type SchematicSheetSize = "A4" | "ANSI_B"
 
 export interface SchematicSheetProps {
-  name: string
-  displayName: string
+  name?: string
+  displayName?: string
   sheetIndex?: number
   /** Sheet size used to render the schematic. Defaults to A4. */
   sheetSize?: SchematicSheetSize
@@ -19,8 +19,8 @@ export interface SchematicSheetProps {
 }
 
 export const schematicSheetProps = z.object({
-  name: z.string(),
-  displayName: z.string(),
+  name: z.string().optional(),
+  displayName: z.string().optional(),
   sheetIndex: z.number().optional(),
   sheetSize: z.enum(["A4", "ANSI_B"]).default("A4"),
   sheetWidth: distance.pipe(z.number().positive()).optional(),

package/lib/components/trace.ts

@@ -1,6 +1,7 @@
-import { distance, layer_ref, route_hint_point } from "circuit-json"
+import { distance, route_hint_point } from "circuit-json"
 import { z } from "zod"
 import { point } from "../common/point"
+import { pcbPath } from "../common/pcbPath"
 
 export const portRef = z.union([
   z.string(),
@@ -13,32 +14,6 @@ export const portRef = z.union([
   ),
 ])
 
-const pcbPathPoint = point
-  .extend({
-    via: z.boolean().optional(),
-    fromLayer: layer_ref.optional(),
-    toLayer: layer_ref.optional(),
-  })
-  .superRefine((value, ctx) => {
-    if (value.via) {
-      if (!value.toLayer) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: "toLayer is required when via is true",
-          path: ["toLayer"],
-        })
-      }
-    } else if (value.fromLayer || value.toLayer) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "fromLayer/toLayer are only allowed when via is true",
-        path: ["via"],
-      })
-    }
-  })
-
-const pcbPath = z.array(z.union([pcbPathPoint, z.string()]))
-
 const baseTraceProps = z.object({
   key: z.string().optional(),
   name: z.string().optional(),

package/lib/index.ts

@@ -6,6 +6,7 @@ export * from "./common/portHints"
 export * from "./common/layout"
 export * from "./common/pinAttributeMap"
 export * from "./common/point3"
+export * from "./common/pcbPath"
 export * from "./common/portHints"
 export * from "./common/footprintProp"
 export * from "./common/symbolProp"
@@ -57,6 +58,7 @@ export * from "./components/drc-check"
 export * from "./components/smtpad"
 export * from "./components/solderpaste"
 export * from "./components/hole"
+export * from "./components/antenna"
 export * from "./components/trace"
 export * from "./components/bus"
 export * from "./components/differentialpair"
@@ -121,6 +123,7 @@ export * from "./components/schematic-row"
 export * from "./components/schematic-cell"
 export * from "./components/schematic-section"
 export * from "./components/schematic-sheet"
+export * from "./components/schematic-graphic"
 export * from "./components/copper-text"
 export * from "./components/silkscreen-text"
 export * from "./components/silkscreen-path"

package/package.json

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