@tscircuit/core 0.0.1

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

@@ -0,0 +1,219 @@
+import { traceProps } from "@tscircuit/props"
+import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
+import type { Port } from "./Port"
+import { IJumpAutorouter, autoroute } from "@tscircuit/infgrid-ijump-astar"
+import type { AnySoupElement, SchematicTrace } from "@tscircuit/soup"
+import type {
+  Obstacle,
+  SimpleRouteConnection,
+  SimpleRouteJson,
+} from "lib/utils/autorouting/SimpleRouteJson"
+import { computeObstacleBounds } from "lib/utils/autorouting/computeObstacleBounds"
+import { projectPointInDirection } from "lib/utils/projectPointInDirection"
+
+export class Trace extends PrimitiveComponent<typeof traceProps> {
+  source_trace_id: string | null = null
+  pcb_trace_id: string | null = null
+  schematic_trace_id: string | null = null
+
+  get config() {
+    return {
+      zodProps: traceProps,
+    }
+  }
+
+  getTracePortPathSelectors(): string[] {
+    if ("from" in this.props && "to" in this.props) {
+      return [
+        typeof this.props.from === "string"
+          ? this.props.from
+          : this.props.from.getPortSelector(),
+        typeof this.props.to === "string"
+          ? this.props.to
+          : this.props.to.getPortSelector(),
+      ]
+    }
+    if ("path" in this.props) {
+      return this.props.path.map((p) =>
+        typeof p === "string" ? p : p.getPortSelector(),
+      )
+    }
+    return []
+  }
+
+  _findConnectedPorts():
+    | { allPortsFound: true; ports: Array<{ selector: string; port: Port }> }
+    | { allPortsFound: false; ports?: undefined } {
+    const { db } = this.project!
+    const { _parsedProps: props, parent } = this
+
+    if (!parent) throw new Error("Trace has no parent")
+
+    const portSelectors = this.getTracePortPathSelectors()
+
+    const ports = portSelectors.map((selector) => ({
+      selector,
+      port: parent.selectOne(selector, { type: "port" }) as Port,
+    }))
+
+    for (const { selector, port } of ports) {
+      if (!port) {
+        const parentSelector = selector.replace(/\>.*$/, "")
+        const targetComponent = parent.selectOne(parentSelector)
+        if (!targetComponent) {
+          this.renderError(`Could not find port for selector "${selector}"`)
+        } else {
+          this.renderError(
+            `Could not find port for selector "${selector}"\nsearched component ${targetComponent.getString()}, which has ports:${targetComponent.children
+              .filter((c) => c.componentName === "Port")
+              .map((c) => `  ${c.getString()}`)
+              .join("\n")}`,
+          )
+        }
+      }
+    }
+
+    if (ports.some((p) => !p.port)) {
+      return { allPortsFound: false }
+    }
+
+    return { allPortsFound: true, ports }
+  }
+
+  doInitialSourceTraceRender(): void {
+    const { db } = this.project!
+    const { _parsedProps: props, parent } = this
+
+    if (!parent) {
+      this.renderError("Trace has no parent")
+      return
+    }
+
+    const { allPortsFound, ports } = this._findConnectedPorts()
+    if (!allPortsFound) return
+
+    const trace = db.source_trace.insert({
+      connected_source_port_ids: ports.map((p) => p.port.source_port_id!),
+      connected_source_net_ids: [],
+    })
+
+    this.source_trace_id = trace.source_trace_id
+  }
+
+  doInitialPcbTraceRender(): void {
+    const { db } = this.project!
+    const { _parsedProps: props, parent } = this
+
+    if (!parent) throw new Error("Trace has no parent")
+
+    const { allPortsFound, ports } = this._findConnectedPorts()
+
+    if (!allPortsFound) return
+
+    const pcbElements: AnySoupElement[] = db
+      .toArray()
+      .filter(
+        (elm) =>
+          elm.type === "pcb_smtpad" ||
+          elm.type === "pcb_trace" ||
+          elm.type === "pcb_plated_hole" ||
+          elm.type === "pcb_hole" ||
+          elm.type === "source_port" ||
+          elm.type === "pcb_port",
+      )
+
+    const source_trace = db.source_trace.get(this.source_trace_id!)!
+
+    const { solution } = autoroute(pcbElements.concat([source_trace]))
+
+    // TODO for some reason, the solution gets duplicated. Seems to be an issue
+    // with the ijump-astar function
+    const pcb_trace = solution[0]
+
+    db.pcb_trace.insert(pcb_trace)
+
+    this.pcb_trace_id = pcb_trace.pcb_trace_id
+  }
+
+  doInitialSchematicTraceRender(): void {
+    const { db } = this.project!
+    const { _parsedProps: props, parent } = this
+
+    if (!parent) throw new Error("Trace has no parent")
+
+    const { allPortsFound, ports } = this._findConnectedPorts()
+
+    if (!allPortsFound) return
+
+    const obstacles: Obstacle[] = []
+    const connection: SimpleRouteConnection = {
+      name: this.source_trace_id!,
+      pointsToConnect: [],
+    }
+
+    for (const elm of db.toArray()) {
+      if (elm.type === "schematic_component") {
+        obstacles.push({
+          type: "rect",
+          center: elm.center,
+          width: elm.size.width,
+          height: elm.size.height,
+          connectedTo: [],
+        })
+      }
+    }
+
+    for (const { port } of ports) {
+      connection.pointsToConnect.push(
+        projectPointInDirection(
+          port.getGlobalSchematicPosition(),
+          port.facingDirection!,
+          0.1501,
+        ),
+      )
+    }
+
+    const bounds = computeObstacleBounds(obstacles)
+
+    const simpleRouteJsonInput: SimpleRouteJson = {
+      obstacles,
+      connections: [connection],
+      bounds,
+      layerCount: 1,
+    }
+
+    const autorouter = new IJumpAutorouter({
+      input: simpleRouteJsonInput,
+    })
+    const results = autorouter.solve()
+
+    if (results.length === 0) return
+
+    const [result] = results
+
+    if (!result.solved) return
+
+    const { route } = result
+
+    const edges: SchematicTrace["edges"] = []
+
+    for (let i = 0; i < route.length - 1; i++) {
+      const from = route[i]
+      const to = route[i + 1]
+
+      edges.push({
+        from,
+        to,
+        // TODO to_schematic_port_id and from_schematic_port_id
+      })
+    }
+
+    const trace = db.schematic_trace.insert({
+      source_trace_id: this.source_trace_id!,
+
+      edges,
+    })
+
+    this.schematic_trace_id = trace.schematic_trace_id
+  }
+}

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

