@tscircuit/props 0.0.698 → 0.0.700

package/lib/assembly/bolt.ts

@@ -0,0 +1,79 @@
+import { distance, type Distance } from "lib/common/distance"
+import { expectTypesMatch } from "lib/typecheck"
+import { z } from "zod"
+import { assemblyFastenerProps, type AssemblyFastenerProps } from "./fastener"
+
+export type AssemblyBoltHeadType = "socket" | "hex" | "pan" | "countersunk"
+
+/** A bolt specified by dimensions, or by one existing assembly CAD source. */
+export interface AssemblyBoltProps extends AssemblyFastenerProps {
+  /** Nominal thread diameter in mm or a unit string. Required with length
+   * when no model, modelUrl, or cadModel is supplied.
+   */
+  diameter?: Distance
+  /** Shaft length in mm or a unit string, excluding the head (including the
+   * head for countersunk bolts). Required with diameter for dimensional bolts.
+   */
+  length?: Distance
+  /** Optional thread pitch in mm or a unit string. No pitch is inferred. */
+  threadPitch?: Distance
+  /** Head shape for dimensional bolts; defaults to socket. */
+  headType?: AssemblyBoltHeadType
+}
+
+const positiveDistance = distance.pipe(z.number().positive().finite())
+
+export const assemblyBoltProps = assemblyFastenerProps
+  .and(
+    z.object({
+      diameter: positiveDistance.optional(),
+      length: positiveDistance.optional(),
+      threadPitch: positiveDistance.optional(),
+      headType: z.enum(["socket", "hex", "pan", "countersunk"]).optional(),
+    }),
+  )
+  .superRefine((bolt, ctx) => {
+    const hasModel = [bolt.model, bolt.modelUrl, bolt.cadModel].some(
+      (value) => value !== undefined,
+    )
+    if (hasModel) {
+      for (const prop of [
+        "diameter",
+        "length",
+        "threadPitch",
+        "headType",
+      ] as const) {
+        if (bolt[prop] !== undefined) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: [prop],
+            message:
+              "Bolt dimensions and headType are exclusive with CAD sources",
+          })
+        }
+      }
+    } else {
+      for (const prop of ["diameter", "length"] as const) {
+        if (bolt[prop] === undefined) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: [prop],
+            message: "Provide diameter and length, or an assembly CAD source",
+          })
+        }
+      }
+    }
+  })
+  .transform((bolt) =>
+    bolt.diameter === undefined
+      ? bolt
+      : { ...bolt, headType: bolt.headType ?? ("socket" as const) },
+  )
+
+export type AssemblyBoltPropsInput = {
+  [K in keyof z.input<typeof assemblyBoltProps>]: z.input<
+    typeof assemblyBoltProps
+  >[K]
+}
+
+expectTypesMatch<AssemblyBoltProps, AssemblyBoltPropsInput>(true)

package/lib/assembly/fastener.ts

