props/lib/common/cadModel.ts at 47843c9874fccdf83db7e8969fd41d8a8032236b · tscircuit/props · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
import { z } from "zod"
import { expectTypesMatch } from "lib/typecheck"
import { distance, type Distance } from "./distance"
import { point3 } from "./point3"
import { url } from "./url"
import type { ReactElement } from "react"

export const rotationPoint3 = z.object({
  x: z.union([z.number(), z.string()]),
  y: z.union([z.number(), z.string()]),
  z: z.union([z.number(), z.string()]),
})

export const cadModelAxisDirections = [
  "x+",
  "x-",
  "y+",
  "y-",
  "z+",
  "z-",
] as const

export type CadModelAxisDirection = (typeof cadModelAxisDirections)[number]

export const cadModelAxisDirection = z.enum(cadModelAxisDirections)

export interface CadModelBase {
  rotationOffset?:
    | number
    | { x: number | string; y: number | string; z: number | string }
  positionOffset?: {
    x: number | string
    y: number | string
    z: number | string
  }
  modelOriginPosition?: {
    x: number | string
    y: number | string
    z: number | string
  }
  size?: { x: number | string; y: number | string; z: number | string }
  modelUnitToMmScale?: Distance
  modelBoardNormalDirection?: CadModelAxisDirection
  pcbRotationOffset?: number
  zOffsetFromSurface?: Distance
  showAsTranslucentModel?: boolean
  stepUrl?: string
}

export const cadModelBase = z.object({
  rotationOffset: z.number().or(rotationPoint3).optional(),
  positionOffset: point3.optional(),
  modelOriginPosition: point3.optional(),
  size: point3.optional(),
  modelUnitToMmScale: distance.optional(),
  modelBoardNormalDirection: cadModelAxisDirection.optional(),
  pcbRotationOffset: z.number().optional(),
  zOffsetFromSurface: distance.optional(),
  showAsTranslucentModel: z.boolean().optional(),
  stepUrl: url.optional(),
})

expectTypesMatch<CadModelBase, z.input<typeof cadModelBase>>(true)

export interface CadModelStl extends CadModelBase {
  stlUrl: string
}
export const cadModelStl = cadModelBase.extend({
  stlUrl: url,
})

export interface CadModelObj extends CadModelBase {
  objUrl: string
  mtlUrl?: string
}
export const cadModelObj = cadModelBase.extend({
  objUrl: url,
  mtlUrl: url.optional(),
})

export interface CadModelGltf extends CadModelBase {
  gltfUrl: string
}
export const cadModelGltf = cadModelBase.extend({
  gltfUrl: url,
})

export interface CadModelGlb extends CadModelBase {
  glbUrl: string
}
export const cadModelGlb = cadModelBase.extend({
  glbUrl: url,
})

export interface CadModelStep extends CadModelBase {
  stepUrl: string
}
export const cadModelStep = cadModelBase.extend({
  stepUrl: url,
})

export interface CadModelWrl extends CadModelBase {
  wrlUrl: string
}
export const cadModelWrl = cadModelBase.extend({
  wrlUrl: url,
})

export interface CadModelJscad extends CadModelBase {
  jscad: Record<string, any>
}
export const cadModelJscad = cadModelBase.extend({
  jscad: z.record(z.any()),
})

export type CadModelProp =
  | null
  | string
  | ReactElement
  | CadModelStl
  | CadModelObj
  | CadModelGltf
  | CadModelGlb
  | CadModelStep
  | CadModelWrl
  | CadModelJscad

export const cadModelProp = z.union([
  z.null(),
  url,
  z.custom<ReactElement>((v) => {
    return v && typeof v === "object" && "type" in v && "props" in v
  }),
  cadModelStl,
  cadModelObj,
  cadModelGltf,
  cadModelGlb,
  cadModelStep,
  cadModelWrl,
  cadModelJscad,
])

type InferredCadModelProp = z.input<typeof cadModelProp>
expectTypesMatch<CadModelProp, InferredCadModelProp>(true)