@tscircuit/props 0.0.707 → 0.0.709

package/lib/assembly/drawing/index.ts

@@ -0,0 +1,15 @@
+import { assemblyDrawingTitleBlockProps } from "./titleblock"
+import { assemblyDrawingPageProps } from "./page"
+import { assemblyDrawingPartViewProps } from "./partview"
+
+export * from "./page"
+export * from "./page-size"
+export * from "./titleblock"
+export * from "./partview"
+
+/** Drawing namespace; pages contain configured part views. */
+export const assemblyDrawingProps = {
+  page: assemblyDrawingPageProps,
+  titleblock: assemblyDrawingTitleBlockProps,
+  partview: assemblyDrawingPartViewProps,
+} as const

package/lib/assembly/drawing/page-size.ts

@@ -0,0 +1,37 @@
+import { z } from "zod"
+
+/** Landscape dimensions in mm. ISO A-series / ASME Y14.1 decimal-inch sheets. */
+export const assemblyDrawingPageSizes = {
+  iso_a0: [1189, 841],
+  iso_a1: [841, 594],
+  iso_a2: [594, 420],
+  iso_a3: [420, 297],
+  iso_a4: [297, 210],
+  ansi_a: [279.4, 215.9],
+  ansi_b: [431.8, 279.4],
+  ansi_c: [558.8, 431.8],
+  ansi_d: [863.6, 558.8],
+  ansi_e: [1117.6, 863.6],
+} as const
+export const assemblyDrawingPageSize = z.enum([
+  "iso_a0",
+  "iso_a1",
+  "iso_a2",
+  "iso_a3",
+  "iso_a4",
+  "ansi_a",
+  "ansi_b",
+  "ansi_c",
+  "ansi_d",
+  "ansi_e",
+])
+export type AssemblyDrawingPageSize = z.infer<typeof assemblyDrawingPageSize>
+export function getAssemblyDrawingPageDimensions(
+  size: AssemblyDrawingPageSize,
+  orientation: "landscape" | "portrait" = "landscape",
+) {
+  const [width, height] = assemblyDrawingPageSizes[size]
+  return orientation === "portrait"
+    ? { width: height, height: width }
+    : { width, height }
+}

package/lib/assembly/drawing/page.ts

@@ -0,0 +1,64 @@
+import { z } from "zod"
+import {
+  assemblyDrawingPageSize,
+  getAssemblyDrawingPageDimensions,
+  type AssemblyDrawingPageSize,
+} from "./page-size"
+import { distance } from "circuit-json"
+import type { Distance } from "lib/common/distance"
+import { expectTypesMatch } from "lib/typecheck"
+
+/** A paper-space drawing page containing configured part views. */
+export interface AssemblyDrawingPageProps {
+  name?: string
+  displayName?: string
+  /** Standard sheet size; landscape by default. Mutually exclusive with width/height. */
+  size?: AssemblyDrawingPageSize
+  orientation?: "landscape" | "portrait"
+  /** Custom paper dimensions in mm when numeric; unit strings are accepted. */
+  width?: Distance
+  height?: Distance
+  children?: any
+}
+
+export const assemblyDrawingPageProps = z
+  .object({
+    name: z.string().optional(),
+    displayName: z.string().optional(),
+    size: assemblyDrawingPageSize.optional(),
+    orientation: z.enum(["landscape", "portrait"]).optional(),
+    width: distance.pipe(z.number().finite().positive()).optional(),
+    height: distance.pipe(z.number().finite().positive()).optional(),
+    children: z.any().optional(),
+  })
+  .superRefine((page, ctx) => {
+    if (
+      page.size
+        ? page.width != null || page.height != null
+        : page.width == null || page.height == null
+    )
+      ctx.addIssue({
+        code: "custom",
+        message: "Specify size or both width and height, exclusively",
+      })
+    if (!page.size && page.orientation)
+      ctx.addIssue({
+        code: "custom",
+        path: ["orientation"],
+        message: "Orientation requires a standard size",
+      })
+  })
+  .transform((page) => ({
+    ...page,
+    ...(page.size
+      ? getAssemblyDrawingPageDimensions(page.size, page.orientation)
+      : { width: page.width!, height: page.height! }),
+  }))
+
+export type InferredAssemblyDrawingPageProps = z.input<
+  typeof assemblyDrawingPageProps
+>
+expectTypesMatch<
+  AssemblyDrawingPageProps,
+  z.input<typeof assemblyDrawingPageProps>
+>(true)

