@tscircuit/core 0.0.1

package/lib/components/base-components/Renderable.ts

@@ -0,0 +1,113 @@
+import type { PCBPlacementError, PCBTraceError } from "@tscircuit/soup"
+import { Component, createElement, type ReactElement } from "react"
+
+export const orderedRenderPhases = [
+  "ReactSubtreesRender", // probably going to be removed b/c subtrees should render instantly
+  "SourceRender",
+  "SourceParentAttachment",
+  "PortDiscovery", // probably going to be removed b/c port discovery can always be done on prop change
+  "PortMatching",
+  "SourceTraceRender",
+  "SchematicComponentRender",
+  "SchematicLayout",
+  "SchematicPortRender",
+  "SchematicTraceRender",
+  "PcbComponentRender",
+  "PcbPortRender",
+  "PcbPrimitiveRender",
+  "PcbParentAttachment",
+  "PcbLayout",
+  "PcbTraceRender",
+  "CadModelRender",
+  "PcbAnalysis",
+] as const
+
+export type RenderPhase = (typeof orderedRenderPhases)[number]
+
+export type RenderPhaseFn<K extends RenderPhase = RenderPhase> =
+  | `doInitial${K}`
+  | `update${K}`
+  | `remove${K}`
+
+export type RenderPhaseStates = Record<RenderPhase, { initialized: boolean }>
+
+export type RenderPhaseFunctions = {
+  [T in RenderPhaseFn]?: () => void
+}
+
+export type IRenderable = RenderPhaseFunctions & {
+  renderPhaseStates: RenderPhaseStates
+  runRenderPhase(phase: RenderPhase): void
+  runRenderPhaseForChildren(phase: RenderPhase): void
+  shouldBeRemoved: boolean
+  children: IRenderable[]
+  runRenderCycle(): void
+}
+
+let globalRenderCounter = 0
+export abstract class Renderable implements IRenderable {
+  renderPhaseStates: RenderPhaseStates
+  shouldBeRemoved = false
+  children: IRenderable[]
+
+  /** PCB-only SMTPads, PlatedHoles, Holes, Silkscreen elements etc. */
+  isPcbPrimitive = false
+  /** Schematic-only, lines, boxes, indicators etc. */
+  isSchematicPrimitive = false
+
+  _renderId: string
+
+  constructor(props: any) {
+    this._renderId = `${globalRenderCounter++}`
+    this.children = []
+    this.renderPhaseStates = {} as RenderPhaseStates
+    for (const phase of orderedRenderPhases) {
+      this.renderPhaseStates[phase] = { initialized: false }
+    }
+  }
+
+  runRenderCycle() {
+    for (const renderPhase of orderedRenderPhases) {
+      this.runRenderPhaseForChildren(renderPhase)
+      this.runRenderPhase(renderPhase)
+    }
+  }
+
+  /**
+   * This runs all the render methods for a given phase, calling one of:
+   * - doInitial*
+   * - update*
+   *  -remove*
+   *  ...depending on the current state of the component.
+   */
+  runRenderPhase(phase: RenderPhase) {
+    const isInitialized = this.renderPhaseStates[phase].initialized
+    if (!isInitialized && this.shouldBeRemoved) return
+    if (this.shouldBeRemoved && isInitialized) {
+      ;(this as any)?.[`remove${phase}`]?.()
+      this.renderPhaseStates[phase].initialized = false
+      return
+    }
+    if (isInitialized) {
+      ;(this as any)?.[`update${phase}`]?.()
+      return
+    }
+    ;(this as any)?.[`doInitial${phase}`]?.()
+    this.renderPhaseStates[phase].initialized = true
+  }
+
+  runRenderPhaseForChildren(phase: RenderPhase): void {
+    for (const child of this.children) {
+      child.runRenderPhaseForChildren(phase)
+      child.runRenderPhase(phase)
+    }
+  }
+
+  renderError(message: string | PCBTraceError | PCBPlacementError) {
+    // TODO add to render phase error list and try to add position or
+    // relationships etc.
+    if (typeof message === "string") {
+      throw new Error(message)
+    }
+  }
+}

