@tscircuit/core 0.0.73 → 0.0.75

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

@@ -1,239 +0,0 @@
-import type { footprintProps } from "@tscircuit/props"
-import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
-import type { Constraint } from "./Constraint"
-import * as kiwi from "@lume/kiwi"
-import Debug from "debug"
-
-const debug = Debug("tscircuit:core:footprint")
-
-export class Footprint extends PrimitiveComponent<typeof footprintProps> {
-  /**
-   * A footprint is a constrainedlayout, the db elements are adjusted according
-   * to any constraints that are defined.
-   */
-  doInitialPcbFootprintLayout() {
-    const constraints = this.children.filter(
-      (child) => child.componentName === "Constraint",
-    ) as Constraint[]
-
-    if (constraints.length === 0) return
-
-    const involvedComponents = constraints
-      .flatMap(
-        (constraint) =>
-          constraint._getAllReferencedComponents().componentsWithSelectors,
-      )
-      .map(({ component, selector, componentSelector, edge }) => ({
-        component,
-        selector,
-        componentSelector,
-        edge,
-        bounds: component._getPcbCircuitJsonBounds(),
-      }))
-
-    if (involvedComponents.some((c) => c.edge)) {
-      throw new Error(
-        "edge constraints not implemented yet for footprint layout, contributions welcome!",
-      )
-    }
-
-    function getComponentDetails(selector: string) {
-      return involvedComponents.find(({ selector: s }) => s === selector)
-    }
-
-    const solver = new kiwi.Solver()
-
-    const kVars: { [varName: string]: kiwi.Variable } = {}
-    function getKVar(name: string) {
-      if (!(name in kVars)) {
-        kVars[name] = new kiwi.Variable(name)
-        solver.addEditVariable(kVars[name], kiwi.Strength.weak)
-      }
-      return kVars[name]
-    }
-
-    // 1. Create kiwi variables to represent each component's center
-    for (const { selector, bounds } of involvedComponents) {
-      const kvx = getKVar(`${selector}_x`)
-      const kvy = getKVar(`${selector}_y`)
-      solver.suggestValue(kvx, bounds.center.x)
-      solver.suggestValue(kvy, bounds.center.y)
-    }
-
-    // 2. Add kiwi constraints using the parsed constraint properties
-    for (const constraint of constraints) {
-      const props = constraint._parsedProps
-
-      if ("xDist" in props) {
-        const { xDist, left, right, edgeToEdge, centerToCenter } = props
-        const leftVar = getKVar(`${left}_x`)
-        const rightVar = getKVar(`${right}_x`)
-        const leftBounds = getComponentDetails(left)?.bounds!
-        const rightBounds = getComponentDetails(right)?.bounds!
-
-        if (centerToCenter) {
-          // right - left = xdist
-          const expr = new kiwi.Expression(rightVar, [-1, leftVar])
-          solver.addConstraint(
-            new kiwi.Constraint(
-              expr,
-              kiwi.Operator.Eq,
-              props.xDist,
-              kiwi.Strength.required,
-            ),
-          )
-        } else if (edgeToEdge) {
-          // rightEdge - leftEdge = xdist
-          // right - rightBounds.width/2 - left - leftBounds.width/2 = xdist
-          const expr = new kiwi.Expression(
-            rightVar,
-            -rightBounds.width / 2,
-            [-1, leftVar],
-            -leftBounds.width / 2,
-          )
-          solver.addConstraint(
-            new kiwi.Constraint(
-              expr,
-              kiwi.Operator.Eq,
-              props.xDist,
-              kiwi.Strength.required,
-            ),
-          )
-        }
-      } else if ("yDist" in props) {
-        const { yDist, top, bottom, edgeToEdge, centerToCenter } = props
-        const topVar = getKVar(`${top}_y`)
-        const bottomVar = getKVar(`${bottom}_y`)
-        const topBounds = getComponentDetails(top)?.bounds!
-        const bottomBounds = getComponentDetails(bottom)?.bounds!
-
-        // Top - Bottom = ydist
-
-        if (centerToCenter) {
-          // top - bottom = ydist
-          const expr = new kiwi.Expression(topVar, [-1, bottomVar])
-          solver.addConstraint(
-            new kiwi.Constraint(
-              expr,
-              kiwi.Operator.Eq,
-              props.yDist,
-              kiwi.Strength.required,
-            ),
-          )
-        } else if (edgeToEdge) {
-          // topElmBottomEdge - bottomElmTopEdge = ydist
-          // topElmCenterY - topElmHeight/2 - bottomElmCenterY - bottomElmHeight/2 = ydist
-          const expr = new kiwi.Expression(
-            topVar,
-            topBounds.height / 2,
-            [-1, bottomVar],
-            -bottomBounds.height / 2,
-          )
-          solver.addConstraint(
-            new kiwi.Constraint(
-              expr,
-              kiwi.Operator.Eq,
-              props.yDist,
-              kiwi.Strength.required,
-            ),
-          )
-        }
-      } else if ("sameY" in props) {
-        const { for: selectors } = props
-        if (selectors.length < 2) continue
-        const vars = selectors.map((selector) => getKVar(`${selector}_y`))
-        const expr = new kiwi.Expression(...vars.slice(1))
-
-        solver.addConstraint(
-          new kiwi.Constraint(
-            expr,
-            kiwi.Operator.Eq,
-            vars[0],
-            kiwi.Strength.required,
-          ),
-        )
-      } else if ("sameX" in props) {
-        const { for: selectors } = props
-        if (selectors.length < 2) continue
-        const vars = selectors.map((selector) => getKVar(`${selector}_x`))
-        const expr = new kiwi.Expression(...vars.slice(1))
-        solver.addConstraint(
-          new kiwi.Constraint(
-            expr,
-            kiwi.Operator.Eq,
-            vars[0],
-            kiwi.Strength.required,
-          ),
-        )
-      }
-    }
-
-    // 3. Solve the system of equations
-    solver.updateVariables()
-    if (debug.enabled) {
-      console.log("Solution to layout constraints:")
-      console.table(
-        Object.entries(kVars).map(([key, kvar]) => ({
-          var: key,
-          val: kvar.value(),
-        })),
-      )
-    }
-
-    // 3.1 Compute the global offset. There are different ways to do this:
-    // - If any component has a fixed position, then that can be used as the
-    //   origin to determine the offset of all other components
-    // - If no component has a fixed position, then we recenter everything
-    //   using the new bounds of all the involved components
-
-    // TODO determine if there's a fixed component
-
-    // Determine the new bounds all the involved components and compute the
-    // bounds of this footprint
-    const bounds = {
-      left: Infinity,
-      right: -Infinity,
-      top: -Infinity,
-      bottom: Infinity,
-    }
-    for (const {
-      selector,
-      bounds: { width, height },
-    } of involvedComponents) {
-      const kvx = getKVar(`${selector}_x`)
-      const kvy = getKVar(`${selector}_y`)
-
-      const newLeft = kvx.value() - width / 2
-      const newRight = kvx.value() + width / 2
-      const newTop = kvy.value() + height / 2
-      const newBottom = kvy.value() - height / 2
-
-      bounds.left = Math.min(bounds.left, newLeft)
-      bounds.right = Math.max(bounds.right, newRight)
-      bounds.top = Math.max(bounds.top, newTop)
-      bounds.bottom = Math.min(bounds.bottom, newBottom)
-    }
-
-    // Compute the global offset, we can use this to recenter each component
-    const globalOffset = {
-      x: -(bounds.right + bounds.left) / 2,
-      y: -(bounds.top + bounds.bottom) / 2,
-    }
-
-    const containerPos =
-      this.getPrimitiveContainer()!._getGlobalPcbPositionBeforeLayout()
-
-    globalOffset.x += containerPos.x
-    globalOffset.y += containerPos.y
-
-    // 4. Update the component positions
-    for (const { component, selector } of involvedComponents) {
-      const kvx = getKVar(`${selector}_x`)
-      const kvy = getKVar(`${selector}_y`)
-      component._setPositionFromLayout({
-        x: kvx.value() + globalOffset.x,
-        y: kvy.value() + globalOffset.y,
-      })
-    }
-  }
-}

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

