@tscircuit/props 0.0.447 → 0.0.449

package/lib/common/kicadFootprintMetadata.ts

@@ -0,0 +1,174 @@
+import { distance, rotation } from "circuit-json"
+import { expectTypesMatch } from "lib/typecheck"
+import { z } from "zod"
+import { point } from "./point"
+import { point3 } from "./point3"
+
+export interface KicadAt {
+  x: number | string
+  y: number | string
+  rotation?: number | string
+}
+
+export const kicadAt = point.extend({
+  rotation: rotation.optional(),
+})
+
+type InferredKicadAt = z.input<typeof kicadAt>
+expectTypesMatch<KicadAt, InferredKicadAt>(true)
+
+export interface KicadFont {
+  size?: { x: number | string; y: number | string }
+  thickness?: number | string
+}
+
+export const kicadFont = z.object({
+  size: point.optional(),
+  thickness: distance.optional(),
+})
+
+type InferredKicadFont = z.input<typeof kicadFont>
+expectTypesMatch<KicadFont, InferredKicadFont>(true)
+
+export interface KicadEffects {
+  font?: KicadFont
+}
+
+export const kicadEffects = z.object({
+  font: kicadFont.optional(),
+})
+
+type InferredKicadEffects = z.input<typeof kicadEffects>
+expectTypesMatch<KicadEffects, InferredKicadEffects>(true)
+
+export interface KicadProperty {
+  value: string
+  at?: KicadAt
+  layer?: string
+  uuid?: string
+  hide?: boolean
+  effects?: KicadEffects
+}
+
+export const kicadProperty = z.object({
+  value: z.string(),
+  at: kicadAt.optional(),
+  layer: z.string().optional(),
+  uuid: z.string().optional(),
+  hide: z.boolean().optional(),
+  effects: kicadEffects.optional(),
+})
+
+type InferredKicadProperty = z.input<typeof kicadProperty>
+expectTypesMatch<KicadProperty, InferredKicadProperty>(true)
+
+export interface KicadFootprintProperties {
+  Reference?: KicadProperty
+  Value?: KicadProperty
+  Datasheet?: KicadProperty
+  Description?: KicadProperty
+}
+
+export const kicadFootprintProperties = z.object({
+  Reference: kicadProperty.optional(),
+  Value: kicadProperty.optional(),
+  Datasheet: kicadProperty.optional(),
+  Description: kicadProperty.optional(),
+})
+
+type InferredKicadFootprintProperties = z.input<typeof kicadFootprintProperties>
+expectTypesMatch<KicadFootprintProperties, InferredKicadFootprintProperties>(
+  true,
+)
+
+export interface KicadFootprintAttributes {
+  through_hole?: boolean
+  smd?: boolean
+  exclude_from_pos_files?: boolean
+  exclude_from_bom?: boolean
+}
+
+export const kicadFootprintAttributes = z.object({
+  through_hole: z.boolean().optional(),
+  smd: z.boolean().optional(),
+  exclude_from_pos_files: z.boolean().optional(),
+  exclude_from_bom: z.boolean().optional(),
+})
+
+type InferredKicadFootprintAttributes = z.input<typeof kicadFootprintAttributes>
+expectTypesMatch<KicadFootprintAttributes, InferredKicadFootprintAttributes>(
+  true,
+)
+
+export interface KicadFootprintPad {
+  name: string
+  type: string
+  shape?: string
+  at?: KicadAt
+  size?: { x: number | string; y: number | string }
+  drill?: number | string
+  layers?: string[]
+  removeUnusedLayers?: boolean
+  uuid?: string
+}
+
+export const kicadFootprintPad = z.object({
+  name: z.string(),
+  type: z.string(),
+  shape: z.string().optional(),
+  at: kicadAt.optional(),
+  size: point.optional(),
+  drill: distance.optional(),
+  layers: z.array(z.string()).optional(),
+  removeUnusedLayers: z.boolean().optional(),
+  uuid: z.string().optional(),
+})
+
+type InferredKicadFootprintPad = z.input<typeof kicadFootprintPad>
+expectTypesMatch<KicadFootprintPad, InferredKicadFootprintPad>(true)
+
+export interface KicadFootprintModel {
+  path: string
+  offset?: { x: number | string; y: number | string; z: number | string }
+  scale?: { x: number | string; y: number | string; z: number | string }
+  rotate?: { x: number | string; y: number | string; z: number | string }
+}
+
+export const kicadFootprintModel = z.object({
+  path: z.string(),
+  offset: point3.optional(),
+  scale: point3.optional(),
+  rotate: point3.optional(),
+})
+
+type InferredKicadFootprintModel = z.input<typeof kicadFootprintModel>
+expectTypesMatch<KicadFootprintModel, InferredKicadFootprintModel>(true)
+
+export interface KicadFootprintMetadata {
+  footprintName?: string
+  version?: number | string
+  generator?: string
+  generatorVersion?: number | string
+  layer?: string
+  properties?: KicadFootprintProperties
+  attributes?: KicadFootprintAttributes
+  pads?: KicadFootprintPad[]
+  embeddedFonts?: boolean
+  model?: KicadFootprintModel
+}
+
+export const kicadFootprintMetadata = z.object({
+  footprintName: z.string().optional(),
+  version: z.union([z.number(), z.string()]).optional(),
+  generator: z.string().optional(),
+  generatorVersion: z.union([z.number(), z.string()]).optional(),
+  layer: z.string().optional(),
+  properties: kicadFootprintProperties.optional(),
+  attributes: kicadFootprintAttributes.optional(),
+  pads: z.array(kicadFootprintPad).optional(),
+  embeddedFonts: z.boolean().optional(),
+  model: kicadFootprintModel.optional(),
+})
+
+type InferredKicadFootprintMetadata = z.input<typeof kicadFootprintMetadata>
+expectTypesMatch<KicadFootprintMetadata, InferredKicadFootprintMetadata>(true)

