@tscircuit/core 0.0.23 → 0.0.24

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

@@ -50,14 +50,14 @@ export abstract class PrimitiveComponent<
   externallyAddedAliases: string[]
 
   /**
-   * An opaque group is a self-contained subcircuit. All the selectors inside
-   * an opaque group are relative to the group. You can have multiple opaque
-   * groups and their selectors will not interact with each other (even if the
+   * An subcircuit is self-contained. All the selectors inside
+   * a subcircuit are relative to the subcircuit group. You can have multiple
+   * subcircuits and their selectors will not interact with each other (even if the
    * components share the same names) unless you explicitly break out some ports
    */
-  get isOpaqueGroup() {
+  get isSubcircuit() {
     return (
-      Boolean(this.props.opaque) ||
+      Boolean(this.props.subcircuit) ||
       // Implied opaque group for top-level group
       (this.lowercaseComponentName === "group" &&
         this?.parent?.props?.name === "$root")
@@ -212,15 +212,15 @@ export abstract class PrimitiveComponent<
     component.shouldBeRemoved = true
   }
 
-  getOpaqueGroupSelector(): string {
+  getSubcircuitSelector(): string {
     const name = this._parsedProps.name
     const endPart = name
       ? `${this.lowercaseComponentName}.${name}`
       : this.lowercaseComponentName
 
     if (!this.parent) return endPart
-    if (this.parent.isOpaqueGroup) return endPart
-    return `${this.parent.getOpaqueGroupSelector()} > ${endPart}`
+    if (this.parent.isSubcircuit) return endPart
+    return `${this.parent.getSubcircuitSelector()} > ${endPart}`
   }
 
   getFullPathSelector(): string {
@@ -266,9 +266,9 @@ export abstract class PrimitiveComponent<
     return false
   }
 
-  getOpaqueGroup(): PrimitiveComponent {
-    if (this.isOpaqueGroup) return this
-    const group = this.parent?.getOpaqueGroup()
+  getSubcircuit(): PrimitiveComponent {
+    if (this.isSubcircuit) return this
+    const group = this.parent?.getSubcircuit()
     if (!group)
       throw new Error("Component is not inside an opaque group (no board?)")
     return group
@@ -349,6 +349,9 @@ export abstract class PrimitiveComponent<
     if (parent?.props?.name && props?.name) {
       return `<${cname}#${this._renderId}(.${parent?.props.name}>.${props?.name}) />`
     }
+    if (props?.from && props?.to) {
+      return `<${cname}#${this._renderId}(from:${props.from} to:${props?.to}) />`
+    }
     if (props?.name) {
       return `<${cname}#${this._renderId} name=".${props?.name}" />`
     }

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

@@ -3,6 +3,7 @@ import { Component, createElement, type ReactElement } from "react"
 
 export const orderedRenderPhases = [
   "ReactSubtreesRender", // probably going to be removed b/c subtrees should render instantly
+  "CreateNetsFromProps",
   "CreateTracesFromProps",
   "SourceRender",
   "SourceParentAttachment",
@@ -19,6 +20,7 @@ export const orderedRenderPhases = [
   "PcbParentAttachment",
   "PcbLayout",
   "PcbTraceRender",
+  "PcbRouteNetIslands",
   "CadModelRender",
   "PcbAnalysis",
 ] as const

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

@@ -2,11 +2,12 @@ import { boardProps } from "@tscircuit/props"
 import type { z } from "zod"
 import { NormalComponent } from "../base-components/NormalComponent"
 import { identity, type Matrix } from "transformation-matrix"
+import { Group } from "../primitive-components/Group"
 
-export class Board extends NormalComponent<typeof boardProps> {
+export class Board extends Group<typeof boardProps> {
   pcb_board_id: string | null = null
 
-  get isOpaqueGroup() {
+  get isSubcircuit() {
     return true
   }
 

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

@@ -29,17 +29,24 @@ export class Capacitor extends NormalComponent<
   pin1 = this.portMap.pin1
   pin2 = this.portMap.pin2
 
+  doInitialCreateNetsFromProps() {
+    this._createNetsFromProps([
+      this.props.decouplingFor,
+      this.props.decouplingTo,
+    ])
+  }
+
   doInitialCreateTracesFromProps() {
     if (this.props.decouplingFor && this.props.decouplingTo) {
       this.add(
         new Trace({
-          from: `${this.getOpaqueGroupSelector()} > port.1`,
+          from: `${this.getSubcircuitSelector()} > port.1`,
           to: this.props.decouplingFor,
         }),
       )
       this.add(
         new Trace({
-          from: `${this.getOpaqueGroupSelector()} > port.2`,
+          from: `${this.getSubcircuitSelector()} > port.2`,
           to: this.props.decouplingTo,
         }),
       )

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

@@ -4,6 +4,7 @@ import { NormalComponent } from "../base-components/NormalComponent"
 import type { SourceSimpleResistorInput } from "@tscircuit/soup"
 import { z } from "zod"
 import { Trace } from "../primitive-components/Trace"
+import { Net } from "../primitive-components/Net"
 
 export class Resistor extends NormalComponent<
   typeof resistorProps,
@@ -20,22 +21,27 @@ export class Resistor extends NormalComponent<
   pin1 = this.portMap.pin1
   pin2 = this.portMap.pin2
 
+  doInitialCreateNetsFromProps() {
+    this._createNetsFromProps([this.props.pullupFor, this.props.pullupTo])
+  }
+
   doInitialCreateTracesFromProps() {
     if (this.props.pullupFor && this.props.pullupTo) {
       this.add(
         new Trace({
-          from: `${this.getOpaqueGroupSelector()} > port.1`,
+          from: `${this.getSubcircuitSelector()} > port.1`,
           to: this.props.pullupFor,
         }),
       )
       this.add(
         new Trace({
-          from: `${this.getOpaqueGroupSelector()} > port.2`,
+          from: `${this.getSubcircuitSelector()} > port.2`,
           to: this.props.pullupTo,
         }),
       )
     }
   }
+
   doInitialSourceRender() {
     const { db } = this.project!
     const { _parsedProps: props } = this

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

@@ -1,11 +1,15 @@
 import { groupProps } from "@tscircuit/props"
 import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
 import { compose, identity } from "transformation-matrix"
+import { z } from "zod"
+import { NormalComponent } from "../base-components/NormalComponent"
 
-export class Group extends PrimitiveComponent<typeof groupProps> {
+export class Group<
+  Props extends z.ZodType<any, any, any> = typeof groupProps,
+> extends NormalComponent<Props> {
   get config() {
     return {
-      zodProps: groupProps,
+      zodProps: groupProps as unknown as Props,
     }
   }
 }

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

@@ -1,12 +1,171 @@
 import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
 import { z } from "zod"
+import type { Port } from "./Port"
+import type { Trace } from "./Trace"
+import { pairs } from "lib/utils/pairs"
+import type { AnySoupElement, SourceTrace } from "@tscircuit/soup"
+import { autoroute } from "@tscircuit/infgrid-ijump-astar"
 
 export const netProps = z.object({
   name: z.string(),
 })
 
 export class Net extends PrimitiveComponent<typeof netProps> {
+  source_net_id?: string
+
   getPortSelector() {
     return `net.${this.props.name}`
   }
+
+  doInitialSourceComponentRender(): void {
+    const { db } = this.project!
+    const { _parsedProps: props } = this
+
+    const net = db.source_net.insert({
+      name: props.name,
+      member_source_group_ids: [],
+    })
+
+    this.source_net_id = net.source_net_id
+  }
+
+  /**
+   * Get all ports connected to this net.
+   *
+   * TODO currently we're not checking for indirect connections (traces that are
+   * connected to other traces that are in turn connected to the net)
+   */
+  getAllConnectedPorts(): Port[] {
+    const allPorts = this.getSubcircuit().selectAll("port") as Port[]
+    const connectedPorts: Port[] = []
+
+    for (const port of allPorts) {
+      const traces = port._getDirectlyConnectedTraces()
+
+      for (const trace of traces) {
+        if (trace._isExplicitlyConnectedToNet(this)) {
+          connectedPorts.push(port)
+          break
+        }
+      }
+    }
+
+    return connectedPorts
+  }
+
+  /**
+   * Get all traces that are directly connected to this net, i.e. they list
+   * this net in their path, from, or to props
+   */
+  _getAllDirectlyConnectedTraces(): Trace[] {
+    const allTraces = this.getSubcircuit().selectAll("trace") as Trace[]
+    const connectedTraces: Trace[] = []
+
+    for (const trace of allTraces) {
+      if (trace._isExplicitlyConnectedToNet(this)) {
+        connectedTraces.push(trace)
+      }
+    }
+
+    return connectedTraces
+  }
+
+  /**
+   * Add PCB Traces to connect net islands together. A net island is a set of
+   * ports that are connected to each other. If a there are multiple net islands
+   * that means that the net is not fully connected and we need to add traces
+   * such that the nets are fully connected
+   */
+  doInitialPcbRouteNetIslands(): void {
+    const { db } = this.project!
+    const { _parsedProps: props } = this
+
+    const traces = this._getAllDirectlyConnectedTraces().filter(
+      (trace) => (trace._portsRoutedOnPcb?.length ?? 0) > 0,
+    )
+
+    const islands: Array<{ ports: Port[]; traces: Trace[] }> = []
+
+    for (const trace of traces) {
+      const tracePorts = trace._portsRoutedOnPcb
+      const traceIsland = islands.find((island) =>
+        tracePorts.some((port) => island.ports.includes(port)),
+      )
+      if (!traceIsland) {
+        islands.push({ ports: [...tracePorts], traces: [trace] })
+        continue
+      }
+      traceIsland.traces.push(trace)
+      traceIsland.ports.push(...tracePorts)
+    }
+
+    if (islands.length === 0) {
+      return
+    }
+
+    // Connect islands together by looking at each pair of islands and adding
+    // a trace between them
+    const islandPairs = pairs(islands)
+    for (const [A, B] of islandPairs) {
+      // Find two closest ports on the island
+      const Apositions: Array<{ x: number; y: number }> = A.ports.map((port) =>
+        port.getGlobalPcbPosition(),
+      )
+      const Bpositions: Array<{ x: number; y: number }> = B.ports.map((port) =>
+        port.getGlobalPcbPosition(),
+      )
+
+      let closestDist = Infinity
+      let closestPair: [number, number] = [-1, -1]
+      for (let i = 0; i < Apositions.length; i++) {
+        const Apos = Apositions[i]
+        for (let j = 0; j < Bpositions.length; j++) {
+          const Bpos = Bpositions[j]
+          const dist = Math.sqrt(
+            (Apos.x - Bpos.x) ** 2 + (Apos.y - Bpos.y) ** 2,
+          )
+          if (dist < closestDist) {
+            closestDist = dist
+            closestPair = [i, j]
+          }
+        }
+      }
+
+      const Aport = A.ports[closestPair[0]]
+      const Bport = B.ports[closestPair[1]]
+
+      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 { solution } = autoroute(
+        pcbElements.concat([
+          {
+            type: "source_trace",
+            source_trace_id: "__net_trace_tmp",
+            connected_source_port_ids: [
+              Aport.source_port_id!,
+              Bport.source_port_id!,
+            ],
+          } as SourceTrace,
+        ]),
+      )
+
+      const trace = solution[0]
+      if (!trace) {
+        this.renderError("Failed to route net islands")
+        return
+      }
+
+      db.pcb_trace.insert(trace as any)
+    }
+  }
 }

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

@@ -4,6 +4,7 @@ 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"
+import type { Trace } from "./Trace"
 
 export const portProps = z.object({
   name: z.string().optional(),
@@ -90,8 +91,8 @@ export class Port extends PrimitiveComponent<typeof portProps> {
     return this.isMatchingAnyOf(port.getNameAndAliases())
   }
   getPortSelector() {
+    // TODO this.parent.getSubcircuitSelector() >
     return `.${this.parent?.props.name} > port.${this.props.name}`
-    // return `#${this.props.id}`
   }
   getAvailablePcbLayers(): string[] {
     return Array.from(
@@ -99,6 +100,21 @@ export class Port extends PrimitiveComponent<typeof portProps> {
     )
   }
 
+  /**
+   * Return traces that are explicitly connected to this port (not via a net)
+   */
+  _getDirectlyConnectedTraces(): Trace[] {
+    const allSubcircuitTraces = this.getSubcircuit().selectAll(
+      "trace",
+    ) as Trace[]
+
+    const connectedTraces = allSubcircuitTraces.filter((trace) =>
+      trace._isExplicitlyConnectedToPort(this),
+    )
+
+    return connectedTraces
+  }
+
   doInitialSourceRender(): void {
     const { db } = this.project!
     const { _parsedProps: props } = this

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

@@ -12,6 +12,7 @@ import type {
   PCBTrace,
   RouteHintPoint,
   SchematicTrace,
+  SourceTrace,
 } from "@tscircuit/soup"
 import type {
   Obstacle,
@@ -24,6 +25,9 @@ import type { TraceHint } from "./TraceHint"
 import { findPossibleTraceLayerCombinations } from "lib/utils/autorouting/findPossibleTraceLayerCombinations"
 import { pairs } from "lib/utils/pairs"
 import { mergeRoutes } from "lib/utils/autorouting/mergeRoutes"
+import type { Net } from "./Net"
+import { getClosest } from "lib/utils/getClosest"
+import { z } from "zod"
 
 type PcbRouteObjective =
   | RouteHintPoint
@@ -41,6 +45,12 @@ 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
+  _portsRoutedOnPcb: Port[]
+
+  constructor(props: z.input<typeof traceProps>) {
+    super(props)
+    this._portsRoutedOnPcb = []
+  }
 
   get config() {
     return {
@@ -48,7 +58,7 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
     }
   }
 
-  getTracePortPathSelectors(): string[] {
+  _getTracePortOrNetSelectorListFromProps(): string[] {
     if ("from" in this.props && "to" in this.props) {
       return [
         typeof this.props.from === "string"
@@ -67,9 +77,29 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
     return []
   }
 
+  getTracePortPathSelectors(): string[] {
+    return this._getTracePortOrNetSelectorListFromProps().filter(
+      (selector) => !selector.includes("net."),
+    )
+  }
+
+  getTracePathNetSelectors(): string[] {
+    return this._getTracePortOrNetSelectorListFromProps().filter((selector) =>
+      selector.includes("net."),
+    )
+  }
+
   _findConnectedPorts():
-    | { allPortsFound: true; ports: Array<{ selector: string; port: Port }> }
-    | { allPortsFound: false; ports?: undefined } {
+    | {
+        allPortsFound: true
+        ports: Port[]
+        portsWithSelectors: Array<{ selector: string; port: Port }>
+      }
+    | {
+        allPortsFound: false
+        ports?: undefined
+        portsWithSelectors?: undefined
+      } {
     const { db } = this.project!
     const { _parsedProps: props, parent } = this
 
@@ -77,17 +107,17 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
 
     const portSelectors = this.getTracePortPathSelectors()
 
-    const ports = portSelectors.map((selector) => ({
+    const portsWithSelectors = portSelectors.map((selector) => ({
       selector,
       port:
-        (this.getOpaqueGroup().selectOne(selector, { type: "port" }) as Port) ??
+        (this.getSubcircuit().selectOne(selector, { type: "port" }) as Port) ??
         null,
     }))
 
-    for (const { selector, port } of ports) {
+    for (const { selector, port } of portsWithSelectors) {
       if (!port) {
         const parentSelector = selector.replace(/\>.*$/, "")
-        const targetComponent = this.getOpaqueGroup().selectOne(parentSelector)
+        const targetComponent = this.getSubcircuit().selectOne(parentSelector)
         if (!targetComponent) {
           this.renderError(`Could not find port for selector "${selector}"`)
         } else {
@@ -103,11 +133,50 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
       }
     }
 
-    if (ports.some((p) => !p.port)) {
+    if (portsWithSelectors.some((p) => !p.port)) {
       return { allPortsFound: false }
     }
 
-    return { allPortsFound: true, ports }
+    return {
+      allPortsFound: true,
+      portsWithSelectors,
+      ports: portsWithSelectors.map(({ port }) => port),
+    }
+  }
+
+  _findConnectedNets(): Array<{ selector: string; net: Net }> {
+    const nets = this.getTracePathNetSelectors().map((selector) => ({
+      selector,
+      net: this.getSubcircuit().selectOne(selector, { type: "net" }) as Net,
+    }))
+
+    const undefinedNets = nets.filter((n) => !n.net)
+    if (undefinedNets.length > 0) {
+      this.renderError(
+        `Could not find net for selector "${undefinedNets[0].selector}" inside ${this}`,
+      )
+    }
+
+    return nets
+  }
+
+  /**
+   * Determine if a trace is explicitly connected to a port (not via a net)
+   */
+  _isExplicitlyConnectedToPort(port: Port) {
+    const { allPortsFound, portsWithSelectors: portsWithMetadata } =
+      this._findConnectedPorts()
+    if (!allPortsFound) return false
+    const ports = portsWithMetadata.map((p) => p.port)
+    return ports.includes(port)
+  }
+
+  /**
+   * Determine if a trace is explicitly connected to a net (not via a port)
+   */
+  _isExplicitlyConnectedToNet(net: Net) {
+    const nets = this._findConnectedNets().map((n) => n.net)
+    return nets.includes(net)
   }
 
   doInitialSourceTraceRender(): void {
@@ -119,12 +188,15 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
       return
     }
 
-    const { allPortsFound, ports } = this._findConnectedPorts()
+    const { allPortsFound, portsWithSelectors: ports } =
+      this._findConnectedPorts()
     if (!allPortsFound) return
 
+    const nets = this._findConnectedNets()
+
     const trace = db.source_trace.insert({
       connected_source_port_ids: ports.map((p) => p.port.source_port_id!),
-      connected_source_net_ids: [],
+      connected_source_net_ids: nets.map((n) => n.net.source_net_id!),
     })
 
     this.source_trace_id = trace.source_trace_id
@@ -137,9 +209,42 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
     if (!parent) throw new Error("Trace has no parent")
 
     const { allPortsFound, ports } = this._findConnectedPorts()
+    const portsConnectedOnPcbViaNet: Port[] = []
 
     if (!allPortsFound) return
 
+    const nets = this._findConnectedNets()
+
+    if (ports.length === 0 && nets.length === 2) {
+      // Find the two optimal points to connect the two nets
+      this.renderError(
+        `Trace connects two nets, we haven't implemented a way to route this yet`,
+      )
+      return
+      // biome-ignore lint/style/noUselessElse: <explanation>
+    } else if (ports.length === 1 && nets.length === 1) {
+      // Add a port from the net that is closest to the port
+      const port = ports[0]
+      const portsInNet = nets[0].net.getAllConnectedPorts()
+      const otherPortsInNet = portsInNet.filter((p) => p !== port)
+      if (otherPortsInNet.length === 0) {
+        console.log(
+          "Nothing to connect this port to, the net is empty. TODO should emit a warning!",
+        )
+        return
+      }
+      const closestPortInNet = getClosest(port, otherPortsInNet)
+
+      portsConnectedOnPcbViaNet.push(closestPortInNet)
+
+      ports.push(closestPortInNet)
+    } else if (ports.length > 1 && nets.length >= 1) {
+      this.renderError(
+        `Trace has more than one port and one or more nets, we don't currently support this type of complex trace routing`,
+      )
+      return
+    }
+
     const pcbElements: AnySoupElement[] = db
       .toArray()
       .filter(
@@ -154,7 +259,7 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
 
     const source_trace = db.source_trace.get(this.source_trace_id!)!
 
-    const hints = ports.flatMap(({ port }) =>
+    const hints = ports.flatMap((port) =>
       port.matchedComponents.filter((c) => c.componentName === "TraceHint"),
     ) as TraceHint[]
 
@@ -165,7 +270,7 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
     if (ports.length > 2) {
       this.renderError(
         `Trace has more than two ports (${ports
-          .map((p) => p.port.getString())
+          .map((p) => p.getString())
           .join(
             ", ",
           )}), routing between more than two ports for a single trace is not implemented`,
@@ -173,21 +278,50 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
       return
     }
 
+    const alreadyRoutedTraces = this.getSubcircuit()
+      .selectAll("trace")
+      .filter(
+        (trace) => trace.renderPhaseStates.PcbTraceRender.initialized,
+      ) as Trace[]
+
+    const isAlreadyRouted = alreadyRoutedTraces.some(
+      (trace) =>
+        trace._portsRoutedOnPcb.length === ports.length &&
+        trace._portsRoutedOnPcb.every((portRoutedByOtherTrace) =>
+          ports.includes(portRoutedByOtherTrace),
+        ),
+    )
+
+    if (isAlreadyRouted) {
+      return
+    }
+
     if (pcbRouteHints.length === 0) {
-      const { solution } = autoroute(pcbElements.concat([source_trace]))
+      const { solution } = autoroute(
+        pcbElements.concat([
+          {
+            ...source_trace,
+            // manually override b/c some of the ports may be connected via nets
+            // so they don't appear properly in the source_trace, we don't need
+            // to do this if the algorithm correctly looks at connected_source_net_ids
+            connected_source_port_ids: ports.map((p) => p.source_port_id!),
+          } as SourceTrace,
+        ]),
+      )
       // TODO for some reason, the solution gets duplicated inside ijump-astar
       const inputPcbTrace = solution[0]
 
       if (!inputPcbTrace) {
         // TODO render error indicating we could not find a route
         console.log(
-          `Failed to find route ffrom ${ports[0].port} to ${ports[1].port} render error!`,
+          `Failed to find route from ${ports[0]} to ${ports[1]} (TODO render error!)`,
         )
         return
       }
       const pcb_trace = db.pcb_trace.insert(inputPcbTrace as any)
 
       this.pcb_trace_id = pcb_trace.pcb_trace_id
+      this._portsRoutedOnPcb = ports
       return
     }
 
@@ -195,9 +329,9 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
     // terminal of the trace and the hints
     // TODO order based on proximity to ports
     const orderedRouteObjectives: PcbRouteObjective[] = [
-      portToObjective(ports[0].port),
+      portToObjective(ports[0]),
       ...pcbRouteHints,
-      portToObjective(ports[1].port),
+      portToObjective(ports[1]),
     ]
 
     // Hints can indicate where there should be a via, but the layer is allowed
@@ -285,7 +419,8 @@ export class Trace extends PrimitiveComponent<typeof traceProps> {
 
     if (!parent) throw new Error("Trace has no parent")
 
-    const { allPortsFound, ports } = this._findConnectedPorts()
+    const { allPortsFound, portsWithSelectors: ports } =
+      this._findConnectedPorts()
 
     if (!allPortsFound) return
 

package/lib/fiber/intrinsic-jsx.ts

@@ -25,6 +25,7 @@ declare global {
       port: Props.PortProps
       group: Props.GroupProps
       netalias: Props.NetAliasProps
+      net: Props.NetProps
       trace: Props.TraceProps
       custom: any
       component: Props.ComponentProps