@tscircuit/props 0.0.706 → 0.0.708

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/explosion/index.ts

@@ -0,0 +1,11 @@
+import { assemblyExplosionMoveProps } from "./move"
+import { assemblyExplosionStageProps } from "./stage"
+
+export * from "./move"
+export * from "./stage"
+
+/** Explosion elements; no separate explosion container is needed. */
+export const assemblyExplosionProps = {
+  stage: assemblyExplosionStageProps,
+  move: assemblyExplosionMoveProps,
+} as const

package/lib/assembly/explosion/move.ts

@@ -0,0 +1,72 @@
+import { type Distance, distance } from "lib/common/distance"
+import { expectTypesMatch } from "lib/typecheck"
+import { z } from "zod"
+
+/** One straight, incremental movement within an explosion stage. */
+export interface AssemblyExplosionMoveProps {
+  /** Parts or subassemblies to move together, relative to the stage owner.
+   * Accepts a comma-separated string or an array; parsed as a nonempty array of
+   * trimmed references. Supply exactly one of targetRefs or targetRef.
+   */
+  targetRefs?: string | string[]
+  /** Single-target compatibility alias for targetRefs. Parsed as targetRefs:
+   * [targetRef]; cannot be combined with targetRefs. React reserves ref.
+   */
+  targetRef?: string
+  /** Signed X displacement in the stage owner's frame, in mm or a unit string.
+   * Omitted axes mean zero in the consumer; parsed props remain omitted.
+   */
+  offX?: Distance
+  /** Signed Y displacement in the stage owner's frame, in mm or a unit string. */
+  offY?: Distance
+  /** Signed Z displacement in the stage owner's frame, in mm or a unit string. */
+  offZ?: Distance
+}
+
+const offset = distance.pipe(z.number().finite())
+const reference = z.string().trim().min(1)
+const references = z
+  .union([
+    z.string().transform((value) => value.split(",")),
+    z.array(z.string()),
+  ])
+  .pipe(z.array(reference).min(1))
+
+export const assemblyExplosionMoveProps = z
+  .object({
+    targetRefs: references.optional(),
+    targetRef: reference.optional(),
+    offX: offset.optional(),
+    offY: offset.optional(),
+    offZ: offset.optional(),
+  })
+  .refine(
+    (move) =>
+      (move.targetRefs !== undefined) !== (move.targetRef !== undefined),
+    {
+      message: "Provide exactly one of targetRefs or targetRef",
+      path: ["targetRefs"],
+    },
+  )
+  .refine(
+    (move) =>
+      move.offX !== undefined ||
+      move.offY !== undefined ||
+      move.offZ !== undefined,
+    {
+      message: "Provide at least one of offX, offY, or offZ",
+      path: ["offX"],
+    },
+  )
+  .transform(({ targetRef, targetRefs, ...move }) => ({
+    ...move,
+    targetRefs: targetRefs ?? [targetRef!],
+  }))
+
+export type AssemblyExplosionMovePropsInput = z.input<
+  typeof assemblyExplosionMoveProps
+>
+
+expectTypesMatch<AssemblyExplosionMoveProps, AssemblyExplosionMovePropsInput>(
+  true,
+)

package/lib/assembly/explosion/stage.ts

@@ -0,0 +1,30 @@
+import { expectTypesMatch } from "lib/typecheck"
+import type { ReactNode } from "react"
+import { z } from "zod"
+
+/** A named explosion stage owned by its containing device or subassembly. */
+export interface AssemblyExplosionStageProps {
+  /** Stable stage identity, unique within the owning assembly. */
+  name: string
+  /** Stage that must execute after this one; qualified names may cross assembly scopes. */
+  nextStageRef?: string
+  /** Stage that must execute before this one; qualified names may cross assembly scopes. */
+  prevStageRef?: string
+  /** Ordered explosion moves; preserved unchanged for the consumer. */
+  children?: ReactNode
+}
+
+export const assemblyExplosionStageProps = z.object({
+  name: z.string().trim().min(1),
+  nextStageRef: z.string().trim().min(1).optional(),
+  prevStageRef: z.string().trim().min(1).optional(),
+  children: z.custom<ReactNode>().optional(),
+})
+
+export type AssemblyExplosionStagePropsInput = z.input<
+  typeof assemblyExplosionStageProps
+>
+
+expectTypesMatch<AssemblyExplosionStageProps, AssemblyExplosionStagePropsInput>(
+  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"
@@ -9,7 +10,9 @@ import { assemblyPrintedPartProps } from "./printedpart"
 import { assemblyMotorProps } from "./motor"
 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"
@@ -22,8 +25,11 @@ export * from "./printedpart"
 export * from "./screen"
 export * from "./subassembly"
 export * from "./cadassembly"
+export * from "./explosion"
 
 export const assemblyProps = {
+  drawing: assemblyDrawingProps,
+  explosion: assemblyExplosionProps,
   bolt: assemblyBoltProps,
   fastener: assemblyFastenerProps,
   cable: assemblyCableProps,

package/package.json

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