@tscircuit/core 0.0.73 → 0.0.75

package/lib/fiber/catalogue.ts

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

@@ -1,179 +0,0 @@
-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"
-import { identity } from "transformation-matrix"
-
-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}" See CREATING_NEW_COMPONENTS.md`,
-      )
-    }
-
-    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 rootContainer = {
-    children: [] as any[],
-    props: {
-      name: "$root",
-    },
-    add(instance: any) {
-      instance.parent = this
-      this.children.push(instance)
-    },
-    computePcbGlobalTransform() {
-      return identity()
-    },
-  }
-  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
-    rootContainer,
-    0,
-    null,
-    false,
-    null,
-    "tsci",
-    (error: Error) => {
-      console.log("Error in createContainer")
-      console.error(error)
-    },
-    null,
-  )
-  reconciler.updateContainer(reactElm, container, null, () => {})
-  const rootInstance = reconciler.getPublicRootInstance(
-    container,
-  ) as NormalComponent
-  if (rootInstance) return rootInstance
-  return rootContainer.children[0] as NormalComponent
-}

package/lib/fiber/intrinsic-jsx.ts

@@ -1,48 +0,0 @@
-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
-      jumper: Props.JumperProps
-      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
-      keepout: Props.PcbKeepoutProps
-      hole: Props.HoleProps
-      port: Props.PortProps
-      group: Props.GroupProps
-      netalias: Props.NetAliasProps
-      net: Props.NetProps
-      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
-      constraint: Props.ConstraintProps
-      constrainedlayout: Props.ConstrainedLayoutProps
-      jscad: any
-    }
-  }
-}

package/lib/index.ts

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

package/lib/register-catalogue.ts

@@ -1,12 +0,0 @@
-import * as Components from "./components"
-import { extendCatalogue } from "./fiber/catalogue"
-
-// Register all components, generally you don't need to manually
-// register a component, as long as it's exported from lib/components
-// it'll automatically be registered!
-extendCatalogue(Components)
-
-// Aliases (only when class name is different than the name of the component)
-extendCatalogue({
-  Bug: Components.Chip,
-})

package/lib/soup/underscorifyPinStyles.ts

@@ -1,25 +0,0 @@
-import type { SchematicPinStyle } 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: Record<string, SchematicPinStyle> | undefined,
-): UnderscorePinStyles | undefined => {
-  if (!pinStyles) return undefined
-  const underscorePinStyles: UnderscorePinStyles = {}
-
-  for (const [pinName, pinStyle] of Object.entries(pinStyles) as Array<
-    [string, SchematicPinStyle]
-  >) {
-    underscorePinStyles[pinName] = {
-      bottom_margin: pinStyle.bottomMargin as number,
-      left_margin: pinStyle.leftMargin as number,
-      right_margin: pinStyle.rightMargin as number,
-      top_margin: pinStyle.topMargin as number,
-    }
-  }
-
-  return underscorePinStyles
-}

package/lib/soup/underscorifyPortArrangement.ts

@@ -1,51 +0,0 @@
-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/autorouting/SimpleRouteJson.ts