package/lib/components/index.ts

@@ -0,0 +1,14 @@
+export { NormalComponent } from "./base-components/NormalComponent"
+export { PrimitiveComponent } from "./base-components/PrimitiveComponent"
+export { Renderable, type IRenderable } from "./base-components/Renderable"
+export { Board } from "./normal-components/Board"
+export { Footprint } from "./primitive-components/Footprint"
+export { SmtPad } from "./primitive-components/SmtPad"
+export { Port } from "./primitive-components/Port"
+export { Resistor } from "./normal-components/Resistor"
+export { Led } from "./normal-components/Led"
+export { Capacitor } from "./normal-components/Capacitor"
+export { Net } from "./primitive-components/Net"
+export { Trace } from "./primitive-components/Trace"
+export { TraceHint } from "./primitive-components/TraceHint"
+export { Group } from "./primitive-components/Group"

package/lib/components/normal-components/Board.ts

@@ -0,0 +1,38 @@
+import { boardProps } from "@tscircuit/props"
+import type { z } from "zod"
+import { NormalComponent } from "../base-components/NormalComponent"
+import { identity, type Matrix } from "transformation-matrix"
+
+export class Board extends NormalComponent<typeof boardProps> {
+  pcb_board_id: string | null = null
+
+  get config() {
+    return {
+      zodProps: boardProps,
+    }
+  }
+
+  doInitialPcbComponentRender(): void {
+    const { db } = this.project!
+    const { _parsedProps: props } = this
+
+    const pcb_board = db.pcb_board.insert({
+      center: { x: props.pcbX, y: props.pcbY },
+      width: props.width,
+      height: props.height,
+    })
+
+    this.pcb_board_id = pcb_board.pcb_board_id
+  }
+
+  removePcbComponentRender(): void {
+    const { db } = this.project!
+    if (!this.pcb_board_id) return
+    db.pcb_board.delete(this.pcb_board_id!)
+    this.pcb_board_id = null
+  }
+
+  computePcbGlobalTransform(): Matrix {
+    return identity()
+  }
+}

package/lib/components/normal-components/Capacitor.ts

@@ -0,0 +1,23 @@
+import { ledProps } from "@tscircuit/props"
+import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
+import { FTYPE, SYMBOL } from "lib/utils/constants"
+
+type PortNames =
+  | "1"
+  | "2"
+  | "pin1"
+  | "pin2"
+  | "left"
+  | "right"
+  | "anode"
+  | "cathode"
+
+export class Capacitor extends PrimitiveComponent<typeof ledProps, PortNames> {
+  get config() {
+    return {
+      // schematicSymbolName: BASE_SYMBOLS.capacitor,
+      zodProps: ledProps,
+      sourceFtype: FTYPE.simple_capacitor,
+    }
+  }
+}

package/lib/components/normal-components/Diode.ts

@@ -0,0 +1,27 @@
+import { diodeProps } from "@tscircuit/props"
+import {
+  FTYPE,
+  SYMBOL,
+  type Ftype,
+  type TwoPinPorts,
+} from "lib/utils/constants"
+import { Port } from "../primitive-components/Port"
+import { NormalComponent } from "../base-components/NormalComponent"
+
+export class Diode extends NormalComponent<typeof diodeProps, TwoPinPorts> {
+  pin1 = this.portMap.pin1
+  pin2 = this.portMap.pin2
+
+  get config() {
+    return {
+      // schematicSymbolName: "diode" as BaseSymbolName,
+      zodProps: diodeProps,
+      sourceFtype: "simple_diode" as Ftype,
+    }
+  }
+
+  initPorts() {
+    this.add(new Port({ name: "pin1", aliases: ["1", "pin1"] }))
+    this.add(new Port({ name: "pin2", aliases: ["2", "pin2"] }))
+  }
+}