@@ -0,0 +1,78 @@
+import { distance, type Distance } from "lib/common/distance"
+import { expectTypesMatch } from "lib/typecheck"
+import { z } from "zod"
+import { assemblyPartProps, type AssemblyPartProps } from "./part"
+
+/** An assembly part that fastens to its mounting target, even without geometry. */
+export interface AssemblyFastenerProps extends AssemblyPartProps {
+  /** Qualified reference surface, e.g. "FRAME.boltHole". Implies fastening.
+   * Without mountFace, use the fastener's authored local mounting origin.
+   */
+  mountedTo?: string
+  /** Common fastener vocabulary for mountedTo; parsed output uses mountedTo.
+   * Both may be supplied only when their trimmed values agree.
+   */
+  fastenedTo?: string
+  /** Optional named mating face on this fastener; requires a mounting target.
+   * When supplied, outward normals oppose and in-plane X directions align.
+   */
+  mountFace?: string
+  /** Nonnegative surface clearance in mm or a unit string; defaults to zero
+   * in the consumer. Requires a mounting target; omitted values stay omitted.
+   */
+  mountGap?: Distance
+}
+
+const mountingTarget = z
+  .string()
+  .trim()
+  .regex(
+    /^[A-Za-z_][A-Za-z0-9_-]*(?:\.[A-Za-z_][A-Za-z0-9_-]*)+$/,
+    "Expected a qualified reference surface, e.g. part.face",
+  )
+
+export const assemblyFastenerProps = assemblyPartProps
+  .and(
+    z.object({
+      mountedTo: mountingTarget.optional(),
+      fastenedTo: mountingTarget.optional(),
+      mountFace: z.string().trim().min(1).optional(),
+      mountGap: distance.pipe(z.number().nonnegative().finite()).optional(),
+    }),
+  )
+  .superRefine((fastener, ctx) => {
+    if (
+      fastener.mountedTo !== undefined &&
+      fastener.fastenedTo !== undefined &&
+      fastener.mountedTo !== fastener.fastenedTo
+    ) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["fastenedTo"],
+        message: "mountedTo and fastenedTo must refer to the same surface",
+      })
+    }
+    if (fastener.mountedTo === undefined && fastener.fastenedTo === undefined) {
+      for (const prop of ["mountFace", "mountGap"] as const) {
+        if (fastener[prop] !== undefined) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: [prop],
+            message: `${prop} requires mountedTo or fastenedTo`,
+          })
+        }
+      }
+    }
+  })
+  .transform(({ fastenedTo, ...fastener }) => {
+    const mountedTo = fastener.mountedTo ?? fastenedTo
+    return mountedTo === undefined ? fastener : { ...fastener, mountedTo }
+  })
+
+export type AssemblyFastenerPropsInput = {
+  [K in keyof z.input<typeof assemblyFastenerProps>]: z.input<
+    typeof assemblyFastenerProps
+  >[K]
+}
+
+expectTypesMatch<AssemblyFastenerProps, AssemblyFastenerPropsInput>(true)

package/lib/assembly/index.ts

@@ -1,5 +1,7 @@
 import { assemblyCadAssemblyProps } from "./cadassembly"
 import { assemblyCableProps } from "./cable"
+import { assemblyBoltProps } from "./bolt"
+import { assemblyFastenerProps } from "./fastener"
 import { assemblyDeviceProps } from "./device"
 import { assemblyPartProps } from "./part"
 import { assemblyReferenceSurfaceProps } from "./referencesurface"
@@ -9,6 +11,8 @@ import { assemblyScreenProps } from "./screen"
 import { assemblySubassemblyProps } from "./subassembly"
 
 export * from "./board-mounting"
+export * from "./bolt"
+export * from "./fastener"
 export * from "./cable"
 export * from "./device"
 export * from "./motor"
@@ -20,6 +24,8 @@ export * from "./subassembly"
 export * from "./cadassembly"
 
 export const assemblyProps = {
+  bolt: assemblyBoltProps,
+  fastener: assemblyFastenerProps,
   cable: assemblyCableProps,
   device: assemblyDeviceProps,
   motor: assemblyMotorProps,

package/lib/components/pin-header.ts

@@ -41,9 +41,9 @@ export interface PinHeaderProps extends CommonComponentProps {
   schFacingDirection?: "up" | "down" | "left" | "right"
 
   /**
-   * Whether the header is male, female, or unpopulated
+   * Whether the header is male or female
    */
-  gender?: "male" | "female" | "unpopulated"
+  gender?: "male" | "female"
 
   /**
    * Mount the header on the top of the board, so it is connected to from
@@ -148,10 +148,7 @@ export const pinHeaderProps = commonComponentProps
     pinCount: z.number(),
     pitch: distance.optional(),
     schFacingDirection: z.enum(["up", "down", "left", "right"]).optional(),
-    gender: z
-      .enum(["male", "female", "unpopulated"])
-      .optional()
-      .default("male"),
+    gender: z.enum(["male", "female"]).optional().default("male"),
     showSilkscreenPinLabels: z.boolean().optional(),
     pcbPinLabels: z.record(z.string(), z.string()).optional(),
     doubleRow: z.boolean().optional(),

package/package.json

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