@@ -0,0 +1,4 @@
+import { PrimitiveComponent } from "lib/components/base-components/PrimitiveComponent"
+import { traceProps } from "@tscircuit/props"
+
+export class TraceHint extends PrimitiveComponent<typeof traceProps> {}

package/lib/fiber/catalogue.ts

@@ -0,0 +1,22 @@
+// See CATALOGUE.md for information about the catalogue pattern
+// The catalogue is a registry of all the component constructors, it has a
+// bunch of purposes but importantly it reduces circular dependencies.
+
+export type Instance = {
+  // Add any universal methods for classes, e.g. ".add"
+} & { [key: string]: any }
+
+export interface Catalogue {
+  [name: string]: {
+    new (...args: any): Instance
+  }
+}
+
+export const catalogue: Catalogue = {}
+export const extendCatalogue = (objects: object): void => {
+  const altKeys = Object.fromEntries(
+    Object.entries(objects).map(([key, v]) => [key.toLowerCase(), v]),
+  )
+  Object.assign(catalogue, objects)
+  Object.assign(catalogue, altKeys)
+}

package/lib/fiber/create-instance-from-react-element.ts

@@ -0,0 +1,168 @@
+import type React from "react"
+import ReactReconciler, { type HostConfig } from "react-reconciler"
+import { type Renderable } from "lib/components/base-components/Renderable"
+import { type NormalComponent } from "lib/components/base-components/NormalComponent"
+import type { ReactElement, ReactNode } from "react"
+import { catalogue, type Instance } from "./catalogue"
+
+export type ReactSubtree = {
+  element: ReactElement // TODO rename to "reactElement"
+  component: NormalComponent
+}
+
+// biome-ignore lint/suspicious/noEmptyInterface: TODO when we have local state
+interface LocalState {}
+
+export function prepare<T extends Renderable>(
+  object: T,
+  state?: Partial<LocalState>,
+): Instance {
+  const instance = object as unknown as Instance
+  instance.__tsci = {
+    ...state,
+  }
+
+  return object
+}
+
+// Define the host config
+const hostConfig: HostConfig<
+  string | NormalComponent,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any
+> = {
+  supportsMutation: true,
+  createInstance(type: string, props: any) {
+    const target = catalogue[type]
+
+    if (!target) {
+      if (Object.keys(catalogue).length === 0) {
+        throw new Error(
+          "No components registered in catalogue, did you forget to import lib/register-catalogue in your test file?",
+        )
+      }
+      throw new Error(
+        `Unsupported component type (not registered in @tscircuit/core catalogue): ${type}`,
+      )
+    }
+
+    const instance = prepare(new target(props) as any, {})
+
+    return instance
+  },
+  createTextInstance() {
+    // We don't need to handle text nodes for this use case
+    return {}
+  },
+  appendInitialChild(parentInstance: any, child: any) {
+    parentInstance.add(child)
+  },
+  appendChild(parentInstance: any, child: any) {
+    parentInstance.add(child)
+  },
+  appendChildToContainer(container: any, child: any) {
+    container.add(child)
+  },
+  finalizeInitialChildren() {
+    return false
+  },
+  prepareUpdate() {
+    return null
+  },
+  shouldSetTextContent() {
+    return false
+  },
+  getRootHostContext() {
+    return {}
+  },
+  getChildHostContext() {
+    return {}
+  },
+  prepareForCommit() {
+    return null
+  },
+  resetAfterCommit() {},
+  commitMount() {},
+  commitUpdate() {},
+  removeChild() {},
+  clearContainer() {},
+  supportsPersistence: false,
+  getPublicInstance(instance: any) {
+    return instance
+  },
+  preparePortalMount(containerInfo: any): void {
+    throw new Error("Function not implemented.")
+  },
+  scheduleTimeout(fn: (...args: unknown[]) => unknown, delay?: number) {
+    throw new Error("Function not implemented.")
+  },
+  cancelTimeout(id: any): void {
+    throw new Error("Function not implemented.")
+  },
+  noTimeout: undefined,
+  isPrimaryRenderer: false,
+  getCurrentEventPriority(): ReactReconciler.Lane {
+    throw new Error("Function not implemented.")
+  },
+  getInstanceFromNode(node: any): ReactReconciler.Fiber | null | undefined {
+    throw new Error("Function not implemented.")
+  },
+  beforeActiveInstanceBlur(): void {
+    throw new Error("Function not implemented.")
+  },
+  afterActiveInstanceBlur(): void {
+    throw new Error("Function not implemented.")
+  },
+  prepareScopeUpdate: (scopeInstance: any, instance: any): void => {
+    throw new Error("Function not implemented.")
+  },
+  getInstanceFromScope: (scopeInstance: any) => {
+    throw new Error("Function not implemented.")
+  },
+  detachDeletedInstance: (node: any): void => {
+    throw new Error("Function not implemented.")
+  },
+  supportsHydration: false,
+}
+
+const reconciler = ReactReconciler(hostConfig as any)
+
+export const createInstanceFromReactElement = (
+  reactElm: React.ReactElement,
+): NormalComponent => {
+  const container = reconciler.createContainer(
+    // TODO Replace with store like react-three-fiber
+    // https://github.com/pmndrs/react-three-fiber/blob/a457290856f57741bf8beef4f6ff9dbf4879c0a5/packages/fiber/src/core/index.tsx#L172
+    // https://github.com/pmndrs/react-three-fiber/blob/master/packages/fiber/src/core/store.ts#L168
+    {
+      props: {
+        name: "$root",
+      },
+      add(instance: any) {
+        instance.parent = this
+      },
+    },
+    0,
+    null,
+    false,
+    null,
+    "tsci",
+    (error: Error) => {
+      console.log("Error in createContainer")
+      console.error(error)
+    },
+    null,
+  )
+  reconciler.updateContainer(reactElm, container, null, () => {})
+  return reconciler.getPublicRootInstance(container) as NormalComponent
+}