package/lib/assembly/drawing/partview.ts

@@ -0,0 +1,118 @@
+import { z } from "zod"
+import { distance } from "circuit-json"
+import type { Distance } from "lib/common/distance"
+import { expectTypesMatch } from "lib/typecheck"
+
+/** Axis names use tscircuit CAD coordinates: mm, +Z up. The camera sits on
+ * the named side of the model and looks toward its center. */
+export type AssemblyDrawingPartViewDirection =
+  | "x+"
+  | "x-"
+  | "y+"
+  | "y-"
+  | "z+"
+  | "z-"
+  | "isometric"
+
+export interface AssemblyDrawingSectionPlane {
+  axis: "x" | "y" | "z"
+  /** Plane coordinate in CAD world space, numeric mm or a distance string. */
+  offset: Distance
+  /** Retain coordinates <= offset or >= offset, respectively. */
+  keepSide: "less" | "greater"
+  /** Physical distance between 45-degree strokes on the model. Defaults to 1mm. */
+  hatchSpacing?: Distance
+}
+
+export const assemblyDrawingSectionPlane = z.object({
+  axis: z.enum(["x", "y", "z"]),
+  offset: distance.pipe(z.number().finite()),
+  keepSide: z.enum(["less", "greater"]),
+  hatchSpacing: distance.pipe(z.number().finite().positive()).default(1),
+})
+
+/** An orthographic viewport within an assembly.drawing.page. */
+export interface AssemblyDrawingPartViewProps {
+  name?: string
+  displayName?: string
+  /** Selector for the board, group or assembly geometry shown in this view. */
+  partRef: string
+  direction: AssemblyDrawingPartViewDirection
+  /** Viewport center relative to the paper center, mm; +X right, +Y up. Defaults to 0 on axes without a relative reference. */
+  centerX?: Distance
+  centerY?: Distance
+  /** Sibling part-view selector; infer centerX with this viewport left of the reference. Conflicts with rightOfRef and centerX. */
+  leftOfRef?: string
+  /** Sibling part-view selector; infer centerX with this viewport right of the reference. Conflicts with leftOfRef and centerX. */
+  rightOfRef?: string
+  /** Sibling part-view selector; infer centerY with this viewport above the reference. Conflicts with belowRef and centerY. */
+  aboveRef?: string
+  /** Sibling part-view selector; infer centerY with this viewport below the reference. Conflicts with aboveRef and centerY. */
+  belowRef?: string
+  /** Paper-space viewport size; dimensions must be positive. */
+  width: Distance
+  height: Distance
+  /** Draw obscured edges as dashed strokes. Defaults to false. */
+  showHiddenEdges?: boolean
+  /** A planar cut with diagonal hatching on closed cut surfaces. */
+  section?: AssemblyDrawingSectionPlane
+}
+
+export const assemblyDrawingPartViewProps = z
+  .object({
+    name: z.string().optional(),
+    displayName: z.string().optional(),
+    partRef: z.string().min(1),
+    direction: z.enum(["x+", "x-", "y+", "y-", "z+", "z-", "isometric"]),
+    centerX: distance.pipe(z.number().finite()).optional(),
+    centerY: distance.pipe(z.number().finite()).optional(),
+    leftOfRef: z.string().trim().min(1).optional(),
+    rightOfRef: z.string().trim().min(1).optional(),
+    aboveRef: z.string().trim().min(1).optional(),
+    belowRef: z.string().trim().min(1).optional(),
+    width: distance.pipe(z.number().finite().positive()),
+    height: distance.pipe(z.number().finite().positive()),
+    showHiddenEdges: z.boolean().default(false),
+    section: assemblyDrawingSectionPlane.optional(),
+  })
+  .superRefine((view, ctx) => {
+    for (const [center, negative, positive] of [
+      ["centerX", "leftOfRef", "rightOfRef"],
+      ["centerY", "belowRef", "aboveRef"],
+    ] as const) {
+      if (view[negative] !== undefined && view[positive] !== undefined)
+        ctx.addIssue({
+          code: "custom",
+          path: [positive],
+          message: `${negative} and ${positive} are mutually exclusive`,
+        })
+      if (
+        view[center] !== undefined &&
+        (view[negative] !== undefined || view[positive] !== undefined)
+      )
+        ctx.addIssue({
+          code: "custom",
+          path: [center],
+          message: `${center} cannot be combined with ${negative} or ${positive}`,
+        })
+    }
+  })
+  .transform((view) => ({
+    ...view,
+    ...(view.leftOfRef || view.rightOfRef
+      ? {}
+      : { centerX: view.centerX ?? 0 }),
+    ...(view.aboveRef || view.belowRef ? {} : { centerY: view.centerY ?? 0 }),
+  }))
+
+export type InferredAssemblyDrawingPartViewProps = z.input<
+  typeof assemblyDrawingPartViewProps
+>
+expectTypesMatch<
+  AssemblyDrawingSectionPlane,
+  z.input<typeof assemblyDrawingSectionPlane>
+>(true)
+expectTypesMatch<
+  AssemblyDrawingPartViewProps,
+  z.input<typeof assemblyDrawingPartViewProps>
+>(true)