package/lib/components/normal-components/Led.ts

@@ -0,0 +1,27 @@
+import { ledProps } from "@tscircuit/props"
+import type {
+  BaseSymbolName,
+  Ftype,
+  PolarizedPassivePorts,
+} from "lib/utils/constants"
+import { NormalComponent } from "../base-components/NormalComponent"
+
+export class Led extends NormalComponent<
+  typeof ledProps,
+  PolarizedPassivePorts
+> {
+  get config() {
+    return {
+      schematicSymbolName: "led" as BaseSymbolName,
+      zodProps: ledProps,
+      sourceFtype: "simple_diode" as Ftype,
+    }
+  }
+
+  pos = this.portMap.pin1
+  pin1 = this.portMap.pin1
+  anode = this.portMap.pin1
+  neg = this.portMap.pin2
+  pin2 = this.portMap.pin2
+  cathode = this.portMap.pin2
+}

package/lib/components/normal-components/Resistor.ts

@@ -0,0 +1,19 @@
+import { resistorProps } from "@tscircuit/props"
+import type { PassivePorts, Ftype, BaseSymbolName } from "lib/utils/constants"
+import { NormalComponent } from "../base-components/NormalComponent"
+
+export class Resistor extends NormalComponent<
+  typeof resistorProps,
+  PassivePorts
+> {
+  get config() {
+    return {
+      schematicSymbolName: "boxresistor" as BaseSymbolName,
+      zodProps: resistorProps,
+      sourceFtype: "simple_resistor" as Ftype,
+    }
+  }
+
+  pin1 = this.portMap.pin1
+  pin2 = this.portMap.pin2
+}

package/lib/components/primitive-components/Footprint.ts

@@ -0,0 +1,4 @@
+import type { footprintProps } from "@tscircuit/props"
+import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
+
+export class Footprint extends PrimitiveComponent<typeof footprintProps> {}

package/lib/components/primitive-components/Group.ts

@@ -0,0 +1,10 @@
+import { groupProps } from "@tscircuit/props"
+import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
+
+export class Group extends PrimitiveComponent<typeof groupProps> {
+  get config() {
+    return {
+      zodProps: groupProps,
+    }
+  }
+}

package/lib/components/primitive-components/Net.ts

@@ -0,0 +1,12 @@
+import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
+import { z } from "zod"
+
+export const netProps = z.object({
+  name: z.string(),
+})
+
+export class Net extends PrimitiveComponent<typeof netProps> {
+  getPortSelector() {
+    return `net.${this.props.name}`
+  }
+}

package/lib/components/primitive-components/Port.ts