package/lib/common/kicadSymbolMetadata.ts

@@ -0,0 +1,115 @@
+import { distance } from "circuit-json"
+import { expectTypesMatch } from "lib/typecheck"
+import { z } from "zod"
+import {
+  kicadAt,
+  kicadFont,
+  type KicadAt,
+  type KicadFont,
+} from "./kicadFootprintMetadata"
+
+export interface KicadSymbolPinNumbers {
+  hide?: boolean
+}
+
+export const kicadSymbolPinNumbers = z.object({
+  hide: z.boolean().optional(),
+})
+
+type InferredKicadSymbolPinNumbers = z.input<typeof kicadSymbolPinNumbers>
+expectTypesMatch<KicadSymbolPinNumbers, InferredKicadSymbolPinNumbers>(true)
+
+export interface KicadSymbolPinNames {
+  offset?: number | string
+  hide?: boolean
+}
+
+export const kicadSymbolPinNames = z.object({
+  offset: distance.optional(),
+  hide: z.boolean().optional(),
+})
+
+type InferredKicadSymbolPinNames = z.input<typeof kicadSymbolPinNames>
+expectTypesMatch<KicadSymbolPinNames, InferredKicadSymbolPinNames>(true)
+
+export interface KicadSymbolEffects {
+  font?: KicadFont
+  justify?: string | string[]
+  hide?: boolean
+}
+
+export const kicadSymbolEffects = z.object({
+  font: kicadFont.optional(),
+  justify: z.union([z.string(), z.array(z.string())]).optional(),
+  hide: z.boolean().optional(),
+})
+
+type InferredKicadSymbolEffects = z.input<typeof kicadSymbolEffects>
+expectTypesMatch<KicadSymbolEffects, InferredKicadSymbolEffects>(true)
+
+export interface KicadSymbolProperty {
+  value: string
+  id?: number | string
+  at?: KicadAt
+  effects?: KicadSymbolEffects
+}
+
+export const kicadSymbolProperty = z.object({
+  value: z.string(),
+  id: z.union([z.number(), z.string()]).optional(),
+  at: kicadAt.optional(),
+  effects: kicadSymbolEffects.optional(),
+})
+
+type InferredKicadSymbolProperty = z.input<typeof kicadSymbolProperty>
+expectTypesMatch<KicadSymbolProperty, InferredKicadSymbolProperty>(true)
+
+export interface KicadSymbolProperties {
+  Reference?: KicadSymbolProperty
+  Value?: KicadSymbolProperty
+  Footprint?: KicadSymbolProperty
+  Datasheet?: KicadSymbolProperty
+  Description?: KicadSymbolProperty
+  ki_keywords?: KicadSymbolProperty
+  ki_fp_filters?: KicadSymbolProperty
+}
+
+export const kicadSymbolProperties = z.object({
+  Reference: kicadSymbolProperty.optional(),
+  Value: kicadSymbolProperty.optional(),
+  Footprint: kicadSymbolProperty.optional(),
+  Datasheet: kicadSymbolProperty.optional(),
+  Description: kicadSymbolProperty.optional(),
+  ki_keywords: kicadSymbolProperty.optional(),
+  ki_fp_filters: kicadSymbolProperty.optional(),
+})
+
+type InferredKicadSymbolProperties = z.input<typeof kicadSymbolProperties>
+expectTypesMatch<KicadSymbolProperties, InferredKicadSymbolProperties>(true)
+
+export interface KicadSymbolMetadata {
+  symbolName?: string
+  extends?: string
+  pinNumbers?: KicadSymbolPinNumbers
+  pinNames?: KicadSymbolPinNames
+  excludeFromSim?: boolean
+  inBom?: boolean
+  onBoard?: boolean
+  properties?: KicadSymbolProperties
+  embeddedFonts?: boolean
+}
+
+export const kicadSymbolMetadata = z.object({
+  symbolName: z.string().optional(),
+  extends: z.string().optional(),
+  pinNumbers: kicadSymbolPinNumbers.optional(),
+  pinNames: kicadSymbolPinNames.optional(),
+  excludeFromSim: z.boolean().optional(),
+  inBom: z.boolean().optional(),
+  onBoard: z.boolean().optional(),
+  properties: kicadSymbolProperties.optional(),
+  embeddedFonts: z.boolean().optional(),
+})
+
+type InferredKicadSymbolMetadata = z.input<typeof kicadSymbolMetadata>
+expectTypesMatch<KicadSymbolMetadata, InferredKicadSymbolMetadata>(true)