package/lib/fiber/intrinsic-jsx.ts

@@ -0,0 +1,43 @@
+import type * as Props from "@tscircuit/props"
+
+declare global {
+  namespace JSX {
+    interface IntrinsicElements {
+      resistor: Props.ResistorProps
+      capacitor: Props.CapacitorProps
+      inductor: Props.InductorProps
+      diode: Props.DiodeProps
+      led: Props.LedProps
+      board: Props.BoardProps
+      bug: Props.ChipProps
+      // TODO use ChipProps once it gets merged in @tscircuit/props
+      chip: Props.ChipProps
+      powersource: Props.PowerSourceProps
+      via: Props.ViaProps
+      schematicbox: Props.SchematicBoxProps
+      schematicline: Props.SchematicLineProps
+      schematicpath: Props.SchematicPathProps
+      schematictext: Props.SchematicTextProps
+      smtpad: Props.SmtPadProps
+      platedhole: Props.PlatedHoleProps
+      hole: Props.HoleProps
+      port: Props.PortProps
+      group: Props.GroupProps
+      netalias: Props.NetAliasProps
+      trace: Props.TraceProps
+      custom: any
+      component: Props.ComponentProps
+      footprint: any
+      silkscreentext: Props.SilkscreenTextProps
+      silkscreenpath: Props.SilkscreenPathProps
+      silkscreenline: Props.SilkscreenLineProps
+      silkscreenrect: Props.SilkscreenRectProps
+      silkscreencircle: Props.SilkscreenCircleProps
+      tracehint: Props.TraceHintProps
+      pcbtrace: Props.PcbTraceProps
+      fabricationnotetext: Props.FabricationNoteTextProps
+      fabricationnotepath: Props.FabricationNotePathProps
+      jscad: any
+    }
+  }
+}