@@ -0,0 +1,187 @@
+import type { PCBSMTPad } from "@tscircuit/soup"
+import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
+import { z } from "zod"
+import { getRelativeDirection } from "lib/utils/get-relative-direction"
+import { symbols, type SchSymbol } from "schematic-symbols"
+import { applyToPoint, compose, translate } from "transformation-matrix"
+
+export const portProps = z.object({
+  name: z.string().optional(),
+  pinNumber: z.number().optional(),
+  aliases: z.array(z.string()).optional(),
+})
+
+export type PortProps = z.infer<typeof portProps>
+
+export class Port extends PrimitiveComponent<typeof portProps> {
+  source_port_id: string | null = null
+  pcb_port_id: string | null = null
+  schematic_port_id: string | null = null
+
+  schematicSymbolPortDef: SchSymbol["ports"][number] | null = null
+  matchedComponents: PrimitiveComponent[]
+  facingDirection: "up" | "down" | "left" | "right" | null = null
+
+  constructor(props: z.input<typeof portProps>) {
+    if (!props.name && props.pinNumber) props.name = `pin${props.pinNumber}`
+    if (!props.name) {
+      throw new Error("Port must have a name or a pinNumber")
+    }
+    super(props)
+    this.matchedComponents = []
+  }
+
+  getGlobalPcbPosition(): { x: number; y: number } {
+    const matchedPcbElm = this.matchedComponents.find((c) => c.isPcbPrimitive)
+
+    if (!matchedPcbElm) {
+      throw new Error(
+        `Port ${this} has no matched pcb component, can't get global schematic position`,
+      )
+    }
+
+    return matchedPcbElm?.getGlobalPcbPosition() ?? { x: 0, y: 0 }
+  }
+
+  getGlobalSchematicPosition(): { x: number; y: number } {
+    if (!this.schematicSymbolPortDef) {
+      throw new Error(
+        `Could not find schematic symbol port for port ${this} so couldn't determine port position`,
+      )
+    }
+
+    const symbol = this.parent?.getSchematicSymbol()
+    if (!symbol) throw new Error(`Could not find parent symbol for ${this}`)
+
+    const transform = compose(
+      this.parent!.computeSchematicGlobalTransform(),
+      translate(-symbol.center.x, -symbol.center.y),
+    )
+
+    return applyToPoint(transform, this.schematicSymbolPortDef)
+  }
+
+  /**
+   * Smtpads and platedholes call this method to register themselves as a match
+   * for this port. All the matching is done by primitives other than the Port,
+   * but everyone registers themselves as a match with their Port.
+   */
+  registerMatch(component: PrimitiveComponent) {
+    this.matchedComponents.push(component)
+  }
+  getNameAndAliases() {
+    const { _parsedProps: props } = this
+    return Array.from(
+      new Set([
+        ...(props.aliases ?? []),
+        props.name,
+        ...(typeof props.pinNumber === "number"
+          ? [`pin${props.pinNumber}`, props.pinNumber.toString()]
+          : []),
+      ]),
+    ) as string[]
+  }
+  isMatchingPort(port: Port) {
+    return this.isMatchingAnyOf(port.getNameAndAliases())
+  }
+  getPortSelector() {
+    return `.${this.parent?.props.name} > port.${this.props.name}`
+    // return `#${this.props.id}`
+  }
+
+  doInitialSourceRender(): void {
+    const { db } = this.project!
+    const { _parsedProps: props } = this
+
+    const port_hints = this.getNameAndAliases()
+
+    const source_port = db.source_port.insert({
+      name: props.name!,
+      pin_number: props.pinNumber,
+      port_hints,
+      source_component_id: this.parent?.source_component_id!,
+    })
+
+    this.source_port_id = source_port.source_port_id
+  }
+
+  doInitialSourceParentAttachment(): void {
+    const { db } = this.project!
+    if (!this.parent?.source_component_id) {
+      throw new Error(
+        `${this.getString()} has no parent source component (parent: ${this.parent?.getString()})`,
+      )
+    }
+
+    db.source_port.update(this.source_port_id!, {
+      source_component_id: this.parent?.source_component_id!,
+    })
+
+    this.source_component_id = this.parent?.source_component_id
+  }
+
+  /**
+   * For PcbPorts, we use the parent attachment phase to determine where to place
+   * the pcb_port (prior to this phase, the smtpad/platedhole isn't guaranteed
+   * to exist)
+   */
+  doInitialPcbPortRender(): void {
+    const { db } = this.project!
+    const { matchedComponents } = this
+
+    if (!this.parent?.pcb_component_id) {
+      throw new Error(
+        `${this.getString()} has no parent pcb component, cannot render pcb_port (parent: ${this.parent?.getString()})`,
+      )
+    }
+
+    const pcbMatches = matchedComponents.filter((c) => c.isPcbPrimitive)
+
+    if (pcbMatches.length === 0) return
+
+    if (pcbMatches.length > 1) {
+      throw new Error(
+        `${this.getString()} has multiple pcb matches, unclear how to place pcb_port: ${pcbMatches.map((c) => c.getString()).join(", ")}`,
+      )
+    }
+
+    const pcbMatch: any = pcbMatches[0]
+
+    if ("getGlobalPcbPosition" in pcbMatch) {
+      const pcb_port = db.pcb_port.insert({
+        pcb_component_id: this.parent?.pcb_component_id!,
+        layers: ["top"],
+
+        ...pcbMatch.getGlobalPcbPosition(),
+
+        source_port_id: this.source_port_id!,
+      })
+      this.pcb_port_id = pcb_port.pcb_port_id
+    } else {
+      throw new Error(
+        `${pcbMatch.getString()} does not have a getGlobalPcbPosition method (needed for pcb_port placement)`,
+      )
+    }
+  }
+
+  doInitialSchematicPortRender(): void {
+    const { db } = this.project!
+    const { _parsedProps: props } = this
+
+    if (!this.parent) return
+
+    const center = this.getGlobalSchematicPosition()
+    const parentCenter = this.parent?.getGlobalSchematicPosition()
+
+    this.facingDirection = getRelativeDirection(parentCenter, center)
+
+    const schematic_port = db.schematic_port.insert({
+      schematic_component_id: this.parent?.schematic_component_id!,
+      center,
+      source_port_id: this.source_port_id!,
+      facing_direction: this.facingDirection,
+    })
+
+    this.schematic_port_id = schematic_port.schematic_port_id
+  }
+}

