@tscircuit/core 0.0.3 → 0.0.5

package/lib/components/index.ts

@@ -12,3 +12,4 @@ export { Net } from "./primitive-components/Net"
 export { Trace } from "./primitive-components/Trace"
 export { TraceHint } from "./primitive-components/TraceHint"
 export { Group } from "./primitive-components/Group"
+export { Chip } from "./normal-components/Chip"

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

@@ -0,0 +1,113 @@
+import { NormalComponent } from "lib/components/base-components/NormalComponent"
+import { chipProps } from "@tscircuit/props"
+import { Port } from "../primitive-components/Port"
+import type { BaseSymbolName } from "lib/utils/constants"
+import {
+  getAllDimensionsForSchematicBox,
+  type SchematicBoxDimensions,
+} from "lib/utils/schematic/getAllDimensionsForSchematicBox"
+import { underscorifyPortArrangement } from "lib/soup/underscorifyPortArrangement"
+import { underscorifyPinStyles } from "lib/soup/underscorifyPinStyles"
+
+export class Chip<PinLabels extends string = never> extends NormalComponent<
+  typeof chipProps,
+  PinLabels
+> {
+  schematicDimensions: SchematicBoxDimensions | null = null
+
+  get config() {
+    return {
+      zodProps: chipProps,
+    }
+  }
+
+  initPorts() {
+    super.initPorts()
+
+    const { _parsedProps: props } = this
+
+    if (props.pinLabels) {
+      for (const [pinNumber, label] of Object.entries(props.pinLabels)) {
+        const port = this.selectOne(`port[pinNumber='${pinNumber}']`)
+        if (!port) {
+          throw new Error(
+            `Could not find port for pin number ${pinNumber} in chip ${this.getString()}`,
+          )
+        }
+        port.props.aliases.push(port.props.name)
+        port.props.name = label
+      }
+    }
+  }
+
+  doInitialSourceRender(): void {
+    const { db } = this.project!
+    const { _parsedProps: props } = this
+
+    const source_component = db.source_component.insert({
+      ftype: "simple_chip",
+      name: props.name,
+      manufacturer_part_number: props.manufacturerPartNumber,
+      supplier_part_numbers: props.supplierPartNumbers,
+    })
+
+    this.source_component_id = source_component.source_component_id!
+  }
+
+  doInitialSchematicComponentRender() {
+    const { db } = this.project!
+    const { _parsedProps: props } = this
+
+    const pinSpacing = props.schPinSpacing ?? 0.2
+
+    const dimensions = getAllDimensionsForSchematicBox({
+      schWidth: props.schWidth,
+      schHeight: props.schHeight,
+      schPinSpacing: pinSpacing,
+      schPinStyle: props.schPinStyle,
+
+      // @ts-ignore there's a subtley in the definition difference with
+      // leftSide/rightSide/topSide/bottomSide in how the direction is defined
+      // that doesn't really matter
+      schPortArrangement: props.schPortArrangement,
+    })
+    this.schematicDimensions = dimensions
+
+    const schematic_component = db.schematic_component.insert({
+      center: { x: props.schX ?? 0, y: props.schY ?? 0 },
+      rotation: props.schRotation ?? 0,
+      size: dimensions.getSize(),
+
+      port_arrangement: underscorifyPortArrangement(
+        props.schPortArrangement as any,
+      ),
+
+      pin_spacing: pinSpacing,
+
+      // @ts-ignore soup needs to support distance for pin_styles
+      pin_styles: underscorifyPinStyles(props.schPinStyle),
+
+      port_labels: props.pinLabels,
+
+      source_component_id: this.source_component_id!,
+    })
+
+    this.schematic_component_id = schematic_component.schematic_component_id
+  }
+
+  doInitialPcbComponentRender() {
+    const { db } = this.project!
+    const { _parsedProps: props } = this
+
+    const pcb_component = db.pcb_component.insert({
+      center: { x: props.pcbX ?? 0, y: props.pcbY ?? 0 },
+      width: 2, // Default width, adjust as needed
+      height: 3, // Default height, adjust as needed
+      layer: props.layer ?? "top",
+      rotation: props.pcbRotation ?? 0,
+      source_component_id: this.source_component_id!,
+    })
+
+    this.pcb_component_id = pcb_component.pcb_component_id
+  }
+}

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