package/lib/index.ts

@@ -0,0 +1,5 @@
+export * from "./components"
+export * from "./Project"
+
+import "./register-catalogue"
+import "./fiber/intrinsic-jsx"

package/lib/register-catalogue.ts

@@ -0,0 +1,3 @@
+import * as Components from "./components"
+import { extendCatalogue } from "./fiber/catalogue"
+extendCatalogue(Components)

package/lib/utils/autorouting/SimpleRouteJson.ts

@@ -0,0 +1,37 @@
+export type SimplifiedPcbTrace = {
+  type: "pcb_trace"
+  pcb_trace_id: string
+  route: Array<{
+    route_type: "wire" | "via"
+    x: number
+    y: number
+    width: number
+    layer: string
+  }>
+}
+export type Obstacle = {
+  // TODO include ovals
+  type: "rect" // NOTE: most datasets do not contain ovals
+  center: { x: number; y: number }
+  width: number
+  height: number
+  connectedTo: string[]
+}
+
+export interface SimpleRouteConnection {
+  name: string
+  pointsToConnect: Array<{ x: number; y: number }>
+}
+
+export interface SimpleRouteJson {
+  layerCount: number
+  obstacles: Obstacle[]
+  connections: Array<SimpleRouteConnection>
+  bounds: { minX: number; maxX: number; minY: number; maxY: number }
+}
+
+// declare module "autorouting-dataset" {
+//   export type Obstacle = SimpleRouteJson["obstacles"][number]
+//   export type SimpleRouteConnection = SimpleRouteJson["connections"][number]
+//   export type SimplifiedPcbTrace = SimpleRouteJson["connections"][number]
+// }

package/lib/utils/autorouting/computeObstacleBounds.ts

@@ -0,0 +1,10 @@
+import type { Obstacle } from "./SimpleRouteJson"
+
+export const computeObstacleBounds = (obstacles: Array<Obstacle>) => {
+  const minX = Math.min(...obstacles.map((o) => o.center.x))
+  const maxX = Math.max(...obstacles.map((o) => o.center.x))
+  const minY = Math.min(...obstacles.map((o) => o.center.y))
+  const maxY = Math.max(...obstacles.map((o) => o.center.y))
+
+  return { minX, maxX, minY, maxY }
+}

package/lib/utils/constants.ts

@@ -0,0 +1,35 @@
+import type { AnySourceComponent } from "@tscircuit/soup"
+import type { BaseSymbolName } from "schematic-symbols"
+
+/**
+ * This is just a proxy to make autocomplete easier, it just returns whatever
+ * key you pass in. It's helpful when you want to make it a bit more obvious
+ * how to select the key you want to use without obscuring the actual key.
+ */
+const stringProxy = new Proxy(
+  {},
+  {
+    get: (target, prop) => prop,
+  },
+) as any
+
+export type Ftype = AnySourceComponent["ftype"]
+
+export const FTYPE: {
+  [T in AnySourceComponent["ftype"]]: T
+} = stringProxy
+
+export const SYMBOL: {
+  [T in BaseSymbolName]: T
+} = stringProxy
+
+export type TwoPinPorts = "pin1" | "pin2"
+export type PassivePorts = TwoPinPorts
+export type PolarizedPassivePorts =
+  | PassivePorts
+  | "anode"
+  | "cathode"
+  | "pos"
+  | "neg"
+
+export type { BaseSymbolName }

package/lib/utils/createComponentsFromSoup.ts

