replaced @tscircuit/soup to circuit-json, refactor tests from ava to …

…bun:test (#16)

* replaced @tscircuit/soup to circuit-json

and AnySoupElement to AnyCircuitElement

* convert to esm

* now tests with bun

* test script

* moduleResolution to Bundler

.gitignore

@@ -2,3 +2,4 @@ node_modules
 .vscode
 dist
 .aider*
+package-lock.json

lib/apply-selector.ts

@@ -1,11 +1,11 @@
 import * as parsel from "parsel-js"
 import { convertAbbrToType } from "./convert-abbreviation-to-soup-element-type"
-import type { AnySoupElement } from "@tscircuit/soup"
+import type { AnyCircuitElement } from "circuit-json"
 
 const filterByType = (
-  elements: AnySoupElement[],
+  elements: AnyCircuitElement[],
   type: string
-): AnySoupElement[] => {
+): AnyCircuitElement[] => {
   type = convertAbbrToType(type)
   return elements.filter(
     (elm) => ("ftype" in elm && elm.ftype === type) || elm.type === type
@@ -17,21 +17,21 @@ const filterByType = (
  * resistor you can do ".R1 > port.left"
  */
 export const applySelector = (
-  elements: AnySoupElement[],
+  elements: AnyCircuitElement[],
   selectorRaw: string
-): AnySoupElement[] => {
+): AnyCircuitElement[] => {
   const selectorAST = parsel.parse(selectorRaw)
   return applySelectorAST(elements, selectorAST!)
 }
 
-const doesElmMatchClassName = (elm: AnySoupElement, className: string) =>
+const doesElmMatchClassName = (elm: AnyCircuitElement, className: string) =>
   ("name" in elm && elm.name === className) ||
   ("port_hints" in elm && elm.port_hints?.includes(className))
 
 export const applySelectorAST = (
-  elements: AnySoupElement[],
+  elements: AnyCircuitElement[],
   selectorAST: parsel.AST
-): AnySoupElement[] => {
+): AnyCircuitElement[] => {
   switch (selectorAST.type) {
     case "complex": {
       switch (selectorAST.combinator) {
@@ -40,7 +40,7 @@ export const applySelectorAST = (
           const { left, right } = selectorAST
           if (left.type === "class" || left.type === "type") {
             // TODO should also check if content matches any element tags
-            let matchElms: AnySoupElement[]
+            let matchElms: AnyCircuitElement[]
             if (left.type === "class") {
               matchElms = elements.filter((elm) =>
                 doesElmMatchClassName(elm, left.name)
@@ -89,7 +89,7 @@ export const applySelectorAST = (
       )
     }
     case "type": {
-      return filterByType(elements, selectorAST.name) as AnySoupElement[]
+      return filterByType(elements, selectorAST.name) as AnyCircuitElement[]
     }
     case "class": {
       return elements.filter((elm) =>

lib/get-bounds-of-pcb-elements.ts

@@ -1,4 +1,4 @@
-import type { AnyCircuitElement } from "@tscircuit/soup"
+import type { AnyCircuitElement } from "circuit-json"
 
 export const getBoundsOfPcbElements = (
   elements: AnyCircuitElement[],

lib/get-element-by-id.ts

@@ -1,9 +1,9 @@
-import type { AnySoupElement } from "@tscircuit/soup"
+import type { AnyCircuitElement } from "circuit-json"
 import { getElementId } from "./get-element-id"
 
 export const getElementById = (
-  soup: AnySoupElement[],
+  soup: AnyCircuitElement[],
   id: string,
-): AnySoupElement | null => {
+): AnyCircuitElement | null => {
   return soup.find((elm) => getElementId(elm) === id) ?? null
 }

lib/get-element-id.ts

@@ -1,6 +1,6 @@
-import type { AnySoupElement } from "@tscircuit/soup"
+import type { AnyCircuitElement } from "circuit-json"
 
-export const getElementId = (elm: AnySoupElement): string => {
+export const getElementId = (elm: AnyCircuitElement): string => {
   const type = elm.type
   const id = (elm as any)[`${type}_id`]
   return id

lib/readable-name-functions/get-readable-name-for-element.ts

@@ -1,13 +1,13 @@
-import type { AnySoupElement } from "@tscircuit/soup"
+import type { AnyCircuitElement } from "circuit-json"
 import { getReadableNameForPcbTrace } from "./get-readable-name-for-pcb-trace"
 import { getReadableNameForPcbSmtpad } from "./get-readable-name-for-pcb-smtpad"
 import { getReadableNameForPcbPort } from "./get-readable-name-for-pcb-port"
 import { getElementById } from "lib/get-element-by-id"
 import { getElementId } from "lib/get-element-id"
 
 export const getReadableNameForElement = (
-  soup: AnySoupElement[],
-  elm: AnySoupElement | string,
+  soup: AnyCircuitElement[],
+  elm: AnyCircuitElement | string,
 ): string => {
   if (typeof elm === "string") {
     const elmObj = getElementById(soup, elm)

lib/readable-name-functions/get-readable-name-for-pcb-port.ts

@@ -1,8 +1,8 @@
-import type { AnySoupElement } from "@tscircuit/soup"
+import type { AnyCircuitElement } from "circuit-json"
 import { su } from "../su"
 
 export const getReadableNameForPcbPort = (
-  soup: AnySoupElement[],
+  soup: AnyCircuitElement[],
   pcb_port_id: string,
 ): string => {
   const pcbPort = su(soup).pcb_port.get(pcb_port_id)

lib/readable-name-functions/get-readable-name-for-pcb-smtpad.ts

@@ -1,9 +1,9 @@
-import type { AnySoupElement } from "@tscircuit/soup"
+import type { AnyCircuitElement } from "circuit-json"
 import { su } from "../su"
 import { getReadableNameForPcbPort } from "./get-readable-name-for-pcb-port"
 
 export function getReadableNameForPcbSmtpad(
-  soup: AnySoupElement[],
+  soup: AnyCircuitElement[],
   pcb_smtpad_id: string,
 ): string {
   // Find the pcb_smtpad object

lib/readable-name-functions/get-readable-name-for-pcb-trace.ts

@@ -1,8 +1,8 @@
-import type { AnySoupElement } from "@tscircuit/soup"
+import type { AnyCircuitElement } from "circuit-json"
 import { su } from "../su"
 
 export function getReadableNameForPcbTrace(
-  soup: AnySoupElement[],
+  soup: AnyCircuitElement[],
   pcb_trace_id: string,
 ) {
   // Find the pcb_trace object

lib/su.ts

@@ -1,14 +1,14 @@
 import type {
-  AnySoupElement,
-  AnySoupElementInput,
+  AnyCircuitElement,
+  AnyCircuitElementInput,
   SourceComponentBase,
   SourcePort,
-} from "@tscircuit/soup"
-import * as Soup from "@tscircuit/soup"
+} from "circuit-json"
+import * as Soup from "circuit-json"
 
 type SoupOps<
-  K extends AnySoupElement["type"],
-  T extends AnySoupElement | AnySoupElementInput,
+  K extends AnyCircuitElement["type"],
+  T extends AnyCircuitElement | AnyCircuitElementInput,
 > = {
   get: (id: string) => Extract<T, { type: K }> | null
   select: (selector: string) => Extract<T, { type: K }> | null
@@ -28,31 +28,31 @@ type SoupOps<
 }
 
 export type SoupUtilObjects = {
-  [K in AnySoupElement["type"]]: SoupOps<K, AnySoupElement>
+  [K in AnyCircuitElement["type"]]: SoupOps<K, AnyCircuitElement>
 } & {
-  toArray: () => AnySoupElement[]
+  toArray: () => AnyCircuitElement[]
 }
 export type SoupInputUtilObjects = {
-  [K in AnySoupElementInput["type"]]: SoupOps<K, AnySoupElementInput>
+  [K in AnyCircuitElementInput["type"]]: SoupOps<K, AnyCircuitElementInput>
 }
 
 export type SoupUtilOptions = {
   validateInserts?: boolean
 }
 
 export type GetSoupUtilFn = ((
-  soup: AnySoupElement[],
+  soup: AnyCircuitElement[],
   options?: SoupUtilOptions,
 ) => SoupUtilObjects) & {
-  unparsed: (soup: AnySoupElementInput[]) => SoupInputUtilObjects
+  unparsed: (soup: AnyCircuitElementInput[]) => SoupInputUtilObjects
 }
 
 interface InternalStore {
   counts: Record<string, number>
 }
 
 export const su: GetSoupUtilFn = ((
-  soup: AnySoupElement[],
+  soup: AnyCircuitElement[],
   options: SoupUtilOptions = {},
 ) => {
   let internalStore: InternalStore = (soup as any)._internal_store

lib/transform-soup-elements.ts

@@ -1,4 +1,4 @@
-import type { AnySoupElement } from "@tscircuit/soup"
+import type { AnyCircuitElement } from "circuit-json"
 import { type Matrix, applyToPoint, decomposeTSR } from "transformation-matrix"
 import {
   directionToVec,
@@ -7,7 +7,7 @@ import {
 } from "./direction-to-vec"
 
 export const transformSchematicElement = (
-  elm: AnySoupElement,
+  elm: AnyCircuitElement,
   matrix: Matrix,
 ) => {
   if (elm.type === "schematic_component") {
@@ -43,13 +43,13 @@ export const transformSchematicElement = (
 }
 
 export const transformSchematicElements = (
-  elms: AnySoupElement[],
+  elms: AnyCircuitElement[],
   matrix: Matrix,
 ) => {
   return elms.map((elm) => transformSchematicElement(elm, matrix))
 }
 
-export const transformPCBElement = (elm: AnySoupElement, matrix: Matrix) => {
+export const transformPCBElement = (elm: AnyCircuitElement, matrix: Matrix) => {
   if (
     elm.type === "pcb_plated_hole" ||
     elm.type === "pcb_hole" ||
@@ -106,7 +106,7 @@ export const transformPCBElement = (elm: AnySoupElement, matrix: Matrix) => {
 }
 
 export const transformPCBElements = (
-  elms: AnySoupElement[],
+  elms: AnyCircuitElement[],
   matrix: Matrix,
 ) => {
   const tsr = decomposeTSR(matrix)

package.json

@@ -6,24 +6,23 @@
   "files": [
     "dist"
   ],
-  "main": "dist/index.cjs",
+  "main": "dist/index.js",
   "scripts": {
-    "test": "ava",
+    "test": "bun test",
     "prepublish": "npm run build",
-    "build": "tsup-node ./index.ts --dts --sourcemap"
+    "build": "tsup-node ./index.ts --format esm --dts --sourcemap"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
   "peerDependencies": {
-    "@tscircuit/soup": "*",
+    "circuit-json": "*",
     "transformation-matrix": "*",
     "zod": "*"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.2",
-    "@tscircuit/soup": "^0.0.71",
-    "ava": "^6.1.2",
+    "circuit-json": "^0.0.78",
     "esbuild": "^0.20.2",
     "esbuild-register": "^3.5.0",
     "transformation-matrix": "^2.16.1",
@@ -32,6 +31,7 @@
     "zod": "^3.23.6"
   },
   "dependencies": {
+    "@types/bun": "^1.1.10",
     "parsel-js": "^1.1.2"
   }
 }

tests/delete.test.ts

@@ -1,9 +1,9 @@
-import type { AnySoupElement } from "@tscircuit/soup"
+import type { AnyCircuitElement } from "circuit-json"
 import { su } from "../index"
-import test from "ava"
+import { test, expect } from "bun:test"
 
-test("delete", (t) => {
-  const soup: AnySoupElement[] = [
+test("delete", () => {
+  const soup: AnyCircuitElement[] = [
     {
       type: "source_component",
       source_component_id: "simple_resistor_0",
@@ -26,5 +26,5 @@ test("delete", (t) => {
     .toArray()
     .find((e) => e.type === "source_port")
 
-  t.falsy(sp)
+  expect(sp).toBeFalsy()
 })

tests/get-bounds-of-pcb-elements.test.ts

@@ -1,8 +1,9 @@
-import test from "ava"
 import { getBoundsOfPcbElements } from "../lib/get-bounds-of-pcb-elements"
+import type { AnyCircuitElement } from "circuit-json"
+import { expect, test } from "bun:test"
 
-test("getBoundsOfPcbElements", (t) => {
-  const elements: AnySoupElement[] = [
+test("getBoundsOfPcbElements", () => {
+  const elements: AnyCircuitElement[] = [
     {
       type: "pcb_component",
       pcb_component_id: "comp1",
@@ -35,5 +36,5 @@ test("getBoundsOfPcbElements", (t) => {
 
   const bounds = getBoundsOfPcbElements(elements)
 
-  t.deepEqual(bounds, { minX: -5, minY: -5, maxX: 20, maxY: 20 })
+  expect(bounds).toEqual({ minX: -5, minY: -5, maxX: 20, maxY: 20 })
 })

tests/get-readable-name-for-element.test.ts

@@ -1,9 +1,9 @@
-import test from "ava"
 import { getReadableNameForElement } from "../lib/readable-name-functions/get-readable-name-for-element"
-import type { AnySoupElement } from "@tscircuit/soup"
+import type { AnyCircuitElement } from "circuit-json"
+import { expect, test } from "bun:test"
 
-test("getReadableNameForElement for pcb_port, pcb_smtpad, and pcb_trace", (t) => {
-  const soup: AnySoupElement[] = [
+test("getReadableNameForElement for pcb_port, pcb_smtpad, and pcb_trace", () => {
+  const soup: AnyCircuitElement[] = [
     {
       type: "source_component",
       source_component_id: "sc1",
@@ -106,23 +106,13 @@ test("getReadableNameForElement for pcb_port, pcb_smtpad, and pcb_trace", (t) =>
   ]
 
   // Test pcb_port
-  t.is(
-    getReadableNameForElement(soup, "pp1"),
-    "pcb_port[.R1 > .1]",
-    "PCB port readable name",
-  )
+  expect(getReadableNameForElement(soup, "pp1")).toBe("pcb_port[.R1 > .1]")
 
   // Test pcb_smtpad
-  t.is(
-    getReadableNameForElement(soup, "ps1"),
-    "pcb_port[.R1 > .1]",
-    "PCB SMT pad readable name",
-  )
+  expect(getReadableNameForElement(soup, "ps1")).toBe("pcb_port[.R1 > .1]")
 
   // Test pcb_trace
-  t.is(
-    getReadableNameForElement(soup, "pt1"),
+  expect(getReadableNameForElement(soup, "pt1")).toBe(
     "trace[.R1 > port.left, .C1 > port.positive]",
-    "PCB trace readable name",
   )
 })

tests/get-using.test.ts

@@ -1,9 +1,9 @@
-import type { AnySoupElementInput } from "@tscircuit/soup"
+import type { AnyCircuitElementInput } from "circuit-json"
 import { su } from "../index"
-import test from "ava"
+import { test, expect } from "bun:test"
 
-test("getUsing", (t) => {
-  const soup: AnySoupElementInput[] = [
+test("getUsing", () => {
+  const soup: AnyCircuitElementInput[] = [
     {
       type: "source_component",
       source_component_id: "simple_resistor_0",
@@ -23,5 +23,5 @@ test("getUsing", (t) => {
   const sc = su.unparsed(soup).source_component.getUsing({
     source_port_id: "source_port_0",
   })
-  t.is(sc?.name, "R1")
+  expect(sc?.name).toBe("R1")
 })