@@ -1,42 +0,0 @@
-import {
-  groupProps,
-  type GroupProps,
-  type SubcircuitGroupProps,
-} 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"
-import { TraceHint } from "./TraceHint"
-
-export class Group<
-  Props extends z.ZodType<any, any, any> = typeof groupProps,
-> extends NormalComponent<Props> {
-  get config() {
-    return {
-      zodProps: groupProps as unknown as Props,
-    }
-  }
-
-  doInitialCreateTraceHintsFromProps(): void {
-    const { _parsedProps: props } = this
-    const { db } = this.root!
-
-    const groupProps = props as SubcircuitGroupProps
-
-    if (!this.isSubcircuit) return
-
-    const manualTraceHints = groupProps.layout?.manual_trace_hints
-
-    if (!manualTraceHints) return
-
-    for (const manualTraceHint of manualTraceHints) {
-      this.add(
-        new TraceHint({
-          for: manualTraceHint.pcb_port_selector,
-          offsets: manualTraceHint.offsets,
-        }),
-      )
-    }
-  }
-}

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

@@ -1,65 +0,0 @@
-import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
-import { holeProps } from "@tscircuit/props"
-import type { PCBHole } from "@tscircuit/soup"
-
-export class Hole extends PrimitiveComponent<typeof holeProps> {
-  pcb_hole_id: string | null = null
-  isPcbPrimitive = true
-
-  get config() {
-    return {
-      zodProps: holeProps,
-    }
-  }
-
-  getPcbSize(): { width: number; height: number } {
-    const { _parsedProps: props } = this
-    return { width: props.diameter, height: props.diameter }
-  }
-
-  doInitialPcbPrimitiveRender(): void {
-    const { db } = this.root!
-    const { _parsedProps: props } = this
-    const position = this._getGlobalPcbPositionBeforeLayout()
-
-    const inserted_hole = db.pcb_hole.insert({
-      hole_shape: "circle",
-      // @ts-ignore
-      hole_diameter: props.diameter,
-      x: position.x,
-      y: position.y,
-    })
-    this.pcb_hole_id = inserted_hole.pcb_hole_id!
-  }
-
-  _getPcbCircuitJsonBounds(): {
-    center: { x: number; y: number }
-    bounds: { left: number; top: number; right: number; bottom: number }
-    width: number
-    height: number
-  } {
-    const { db } = this.root!
-    const hole = db.pcb_hole.get(this.pcb_hole_id!)!
-    const size = this.getPcbSize()
-
-    return {
-      center: { x: hole.x, y: hole.y },
-      bounds: {
-        left: hole.x - size.width / 2,
-        top: hole.y - size.height / 2,
-        right: hole.x + size.width / 2,
-        bottom: hole.y + size.height / 2,
-      },
-      width: size.width,
-      height: size.height,
-    }
-  }
-
-  _setPositionFromLayout(newCenter: { x: number; y: number }) {
-    const { db } = this.root!
-    db.pcb_hole.update(this.pcb_hole_id!, {
-      x: newCenter.x,
-      y: newCenter.y,
-    })
-  }
-}

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