@@ -0,0 +1,86 @@
+import type { AnySoupElement } from "@tscircuit/soup"
+import type { PrimitiveComponent } from "../components/base-components/PrimitiveComponent"
+import { SmtPad } from "lib/components/primitive-components/SmtPad"
+
+export const createComponentsFromSoup = (
+  soup: AnySoupElement[],
+): PrimitiveComponent[] => {
+  const components: PrimitiveComponent[] = []
+  for (const elm of soup) {
+    if (elm.type === "pcb_smtpad" && elm.shape === "rect") {
+      components.push(
+        new SmtPad({
+          pcbX: elm.x,
+          pcbY: elm.y,
+          layer: elm.layer,
+          shape: "rect",
+          height: elm.height,
+          width: elm.width,
+          portHints: elm.port_hints,
+        }),
+      )
+    } else if (elm.type === "pcb_smtpad" && elm.shape === "circle") {
+      components.push(
+        new SmtPad({
+          pcbX: elm.x,
+          pcbY: elm.y,
+          layer: elm.layer,
+          shape: "circle",
+          radius: elm.radius,
+          portHints: elm.port_hints,
+        }),
+      )
+    }
+  }
+  return components
+  //   if (elm.type === "pcb_smtpad") {
+  //     this.add("smtpad", (pb) => pb.setProps(elm))
+  //   } else if (elm.type === "pcb_plated_hole") {
+  //     this.add("platedhole", (pb) => pb.setProps(elm))
+  //   } else if (elm.type === "pcb_hole") {
+  //     this.add("hole", (pb) => pb.setProps(elm))
+  //   } else if (elm.type === "pcb_silkscreen_circle") {
+  //     this.add("silkscreencircle", (pb) =>
+  //       pb.setProps({
+  //         ...elm,
+  //         pcbX: elm.center.x,
+  //         pcbY: elm.center.y,
+  //       })
+  //     )
+  //   } else if (elm.type === "pcb_silkscreen_line") {
+  //     this.add("silkscreenline", (pb) =>
+  //       pb.setProps({
+  //         ...elm,
+  //         strokeWidth: elm.stroke_width,
+  //       })
+  //     )
+  //   } else if (elm.type === "pcb_silkscreen_path") {
+  //     this.add("silkscreenpath", (pb) =>
+  //       pb.setProps({
+  //         ...elm,
+  //         strokeWidth: elm.stroke_width,
+  //       })
+  //     )
+  //   } else if (elm.type === "pcb_silkscreen_rect") {
+  //     this.add("silkscreenrect", (pb) =>
+  //       pb.setProps({
+  //         ...elm,
+  //         pcbX: elm.center.x,
+  //         pcbY: elm.center.y,
+  //         // TODO silkscreen rect isFilled, isOutline etc.
+  //       })
+  //     )
+  //   } else if (elm.type === "pcb_fabrication_note_path") {
+  //     this.add("fabricationnotepath", (pb) => pb.setProps(elm))
+  //   } else if (elm.type === "pcb_fabrication_note_text") {
+  //     this.add("fabricationnotetext", (pb) =>
+  //       pb.setProps({
+  //         ...elm,
+  //         pcbX: elm.anchor_position.x,
+  //         pcbY: elm.anchor_position.y,
+  //         anchorAlignment: elm.anchor_alignment,
+  //         fontSize: elm.font_size,
+  //       })
+  //     )
+  //   }
+}

package/lib/utils/get-relative-direction.ts

@@ -0,0 +1,14 @@
+// Return "up", "down", "left", or "right" based on the angle between two points
+// A & B. The direction is relative to A. So if B is to the right of A, the
+// direction is "right". The largest distance wins
+export function getRelativeDirection(
+  pointA: { x: number; y: number },
+  pointB: { x: number; y: number },
+): "up" | "down" | "left" | "right" {
+  const dx = pointB.x - pointA.x
+  const dy = pointB.y - pointA.y
+  if (Math.abs(dx) > Math.abs(dy)) {
+    return dx > 0 ? "right" : "left"
+  }
+  return dy > 0 ? "down" : "up"
+}

package/lib/utils/getPortFromHints.ts

@@ -0,0 +1,10 @@
+import { Port } from "lib/components/primitive-components/Port"
+
+export function getPortFromHints(hints: string[]): Port | null {
+  const pinNumber = hints.find((p) => /^(pin)?\d+$/.test(p))
+  if (!pinNumber) return null
+  return new Port({
+    pinNumber: Number.parseInt(pinNumber.replace(/^pin/, "")),
+    aliases: hints.filter((p) => p !== pinNumber),
+  })
+}

package/lib/utils/projectPointInDirection.ts

@@ -0,0 +1,18 @@
+export const projectPointInDirection = (
+  point: { x: number; y: number },
+  direction: "up" | "down" | "left" | "right",
+  distance: number,
+) => {
+  switch (direction) {
+    case "up":
+      return { x: point.x, y: point.y - distance }
+    case "down":
+      return { x: point.x, y: point.y + distance }
+    case "left":
+      return { x: point.x - distance, y: point.y }
+    case "right":
+      return { x: point.x + distance, y: point.y }
+    default:
+      throw new Error(`Unknown direction "${direction}"`)
+  }
+}