package/lib/assembly/drawing/titleblock.ts

@@ -0,0 +1,43 @@
+import { z } from "zod"
+import { expectTypesMatch } from "lib/typecheck"
+
+/** Optional page child. Metadata fields reference ISO 7200:2004. */
+export interface AssemblyDrawingTitleBlockProps {
+  name?: string
+  title: string
+  legalOwner?: string
+  identificationNumber?: string
+  revisionIndex?: string
+  dateOfIssue?: string
+  creator?: string
+  approvalPerson?: string
+  sheetNumber?: number
+  numberOfSheets?: number
+}
+export const assemblyDrawingTitleBlockProps = z
+  .object({
+    name: z.string().optional(),
+    title: z.string().min(1),
+    legalOwner: z.string().optional(),
+    identificationNumber: z.string().optional(),
+    revisionIndex: z.string().optional(),
+    dateOfIssue: z.string().optional(),
+    creator: z.string().optional(),
+    approvalPerson: z.string().optional(),
+    sheetNumber: z.number().int().positive().optional(),
+    numberOfSheets: z.number().int().positive().optional(),
+  })
+  .refine(
+    (block) =>
+      block.sheetNumber == null ||
+      block.numberOfSheets == null ||
+      block.sheetNumber <= block.numberOfSheets,
+    {
+      message: "sheetNumber must not exceed numberOfSheets",
+      path: ["sheetNumber"],
+    },
+  )
+expectTypesMatch<
+  AssemblyDrawingTitleBlockProps,
+  z.input<typeof assemblyDrawingTitleBlockProps>
+>(true)

package/lib/assembly/index.ts

@@ -1,3 +1,4 @@
+import { assemblyDrawingProps } from "./drawing"
 import { assemblyCadAssemblyProps } from "./cadassembly"
 import { assemblyCableProps } from "./cable"
 import { assemblyBoltProps } from "./bolt"
@@ -11,6 +12,7 @@ import { assemblyScreenProps } from "./screen"
 import { assemblySubassemblyProps } from "./subassembly"
 import { assemblyExplosionProps } from "./explosion"
 
+export * from "./drawing"
 export * from "./board-mounting"
 export * from "./bolt"
 export * from "./fastener"
@@ -26,6 +28,7 @@ export * from "./cadassembly"
 export * from "./explosion"
 
 export const assemblyProps = {
+  drawing: assemblyDrawingProps,
   explosion: assemblyExplosionProps,
   bolt: assemblyBoltProps,
   fastener: assemblyFastenerProps,

package/lib/components/analogtransientsimulation.ts

@@ -1,4 +1,4 @@
-import { ms } from "circuit-json"
+import { frequency, length, ms } from "circuit-json"
 import { expectTypesMatch } from "lib/typecheck"
 import { z } from "zod"
 import { ibisPinRunState, type IbisPinRunState } from "lib/common/ibis"
@@ -17,8 +17,119 @@ export interface AnalogTransientSimulationProps
   timePerStep?: number | string
   /** Physical pin selectors and per-experiment direction/enable states. Requires spiceEngine="pcb_spice"; rendering only declares the experiment. */
   ibisPinStates?: Record<string, IbisPinRunState>
+  pcbSpiceChannel?: PcbSpiceChannelProps
 }
 