@@ -1,58 +0,0 @@
-import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
-import { pcbKeepoutProps } from "@tscircuit/props"
-import type { RenderPhaseFn } from "../base-components/Renderable"
-import type { PCBKeepout } from "@tscircuit/soup"
-import { decomposeTSR } from "transformation-matrix"
-
-export class Keepout extends PrimitiveComponent<typeof pcbKeepoutProps> {
-  pcb_keepout_id: string | null = null
-
-  isPcbPrimitive = true
-
-  get config() {
-    return {
-      zodProps: pcbKeepoutProps,
-    }
-  }
-
-  doInitialPcbPrimitiveRender(): void {
-    const { db } = this.root!
-    const { _parsedProps: props } = this
-    const position = this._getGlobalPcbPositionBeforeLayout()
-    const decomposedMat = decomposeTSR(
-      this._computePcbGlobalTransformBeforeLayout(),
-    )
-    const isRotated90 =
-      Math.abs(decomposedMat.rotation.angle * (180 / Math.PI) - 90) < 0.01
-
-    let pcb_keepout: PCBKeepout | null = null
-    if (props.shape === "circle") {
-      pcb_keepout = db.pcb_keepout.insert({
-        layers: ["top"],
-        shape: "circle",
-        // @ts-ignore: no idea why this is triggering
-        radius: props.radius,
-        center: {
-          x: position.x,
-          y: position.y,
-        },
-      })
-    } else if (props.shape === "rect") {
-      pcb_keepout = db.pcb_keepout.insert({
-        layers: ["top"],
-        shape: "rect",
-        ...(isRotated90
-          ? { width: props.height, height: props.width }
-          : { width: props.width, height: props.height }),
-        // @ts-ignore: no idea why this is triggering
-        center: {
-          x: position.x,
-          y: position.y,
-        },
-      })
-    }
-    if (pcb_keepout) {
-      this.pcb_keepout_id = pcb_keepout.pcb_keepout_id
-    }
-  }
-}

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