package/lib/components/primitive-components/SmtPad.ts

@@ -0,0 +1,80 @@
+import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
+import { smtPadProps } from "@tscircuit/props"
+import type { Port } from "./Port"
+import type { RenderPhaseFn } from "../base-components/Renderable"
+import type { PCBSMTPad } from "@tscircuit/soup"
+
+export class SmtPad extends PrimitiveComponent<typeof smtPadProps> {
+  pcb_smtpad_id: string | null = null
+
+  matchedPort: Port | null = null
+
+  isPcbPrimitive = true
+
+  get config() {
+    return {
+      zodProps: smtPadProps,
+    }
+  }
+
+  doInitialPortMatching(): void {
+    const parentPorts = (this.parent?.children ?? []).filter(
+      (c) => c.componentName === "Port",
+    ) as Port[]
+
+    if (!this.props.portHints) {
+      return
+    }
+
+    for (const port of parentPorts) {
+      if (port.isMatchingAnyOf(this.props.portHints)) {
+        this.matchedPort = port
+        port.registerMatch(this)
+        return
+      }
+    }
+  }
+
+  doInitialPcbPrimitiveRender(): void {
+    const { db } = this.project!
+    const { _parsedProps: props } = this
+    if (!props.portHints) return
+    const position = this.getGlobalPcbPosition()
+    let pcb_smtpad: PCBSMTPad | null = null
+    if (props.shape === "circle") {
+      pcb_smtpad = db.pcb_smtpad.insert({
+        pcb_component_id: this.parent?.pcb_component_id!,
+        pcb_port_id: this.matchedPort?.pcb_port_id!,
+        layer: props.layer ?? "top",
+        shape: "circle",
+
+        // @ts-ignore: no idea why this is triggering
+        radius: props.radius!,
+
+        port_hints: props.portHints.map((ph) => ph.toString()),
+
+        x: position.x,
+        y: position.y,
+      })
+    } else if (props.shape === "rect") {
+      pcb_smtpad = db.pcb_smtpad.insert({
+        pcb_component_id: this.parent?.pcb_component_id!,
+        pcb_port_id: this.matchedPort?.pcb_port_id!,
+        layer: props.layer ?? "top",
+        shape: "rect",
+
+        // @ts-ignore: no idea why this is triggering
+        width: props.width,
+        height: props.height,
+
+        port_hints: props.portHints.map((ph) => ph.toString()),
+
+        x: position.x,
+        y: position.y,
+      })
+    }
+    if (pcb_smtpad) {
+      this.pcb_smtpad_id = pcb_smtpad.pcb_smtpad_id
+    }
+  }
+}