+export interface PcbSpiceChannelProps {
+  reduction: "routed-copper" | "straightened-stages"
+  sections: number
+  lanes: Array<{ name: string; from: string; to: string }>
+  referencePinRef: string
+  passiveComponentRefs?: string[]
+  extraction: {
+    minimumFrequency: number | string
+    maximumFrequency: number | string
+    modelFrequency: number | string
+    filaments: number
+    refinementFilaments: number
+    convergenceTolerance: number
+    capacitanceTolerance: number
+    reciprocityTolerance: number
+    dcResistanceTolerance: number
+    maxPanelLength: number | string
+    groundMeshSize?: number | string
+  }
+  relativePermittivity?: number
+  via?: {
+    platingThickness?: number | string
+    equivalentWidth?: number | string
+    omitThroughViaStubs?: boolean
+  }
+  straightenedStageProfiles?: Record<
+    string,
+    {
+      spacing: number | string
+      relativePermittivity: number
+      return: {
+        width: number | string
+        thickness: number | string
+        lengthFactor: number
+        centerY: number | string
+        centerZ: number | string
+      }
+    }
+  >
+}
+
+const positiveLength = length.pipe(z.number().finite().positive())
+const signedLength = length.pipe(z.number().finite())
+const positiveFrequency = frequency.pipe(z.number().finite().positive())
+
+export const pcbSpiceChannelProps = z.object({
+  reduction: z.enum(["routed-copper", "straightened-stages"]),
+  sections: z.number().int().min(1).max(128),
+  lanes: z
+    .array(
+      z.object({
+        name: z.string().min(1),
+        from: z.string().min(1),
+        to: z.string().min(1),
+      }),
+    )
+    .min(1)
+    .max(3),
+  referencePinRef: z.string().min(1),
+  passiveComponentRefs: z.array(z.string().min(1)).optional(),
+  extraction: z
+    .object({
+      minimumFrequency: positiveFrequency,
+      maximumFrequency: positiveFrequency,
+      modelFrequency: positiveFrequency,
+      filaments: z.number().int().positive(),
+      refinementFilaments: z.number().int().positive(),
+      convergenceTolerance: z.number().finite().positive(),
+      capacitanceTolerance: z.number().finite().positive(),
+      reciprocityTolerance: z.number().finite().positive(),
+      dcResistanceTolerance: z.number().finite().positive(),
+      maxPanelLength: positiveLength,
+      groundMeshSize: positiveLength.optional(),
+    })
+    .refine(
+      (extraction) => extraction.refinementFilaments > extraction.filaments,
+      {
+        path: ["refinementFilaments"],
+        message: "refinementFilaments must be greater than filaments",
+      },
+    ),
+  relativePermittivity: z.number().finite().positive().optional(),
+  via: z
+    .object({
+      platingThickness: positiveLength.optional(),
+      equivalentWidth: positiveLength.optional(),
+      omitThroughViaStubs: z.boolean().optional(),
+    })
+    .optional(),
+  straightenedStageProfiles: z
+    .record(
+      z.object({
+        spacing: positiveLength,
+        relativePermittivity: z.number().finite().positive(),
+        return: z.object({
+          width: positiveLength,
+          thickness: positiveLength,
+          lengthFactor: z.number().finite().positive(),
+          centerY: signedLength,
+          centerZ: signedLength,
+        }),
+      }),
+    )
+    .optional(),
+})
+
+expectTypesMatch<PcbSpiceChannelProps, z.input<typeof pcbSpiceChannelProps>>(
+  true,
+)
+
 const positiveMilliseconds = ms.refine(
   (milliseconds) => milliseconds > 0,
   "Time must be positive",
@@ -30,9 +141,17 @@ export const analogTransientSimulationProps = z
     duration: positiveMilliseconds.default("10ms"),
     startTime: ms.default("0ms"),
     timePerStep: positiveMilliseconds.default("0.01ms"),
+    pcbSpiceChannel: pcbSpiceChannelProps.optional(),
     ibisPinStates: z.record(z.string().min(1), ibisPinRunState).optional(),
   })
   .superRefine((simulation, context) => {
+    if (simulation.pcbSpiceChannel && simulation.spiceEngine !== "pcb_spice") {
+      context.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["pcbSpiceChannel"],
+        message: "PCB SPICE channel settings require spiceEngine=pcb_spice",
+      })
+    }
     if (simulation.ibisPinStates && simulation.spiceEngine !== "pcb_spice") {
       context.addIssue({
         code: z.ZodIssueCode.custom,

package/package.json

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