@@ -1,48 +0,0 @@
-export type SimplifiedPcbTrace = {
-  type: "pcb_trace"
-  pcb_trace_id: string
-  route: Array<
-    | {
-        route_type: "wire"
-        x: number
-        y: number
-        width: number
-        layer: string
-      }
-    | {
-        route_type: "via"
-        x: number
-        y: number
-        to_layer: string
-        from_layer: string
-      }
-  >
-}
-export type Obstacle = {
-  // TODO include ovals
-  type: "rect" // NOTE: most datasets do not contain ovals
-  layers: string[]
-  center: { x: number; y: number }
-  width: number
-  height: number
-  connectedTo: string[]
-}
-
-export interface SimpleRouteConnection {
-  name: string
-  pointsToConnect: Array<{ x: number; y: number; layer: string }>
-}
-
-export interface SimpleRouteJson {
-  layerCount: number
-  minTraceWidth: 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

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

@@ -1,102 +0,0 @@
-interface Hint {
-  via?: boolean
-  optional_via?: boolean
-  layers?: Array<string>
-}
-
-const LAYER_SELECTION_PREFERENCE = ["top", "bottom", "inner1", "inner2"]
-
-/**
- * ORDERING OF CANDIDATES: Example:
- * top    -> top    -> bottom -> bottom
- * bottom -> bottom -> top    -> top
- * top    -> bottom -> bottom -> top
- * bottom -> top    -> top    -> bottom
- */
-export interface CandidateTraceLayerCombination {
-  layer_path: string[]
-}
-
-/**
- * Given a set of hints that contain layers or indication there should be a via,
- * this function returns all combinations of layers that could be traversed.
- *
- * EXAMPLE 1:
- *   INPUT:
- *   [top,bottom] -> unspecified -> unspecified/via -> [top, bottom]
- *   OUTPUT:
- *   top -> top -> bottom -> bottom
- *   bottom -> bottom -> top -> top *
- * EXAMPLE 2:
- *   INPUT:
- *   [top,bottom] -> unspecified -> unspecified/via -> unspecified/via -> [top, bottom]
- *   OUTPUT:
- *   top -> top -> bottom -> top -> top
- *   bottom -> bottom -> top-> bottom -> bottom
- *   bottom -> bottom -> inner-1 -> inner-1 -> bottom
- */
-export const findPossibleTraceLayerCombinations = (
-  hints: Hint[],
-  layer_path: string[] = [],
-): CandidateTraceLayerCombination[] => {
-  const candidates: CandidateTraceLayerCombination[] = []
-  if (layer_path.length === 0) {
-    const starting_layers = hints[0].layers!
-    for (const layer of starting_layers) {
-      candidates.push(
-        ...findPossibleTraceLayerCombinations(hints.slice(1), [layer]),
-      )
-    }
-    return candidates
-  }
-
-  if (hints.length === 0) return []
-  const current_hint = hints[0]
-  const is_possibly_via = current_hint.via || current_hint.optional_via
-  const last_layer = layer_path[layer_path.length - 1]
-
-  if (hints.length === 1) {
-    const last_hint = current_hint
-    if (last_hint.layers && is_possibly_via) {
-      return last_hint.layers.map((layer) => ({
-        layer_path: [...layer_path, layer],
-      }))
-    }
-    if (last_hint.layers?.includes(last_layer)) {
-      return [{ layer_path: [...layer_path, last_layer] }]
-    }
-    return []
-  }
-
-  if (!is_possibly_via) {
-    if (current_hint.layers) {
-      if (!current_hint.layers.includes(last_layer)) {
-        return []
-      }
-    }
-
-    return findPossibleTraceLayerCombinations(
-      hints.slice(1),
-      layer_path.concat([last_layer]),
-    )
-  }
-
-  const candidate_next_layers = (
-    current_hint.optional_via
-      ? LAYER_SELECTION_PREFERENCE
-      : LAYER_SELECTION_PREFERENCE.filter((layer) => layer !== last_layer)
-  ).filter(
-    (layer) => !current_hint.layers || current_hint.layers?.includes(layer),
-  )
-
-  for (const candidate_next_layer of candidate_next_layers) {
-    candidates.push(
-      ...findPossibleTraceLayerCombinations(
-        hints.slice(1),
-        layer_path.concat(candidate_next_layer),
-      ),
-    )
-  }
-
-  return candidates
-}

package/lib/utils/autorouting/mergeRoutes.ts

@@ -1,71 +0,0 @@
-import type { PCBTrace } from "@tscircuit/soup"
-
-function pdist(a: any, b: any) {
-  return Math.hypot(a.x - b.x, a.y - b.y)
-}
-
-/**
- * Merge multiple routes into a single route.
- *
- * If the end of the next route is closer to the end of the previous route,
- * reverse the next route and append it to the previous route.
- */
-export const mergeRoutes = (routes: PCBTrace["route"][]) => {
-  if (routes.length === 1) return routes[0]
-  // routes = routes.filter((route) => route.length > 0)
-  if (routes.some((r) => r.length === 0)) {
-    throw new Error("Cannot merge routes with zero length")
-  }
-  // for (const route of routes) {
-  //   console.table(route)
-  // }
-  const merged: PCBTrace["route"] = []
-  // const reverse_log: boolean[] = []
-
-  // Determine if the first route should be reversed
-  const first_route_fp = routes[0][0]
-  const first_route_lp = routes[0][routes[0].length - 1]
-
-  const second_route_fp = routes[1][0]
-  const second_route_lp = routes[1][routes[1].length - 1]
-
-  const best_reverse_dist = Math.min(
-    pdist(first_route_fp, second_route_fp),
-    pdist(first_route_fp, second_route_lp),
-  )
-
-  const best_normal_dist = Math.min(
-    pdist(first_route_lp, second_route_fp),
-    pdist(first_route_lp, second_route_lp),
-  )
-
-  if (best_reverse_dist < best_normal_dist) {
-    merged.push(...routes[0].reverse())
-    // reverse_log.push(true)
-  } else {
-    merged.push(...routes[0])
-    // reverse_log.push(false)
-  }
-
-  for (let i = 1; i < routes.length; i++) {
-    const last_merged_point = merged[merged.length - 1]
-    const next_route = routes[i]
-
-    const next_first_point = next_route[0]
-    const next_last_point = next_route[next_route.length - 1]
-
-    const distance_to_first = pdist(last_merged_point, next_first_point)
-    const distance_to_last = pdist(last_merged_point, next_last_point)
-
-    if (distance_to_first < distance_to_last) {
-      // reverse_log.push(false)
-      merged.push(...next_route)
-    } else {
-      // reverse_log.push(true)
-      merged.push(...next_route.reverse())
-    }
-  }
-  // console.log(reverse_log)
-  // console.table(merged)
-  return merged
-}

package/lib/utils/components/createNetsFromProps.ts

@@ -1,15 +0,0 @@
-import type { PrimitiveComponent } from "lib/components/base-components/PrimitiveComponent"
-import { Net } from "lib/components/primitive-components/Net"
-
-export const createNetsFromProps = (
-  component: PrimitiveComponent,
-  props: (string | undefined | null)[],
-) => {
-  for (const prop of props) {
-    if (typeof prop === "string" && prop.startsWith("net.")) {
-      if (!component.getSubcircuit().selectOne(prop)) {
-        component.getSubcircuit().add(new Net({ name: prop.split("net.")[1] }))
-      }
-    }
-  }
-}

package/lib/utils/constants.ts

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