package/lib/common/layout.ts

@@ -10,6 +10,14 @@ import { pcbCoordinate } from "./distance"
 import { z } from "zod"
 import { type CadModelProp, cadModelProp } from "./cadModel"
 import { type FootprintProp, footprintProp } from "./footprintProp"
+import {
+  type KicadFootprintMetadata,
+  kicadFootprintMetadata,
+} from "./kicadFootprintMetadata"
+import {
+  type KicadSymbolMetadata,
+  kicadSymbolMetadata,
+} from "./kicadSymbolMetadata"
 import { pcbStyle, type PcbStyle } from "./pcbStyle"
 import { schStyle, type SchStyle } from "./schStyle"
 import { type SymbolProp, symbolProp } from "./symbolProp"
@@ -248,6 +256,8 @@ export interface CommonComponentProps<PinLabel extends string = string>
   pinAttributes?: Record<PinLabel, PinAttributeMap>
   supplierPartNumbers?: SupplierPartNumbers
   cadModel?: CadModelProp
+  kicadFootprintMetadata?: KicadFootprintMetadata
+  kicadSymbolMetadata?: KicadSymbolMetadata
   children?: any
   symbolName?: string
   doNotPlace?: boolean
@@ -271,6 +281,8 @@ export const commonComponentProps = commonLayoutProps
     displayName: z.string().optional(),
     datasheetUrl: z.string().optional(),
     cadModel: cadModelProp.optional(),
+    kicadFootprintMetadata: kicadFootprintMetadata.optional(),
+    kicadSymbolMetadata: kicadSymbolMetadata.optional(),
     children: z.any().optional(),
     symbolName: z.string().optional(),
     doNotPlace: z.boolean().optional(),

package/lib/index.ts

@@ -14,6 +14,8 @@ export * from "./common/schematicPinStyle"
 export * from "./common/cadModel"
 export * from "./common/schematicPinLabel"
 export * from "./common/schematicSize"
+export * from "./common/kicadFootprintMetadata"
+export * from "./common/kicadSymbolMetadata"
 
 export * from "./components/board"
 export * from "./components/panel"

package/package.json

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