@@ -45,6 +45,10 @@ export class Port extends PrimitiveComponent<typeof portProps> {
 
   getGlobalSchematicPosition(): { x: number; y: number } {
     if (!this.schematicSymbolPortDef) {
+      return applyToPoint(this.parent!.computeSchematicGlobalTransform(), {
+        x: 0,
+        y: 0,
+      })
       throw new Error(
         `Could not find schematic symbol port for port ${this} so couldn't determine port position`,
       )

package/lib/soup/underscorifyPinStyles.ts

@@ -0,0 +1,23 @@
+import type { SchematicPinStyles } from "@tscircuit/props"
+import { schematic_component } from "@tscircuit/soup"
+import { z } from "zod"
+
+type UnderscorePinStyles = z.input<typeof schematic_component>["pin_styles"]
+
+export const underscorifyPinStyles = (
+  pinStyles: SchematicPinStyles | undefined,
+): UnderscorePinStyles | undefined => {
+  if (!pinStyles) return undefined
+  const underscorePinStyles: UnderscorePinStyles = {}
+
+  for (const [pinName, pinStyle] of Object.entries(pinStyles)) {
+    underscorePinStyles[pinName] = {
+      bottom_margin: pinStyle.bottomMargin,
+      left_margin: pinStyle.leftMargin,
+      right_margin: pinStyle.rightMargin,
+      top_margin: pinStyle.topMargin,
+    }
+  }
+
+  return underscorePinStyles
+}

package/lib/soup/underscorifyPortArrangement.ts

@@ -0,0 +1,51 @@
+import type { SchematicComponentInput } from "@tscircuit/soup"
+import type { PortArrangement } from "lib/utils/schematic/getAllDimensionsForSchematicBox"
+
+export const underscorifyPortArrangement = (
+  portArrangement?: PortArrangement | undefined,
+): SchematicComponentInput["port_arrangement"] | undefined => {
+  if (!portArrangement) return undefined
+  if (
+    "leftSide" in portArrangement ||
+    "rightSide" in portArrangement ||
+    "topSide" in portArrangement ||
+    "bottomSide" in portArrangement
+  ) {
+    return {
+      left_side: portArrangement.leftSide,
+      right_side: portArrangement.rightSide,
+      top_side: portArrangement.topSide,
+      bottom_side: portArrangement.bottomSide,
+    }
+  }
+
+  if (
+    "leftPinCount" in portArrangement ||
+    "rightPinCount" in portArrangement ||
+    "topPinCount" in portArrangement ||
+    "bottomPinCount" in portArrangement
+  ) {
+    return {
+      left_size: portArrangement.leftPinCount!,
+      right_size: portArrangement.rightPinCount!,
+      top_size: portArrangement.topPinCount,
+      bottom_size: portArrangement.bottomPinCount,
+    }
+  }
+
+  if (
+    "leftSize" in portArrangement ||
+    "rightSize" in portArrangement ||
+    "topSize" in portArrangement ||
+    "bottomSize" in portArrangement
+  ) {
+    return {
+      left_size: portArrangement.leftSize!,
+      right_size: portArrangement.rightSize!,
+      top_size: portArrangement.topSize,
+      bottom_size: portArrangement.bottomSize,
+    }
+  }
+
+  return undefined
+}

package/lib/utils/range.ts

@@ -0,0 +1,8 @@
+// same signature as lodash.range
+export const range = (start: number, end: number, step = 1) => {
+  const result: number[] = []
+  for (let i = start; i < end; i += step) {
+    result.push(i)
+  }
+  return result
+}

package/lib/utils/schematic/getAllDimensionsForSchematicBox.ts

@@ -0,0 +1,330 @@
+import { current } from "@tscircuit/soup"
+import { getSizeOfSidesFromPortArrangement } from "./getSizeOfSidesFromPortArrangement"
+import { schematicPortArrangement } from "@tscircuit/props"
+import { z } from "zod"
+
+export type VerticalPortSideConfiguration = {
+  direction?: "top-to-bottom" | "bottom-to-top"
+  pins: number[]
+}
+export type HorizontalPortSideConfiguration = {
+  direction?: "left-to-right" | "right-to-left"
+  pins: number[]
+}
+
+export type ExplicitPinMappingArrangement = {
+  leftSide?: VerticalPortSideConfiguration
+  rightSide?: VerticalPortSideConfiguration
+  topSide?: HorizontalPortSideConfiguration
+  bottomSide?: HorizontalPortSideConfiguration
+}
+/** @deprecated prefer SidePinCounts */
+export interface SideSizes {
+  leftSize?: number
+  rightSize?: number
+  topSize?: number
+  bottomSize?: number
+}
+
+export interface SidePinCounts {
+  leftPinCount?: number
+  rightPinCount?: number
+  topPinCount?: number
+  bottomPinCount?: number
+}
+
+export type PortArrangement =
+  | SideSizes
+  | SidePinCounts
+  | ExplicitPinMappingArrangement
+
+interface Params {
+  schWidth?: number
+  schHeight?: number
+  portDistanceFromEdge?: number
+  schPinSpacing: number
+  schPinStyle?: Record<
+    `pin${number}` | number | `${number}`,
+    {
+      leftMargin?: number
+      rightMargin?: number
+      topMargin?: number
+      bottomMargin?: number
+    }
+  >
+  pinCount?: number
+  schPortArrangement?: PortArrangement
+}
+
+type Side = "left" | "right" | "top" | "bottom"
+
+export interface SchematicBoxDimensions {
+  pinCount: number
+  getPortPositionByPinNumber(pinNumber: number): { x: number; y: number }
+  getSize(): { width: number; height: number }
+}
+
+/**
+ * Get the dimensions of a schematic box based on the provided parameters.
+ *
+ * A schematic box is a rectangular box with a set of pins on the sides.
+ *
+ * The user can customize the position of the pins and the spacing between them,
+ * this makes computing the box fairly complicated.
+ *
+ * A note on the internals:
+ * * A "true port" refers to a pin/port before it's remapped by the user to a
+ *   different position. True Pin 1 is guaranteed to be in the top-left corner
+ * * We basically iterate over each side and compute how far we are from the
+ *   edge for that side by adding margins together
+ */
+export const getAllDimensionsForSchematicBox = (
+  params: Params,
+): SchematicBoxDimensions => {
+  const portDistanceFromEdge =
+    params.portDistanceFromEdge ?? params.schPinSpacing * 2
+
+  let sidePinCounts = params.schPortArrangement
+    ? getSizeOfSidesFromPortArrangement(params.schPortArrangement)
+    : null
+
+  const sideLengths: Record<Side, number> = {
+    left: 0,
+    right: 0,
+    top: 0,
+    bottom: 0,
+  }
+
+  let pinCount: number | null = params.pinCount ?? null
+
+  if (pinCount === null) {
+    if (sidePinCounts) {
+      pinCount =
+        sidePinCounts.leftSize + sidePinCounts.rightSize + sidePinCounts.topSize
+    } else {
+      throw new Error("Could not determine pin count for the schematic box")
+    }
+  }
+
+  if (pinCount && !sidePinCounts) {
+    const rightSize = Math.floor(pinCount / 2)
+    sidePinCounts = {
+      leftSize: pinCount - rightSize,
+      rightSize: rightSize,
+      topSize: 0,
+      bottomSize: 0,
+    }
+  }
+
+  if (!sidePinCounts) {
+    throw new Error("Could not determine side sizes for the schematic box")
+  }
+
+  // Map the indices to the sides they correspond to
+  const orderedTruePorts: Array<{
+    trueIndex: number
+    pinNumber: number
+    side: "left" | "right" | "top" | "bottom"
+    distanceFromEdge: number
+  }> = []
+  let currentDistanceFromEdge = 0
+  let truePinIndex = 0
+  // moving downward from the top-left corner
+  for (let sideIndex = 0; sideIndex < sidePinCounts.leftSize; sideIndex++) {
+    const pinNumber = truePinIndex + 1 // TODO check mapping from schPortArrangement
+    const pinStyle =
+      params.schPinStyle?.[`pin${pinNumber}`] ?? params.schPinStyle?.[pinNumber]
+
+    if (pinStyle?.topMargin) {
+      currentDistanceFromEdge += pinStyle.topMargin
+    }
+
+    orderedTruePorts.push({
+      trueIndex: truePinIndex,
+      pinNumber,
+      side: "left",
+      distanceFromEdge: currentDistanceFromEdge,
+    })
+
+    if (pinStyle?.bottomMargin) {
+      currentDistanceFromEdge += pinStyle.bottomMargin
+    }
+
+    const isLastPinOnSide = sideIndex === sidePinCounts.leftSize - 1
+    if (!isLastPinOnSide) {
+      currentDistanceFromEdge += params.schPinSpacing
+    } else {
+      sideLengths.left = currentDistanceFromEdge
+    }
+    truePinIndex++
+  }
+
+  currentDistanceFromEdge = 0
+  // moving rightward from the left-bottom corner
+  for (let sideIndex = 0; sideIndex < sidePinCounts.bottomSize; sideIndex++) {
+    const pinNumber = truePinIndex + 1 // TODO check mapping from schPortArrangement
+    const pinStyle =
+      params.schPinStyle?.[`pin${pinNumber}`] ?? params.schPinStyle?.[pinNumber]
+
+    if (pinStyle?.leftMargin) {
+      currentDistanceFromEdge += pinStyle.leftMargin
+    }
+
+    orderedTruePorts.push({
+      trueIndex: truePinIndex,
+      pinNumber,
+      side: "bottom",
+      distanceFromEdge: currentDistanceFromEdge,
+    })
+
+    if (pinStyle?.rightMargin) {
+      currentDistanceFromEdge += pinStyle.rightMargin
+    }
+
+    const isLastPinOnSide = sideIndex === sidePinCounts.bottomSize - 1
+    if (!isLastPinOnSide) {
+      currentDistanceFromEdge += params.schPinSpacing
+    } else {
+      sideLengths.bottom = currentDistanceFromEdge
+    }
+    truePinIndex++
+  }
+
+  currentDistanceFromEdge = 0
+  // moving upward from the bottom-right corner
+  for (let sideIndex = 0; sideIndex < sidePinCounts.rightSize; sideIndex++) {
+    const pinNumber = truePinIndex + 1 // TODO check mapping from schPortArrangement
+    const pinStyle =
+      params.schPinStyle?.[`pin${pinNumber}`] ?? params.schPinStyle?.[pinNumber]
+
+    if (pinStyle?.bottomMargin) {
+      currentDistanceFromEdge += pinStyle.bottomMargin
+    }
+
+    orderedTruePorts.push({
+      trueIndex: truePinIndex,
+      pinNumber,
+      side: "right",
+      distanceFromEdge: currentDistanceFromEdge,
+    })
+
+    if (pinStyle?.topMargin) {
+      currentDistanceFromEdge += pinStyle.topMargin
+    }
+
+    const isLastPinOnSide = sideIndex === sidePinCounts.rightSize - 1
+    if (!isLastPinOnSide) {
+      currentDistanceFromEdge += params.schPinSpacing
+    } else {
+      sideLengths.right = currentDistanceFromEdge
+    }
+    truePinIndex++
+  }
+
+  currentDistanceFromEdge = 0
+  // moving leftward from the top-right corner
+  for (let sideIndex = 0; sideIndex < sidePinCounts.topSize; sideIndex++) {
+    const pinNumber = truePinIndex + 1 // TODO check mapping from schPortArrangement
+    const pinStyle =
+      params.schPinStyle?.[`pin${pinNumber}`] ?? params.schPinStyle?.[pinNumber]
+
+    if (pinStyle?.rightMargin) {
+      currentDistanceFromEdge += pinStyle.rightMargin
+    }
+
+    orderedTruePorts.push({
+      trueIndex: truePinIndex,
+      pinNumber,
+      side: "top",
+      distanceFromEdge: currentDistanceFromEdge,
+    })
+
+    if (pinStyle?.leftMargin) {
+      currentDistanceFromEdge += pinStyle.leftMargin
+    }
+
+    const isLastPinOnSide = sideIndex === sidePinCounts.topSize - 1
+    if (!isLastPinOnSide) {
+      currentDistanceFromEdge += params.schPinSpacing
+    } else {
+      sideLengths.top = currentDistanceFromEdge
+    }
+    truePinIndex++
+  }
+
+  // Use lengths to determine schWidth and schHeight
+  let schWidth = params.schWidth
+  if (!schWidth) {
+    schWidth = Math.max(
+      sideLengths.top + params.schPinSpacing * 2,
+      sideLengths.bottom + params.schPinSpacing * 2,
+    )
+  }
+  let schHeight = params.schHeight
+  if (!schHeight) {
+    schHeight = Math.max(
+      sideLengths.left + params.schPinSpacing * 2,
+      sideLengths.right + params.schPinSpacing * 2,
+    )
+  }
+
+  const trueEdgePositions = {
+    // Top left corner
+    left: {
+      x: -schWidth / 2 - portDistanceFromEdge,
+      y: sideLengths.left / 2,
+    },
+    // bottom left corner
+    bottom: {
+      x: -sideLengths.bottom / 2,
+      y: -schHeight / 2 - portDistanceFromEdge,
+    },
+    // bottom right corner
+    right: {
+      x: schWidth / 2 + portDistanceFromEdge,
+      y: -sideLengths.right / 2,
+    },
+    // top right corner
+    top: {
+      x: sideLengths.top / 2,
+      y: schHeight / 2 + portDistanceFromEdge,
+    },
+  }
+
+  const trueEdgeTraversalDirections = {
+    left: { x: 0, y: -1 },
+    right: { x: 0, y: 1 },
+    top: { x: -1, y: 0 },
+    bottom: { x: 1, y: 0 },
+  }
+
+  const truePortsWithPositions = orderedTruePorts.map((p) => {
+    const { distanceFromEdge, side } = p
+    const edgePos = trueEdgePositions[side]
+    const edgeDir = trueEdgeTraversalDirections[side]
+
+    return {
+      x: edgePos.x + distanceFromEdge * edgeDir.x,
+      y: edgePos.y + distanceFromEdge * edgeDir.y,
+      ...p,
+    }
+  })
+
+  return {
+    getPortPositionByPinNumber(pinNumber: number): { x: number; y: number } {
+      const port = truePortsWithPositions.find(
+        (p) => p.pinNumber.toString() === pinNumber.toString(),
+      )
+      if (!port) {
+        throw new Error(
+          `Could not find port for pin number ${pinNumber}, available pins: ${truePortsWithPositions.map((tp) => tp.pinNumber).join(", ")}`,
+        )
+      }
+      return port
+    },
+    getSize(): { width: number; height: number } {
+      return { width: schWidth, height: schHeight }
+    },
+    pinCount,
+  }
+}

package/lib/utils/schematic/getSizeOfSidesFromPortArrangement.ts

@@ -0,0 +1,47 @@
+import type {
+  ExplicitPinMappingArrangement,
+  PortArrangement,
+} from "./getAllDimensionsForSchematicBox"
+
+export const hasExplicitPinMapping = (
+  pa: PortArrangement,
+): pa is ExplicitPinMappingArrangement => {
+  for (const side of [
+    "leftSide",
+    "rightSide",
+    "topSide",
+    "bottomSide",
+  ] as const) {
+    if (side in pa && typeof (pa as any)[side] === "number") {
+      throw new Error(
+        `A number was specified for "${side}", you probably meant to use "size" not "side"`,
+      )
+    }
+  }
+  return (
+    "leftSide" in pa ||
+    "rightSide" in pa ||
+    "topSide" in pa ||
+    "bottomSide" in pa
+  )
+}
+
+export const getSizeOfSidesFromPortArrangement = (
+  pa: PortArrangement,
+): {
+  leftSize: number
+  rightSize: number
+  topSize: number
+  bottomSize: number
+} => {
+  if (hasExplicitPinMapping(pa)) {
+    return {
+      leftSize: pa.leftSide?.pins.length ?? 0,
+      rightSize: pa.rightSide?.pins.length ?? 0,
+      topSize: pa.topSide?.pins.length ?? 0,
+      bottomSize: pa.bottomSide?.pins.length ?? 0,
+    }
+  }
+  const { leftSize = 0, rightSize = 0, topSize = 0, bottomSize = 0 } = pa as any
+  return { leftSize, rightSize, topSize, bottomSize }
+}

package/lib/utils/selector-matching/index.ts

@@ -57,6 +57,6 @@ export function isMatchingSelector(
     const match = condition.match(/\[(\w+)=['"]?(.+?)['"]?\]/)
     if (!match) return true
     const [, prop, value] = match
-    return component.props[prop] === value
+    return component.props[prop].toString() === value
   })
 }

package/package.json

@@ -3,7 +3,7 @@
   "module": "index.ts",
   "type": "module",
   "types": "index.ts",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "main": "dist/index.cjs",
   "files": [
     "index.ts",
@@ -11,7 +11,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsup index.ts"
+    "build": "tsup-node index.ts"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.8.3",
@@ -28,13 +28,14 @@
   },
   "dependencies": {
     "@tscircuit/infgrid-ijump-astar": "0.0.4",
-    "@tscircuit/props": "^0.0.37",
-    "@tscircuit/soup": "^0.0.52",
+    "@tscircuit/props": "^0.0.46",
+    "@tscircuit/soup": "^0.0.58",
     "@tscircuit/soup-util": "0.0.18",
     "footprinter": "^0.0.44",
     "react": "^18.3.1",
     "react-reconciler": "^0.29.2",
     "schematic-symbols": "0.0.10",
-    "transformation-matrix": "^2.16.1"
+    "transformation-matrix": "^2.16.1",
+    "zod": "^3.23.8"
   }
 }