@tscircuit/core 0.0.72 → 0.0.74

package/lib/utils/createComponentsFromSoup.ts

@@ -1,79 +0,0 @@
-import type { AnySoupElement } from "@tscircuit/soup"
-import type { PrimitiveComponent } from "../components/base-components/PrimitiveComponent"
-import { SmtPad } from "lib/components/primitive-components/SmtPad"
-import { SilkscreenPath } from "lib/components/primitive-components/SilkscreenPath"
-import { PlatedHole } from "lib/components/primitive-components/PlatedHole"
-import { Keepout } from "lib/components/primitive-components/Keepout"
-
-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,
-        }),
-      )
-    } else if (elm.type === "pcb_silkscreen_path") {
-      components.push(
-        new SilkscreenPath({
-          layer: elm.layer,
-          route: elm.route,
-          strokeWidth: elm.stroke_width,
-        }),
-      )
-    } else if (elm.type === "pcb_plated_hole" && elm.shape === "circle") {
-      if (elm.shape === "circle") {
-        components.push(
-          new PlatedHole({
-            pcbX: elm.x,
-            pcbY: elm.y,
-            shape: "circle",
-            holeDiameter: elm.hole_diameter,
-            outerDiameter: elm.outer_diameter,
-            portHints: elm.port_hints,
-          }),
-        )
-      }
-    } else if (elm.type === "pcb_keepout" && elm.shape === "circle") {
-      components.push(
-        new Keepout({
-          pcbX: elm.center.x,
-          pcbY: elm.center.y,
-          shape: "circle",
-          radius: elm.radius,
-        }),
-      )
-    } else if (elm.type === "pcb_keepout" && elm.shape === "rect") {
-      components.push(
-        new Keepout({
-          pcbX: elm.center.x,
-          pcbY: elm.center.y,
-          shape: "rect",
-          width: elm.width,
-          height: elm.height,
-        }),
-      )
-    }
-  }
-  return components
-}

package/lib/utils/extend-aliases.ts

@@ -1,12 +0,0 @@
-export const extendAliases = (
-  aliases: string[],
-  additionalAliases: Record<string, string[]>,
-): string[] => {
-  return Array.from(
-    new Set(
-      aliases.flatMap((alias) => {
-        return [alias, ...(additionalAliases[alias] || [])]
-      }),
-    ),
-  )
-}

package/lib/utils/get-bounds-of-pcb-components.ts

@@ -1,41 +0,0 @@
-import type { PrimitiveComponent } from "lib/components/base-components/PrimitiveComponent"
-
-export function getBoundsOfPcbComponents(components: PrimitiveComponent[]) {
-  let minX = Infinity
-  let minY = Infinity
-  let maxX = -Infinity
-  let maxY = -Infinity
-
-  for (const child of components) {
-    if (child.isPcbPrimitive) {
-      const { x, y } = child._getGlobalPcbPositionBeforeLayout()
-      const { width, height } = child.getPcbSize()
-      minX = Math.min(minX, x - width / 2)
-      minY = Math.min(minY, y - height / 2)
-      maxX = Math.max(maxX, x + width / 2)
-      maxY = Math.max(maxY, y + height / 2)
-    } else if (child.componentName === "Footprint") {
-      const childBounds = getBoundsOfPcbComponents(child.children)
-
-      minX = Math.min(minX, childBounds.minX)
-      minY = Math.min(minY, childBounds.minY)
-      maxX = Math.max(maxX, childBounds.maxX)
-      maxY = Math.max(maxY, childBounds.maxY)
-    }
-  }
-
-  let width = maxX - minX
-  let height = maxY - minY
-
-  if (width < 0) width = 0
-  if (height < 0) height = 0
-
-  return {
-    minX,
-    minY,
-    maxX,
-    maxY,
-    width,
-    height,
-  }
-}

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

@@ -1,14 +0,0 @@
-// 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/getClosest.ts

@@ -1,35 +0,0 @@
-export type PointLike =
-  | { _getGlobalPcbPositionBeforeLayout: () => { x: number; y: number } }
-  | { x: number; y: number }
-
-const getDistance = (a: PointLike, b: PointLike) => {
-  const aPos =
-    "_getGlobalPcbPositionBeforeLayout" in a
-      ? a._getGlobalPcbPositionBeforeLayout()
-      : a
-  const bPos =
-    "_getGlobalPcbPositionBeforeLayout" in b
-      ? b._getGlobalPcbPositionBeforeLayout()
-      : b
-  return Math.sqrt((aPos.x - bPos.x) ** 2 + (aPos.y - bPos.y) ** 2)
-}
-
-export function getClosest<T extends PointLike, U extends PointLike>(
-  point: T,
-  candidates: U[],
-): U {
-  if (candidates.length === 0)
-    throw new Error("No candidates given to getClosest method")
-  let closest: U = candidates[0]
-  let closestDist = Infinity
-
-  for (const candidate of candidates) {
-    const dist = getDistance(point, candidate)
-    if (dist < closestDist) {
-      closest = candidate
-      closestDist = dist
-    }
-  }
-
-  return closest
-}

package/lib/utils/getPortFromHints.ts

@@ -1,10 +0,0 @@
-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/pairs.ts

@@ -1,10 +0,0 @@
-/**
- * Return pairs of adjacent elements in an array.
- */
-export function pairs<T>(arr: Array<T>): Array<[T, T]> {
-  const result: Array<[T, T]> = []
-  for (let i = 0; i < arr.length - 1; i++) {
-    result.push([arr[i], arr[i + 1]])
-  }
-  return result
-}

package/lib/utils/projectPointInDirection.ts

@@ -1,18 +0,0 @@
-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}"`)
-  }
-}

package/lib/utils/range.ts

@@ -1,8 +0,0 @@
-// 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

@@ -1,330 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,2 +0,0 @@
-export * from "./is-matching-selector"
-export * from "./is-matching-path-selector"

package/lib/utils/selector-matching/is-matching-path-selector.ts

@@ -1,32 +0,0 @@
-import type { PrimitiveComponent } from "lib/components"
-import type { Primitive } from "schematic-symbols/drawing/types"
-
-import { isMatchingSelector } from "./is-matching-selector"
-
-/**
- * Determines if a component matches a path selector, meaning that the last
- * selector matches the current component, and the previous selectors match
- * the parent components.
- */
-export function isMatchingPathSelector(
-  component: PrimitiveComponent,
-  selector: string,
-): boolean {
-  const selectorParts = selector.split(/\> /g).map((part) => part.trim())
-  let currentComponent: PrimitiveComponent | null = component
-
-  // Iterate through selector parts from right to left
-  for (let i = selectorParts.length - 1; i >= 0; i--) {
-    if (!currentComponent) return false
-
-    if (!isMatchingSelector(currentComponent, selectorParts[i])) {
-      return false
-    }
-
-    // Move to the parent component for the next iteration
-    currentComponent = currentComponent.parent
-  }
-
-  // If we've matched all parts of the selector, it's a match
-  return true
-}