@@ -1,171 +0,0 @@
-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}`
-  }
-
-  doInitialSourceRender(): void {
-    const { db } = this.root!
-    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.root!
-    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._getGlobalPcbPositionBeforeLayout(),
-      )
-      const Bpositions: Array<{ x: number; y: number }> = B.ports.map((port) =>
-        port._getGlobalPcbPositionBeforeLayout(),
-      )
-
-      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/PlatedHole.ts

@@ -1,116 +0,0 @@
-import { PrimitiveComponent } from "../base-components/PrimitiveComponent"
-import { platedHoleProps } from "@tscircuit/props"
-import type { Port } from "./Port"
-import type { PCBPlatedHoleInput } from "@tscircuit/soup"
-
-export class PlatedHole extends PrimitiveComponent<typeof platedHoleProps> {
-  pcb_plated_hole_id: string | null = null
-  matchedPort: Port | null = null
-  isPcbPrimitive = true
-
-  get config() {
-    return {
-      zodProps: platedHoleProps,
-    }
-  }
-
-  getAvailablePcbLayers(): string[] {
-    // TODO use project layerCount
-    return ["top", "inner1", "inner2", "bottom"]
-  }
-
-  getPcbSize(): { width: number; height: number } {
-    const { _parsedProps: props } = this
-    if (props.shape === "circle") {
-      return { width: props.outerDiameter, height: props.outerDiameter }
-    }
-    if (props.shape === "oval") {
-      return { width: props.outerWidth, height: props.outerHeight }
-    }
-    throw new Error(
-      `getPcbSize for shape "${(props as any).shape}" not implemented for ${this.componentName}`,
-    )
-  }
-
-  _getPcbCircuitJsonBounds(): {
-    center: { x: number; y: number }
-    bounds: { left: number; top: number; right: number; bottom: number }
-    width: number
-    height: number
-  } {
-    const { db } = this.root!
-    const platedHole = db.pcb_plated_hole.get(this.pcb_plated_hole_id!)!
-    const size = this.getPcbSize()
-
-    return {
-      center: { x: platedHole.x, y: platedHole.y },
-      bounds: {
-        left: platedHole.x - size.width / 2,
-        top: platedHole.y - size.height / 2,
-        right: platedHole.x + size.width / 2,
-        bottom: platedHole.y + size.height / 2,
-      },
-      width: size.width,
-      height: size.height,
-    }
-  }
-
-  _setPositionFromLayout(newCenter: { x: number; y: number }) {
-    const { db } = this.root!
-    db.pcb_plated_hole.update(this.pcb_plated_hole_id!, {
-      x: newCenter.x,
-      y: newCenter.y,
-    })
-    this.matchedPort?._setPositionFromLayout(newCenter)
-  }
-
-  doInitialPortMatching(): void {
-    const parentPorts = this.getPrimitiveContainer()?.selectAll(
-      "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.root!
-    const { _parsedProps: props } = this
-    const position = this._getGlobalPcbPositionBeforeLayout()
-    const pcb_component_id =
-      this.parent?.pcb_component_id ??
-      this.getPrimitiveContainer()?.pcb_component_id!
-    if (props.shape === "circle") {
-      const pcb_plated_hole = db.pcb_plated_hole.insert({
-        pcb_component_id,
-        pcb_port_id: this.matchedPort?.pcb_port_id!,
-        // @ts-ignore - some issue with @tscircuit/soup union type
-        outer_diameter: props.outerDiameter,
-        hole_diameter: props.holeDiameter,
-        shape: "circle" as const,
-        port_hints: this.getNameAndAliases(),
-        x: position.x,
-        y: position.y,
-        layers: ["top", "bottom"],
-      })
-
-      this.pcb_plated_hole_id = pcb_plated_hole.pcb_plated_hole_id
-    }
-  }
-
-  doInitialPcbPortAttachment(): void {
-    const { db } = this.root!
-    db.pcb_plated_hole.update(this.pcb_plated_hole_id!, {
-      pcb_port_id: this.matchedPort?.pcb_port_id!,
-    })
-  }
-}