@tscircuit/parts-engine 0.0.1 → 0.0.3

package/bun.lock

@@ -5,9 +5,9 @@
       "name": "@tscircuit/parts-engine",
       "devDependencies": {
         "@biomejs/biome": "^1.9.4",
-        "@tscircuit/props": "^0.0.172",
+        "@tscircuit/props": "^0.0.227",
         "@types/bun": "latest",
-        "circuit-json": "^0.0.159",
+        "circuit-json": "^0.0.209",
         "tsup": "^8.4.0",
       },
       "peerDependencies": {
@@ -142,7 +142,7 @@
 
     "@tscircuit/manual-edit-events": ["@tscircuit/manual-edit-events@0.0.6", "", { "dependencies": { "zod": "^3.23.8" } }, "sha512-PLgy+/Dsw1YcnNVNqfieNGTNIaRKRJ70Jt2LcSMljwaBOtsiOwtdzj24xCYO9XzJUZc7opKytShMlx863PehTQ=="],
 
-    "@tscircuit/props": ["@tscircuit/props@0.0.172", "", { "peerDependencies": { "@tscircuit/layout": "*", "circuit-json": "*", "react": "*", "zod": "*" } }, "sha512-RKC8g5kBy8+XnT7gjvhXPYR9hogEQJ9Nh0MMRAC3rMyqO3kBCuB2UZduEUwvREyoo42mwN2qlyydDlnIu41Ztg=="],
+    "@tscircuit/props": ["@tscircuit/props@0.0.227", "", { "peerDependencies": { "@tscircuit/layout": "*", "circuit-json": "*", "react": "*", "zod": "*" } }, "sha512-vJMZ2vHPX3nhfYCwCoijp/r+w1SLM3zocVSdofr6VQpV4Ct8JrLJUJ+h3AhKPttD8kunZ66jbWMlC9wA+U7iNQ=="],
 
     "@tscircuit/schematic-autolayout": ["@tscircuit/schematic-autolayout@0.0.6", "", { "dependencies": { "@tscircuit/soup-util": "^0.0.38", "transformation-matrix": "^2.16.1" } }, "sha512-34cQxtlSylBKyHkzaMBCynaWJgN9c/mWm7cz63StTYIafKmfFs383K8Xoc4QX8HXCvVrHYl1aK15onZua9MxeA=="],
 
@@ -172,7 +172,7 @@
 
     "chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="],
 
-    "circuit-json": ["circuit-json@0.0.159", "", { "dependencies": { "nanoid": "^5.0.7", "zod": "^3.23.6" } }, "sha512-NW2xGkLGhjCas6EMvbSjnpak9GV9+axJZnTh6fdu4UHVj97EMMtZOZs9/n4AEyjKexZ9SOknQiW7fTaUkvdnGA=="],
+    "circuit-json": ["circuit-json@0.0.209", "", { "dependencies": { "nanoid": "^5.0.7", "zod": "^3.25.64" } }, "sha512-cu/LQQS7XPGgAfDvwbusQqJbPyMdYRkKN4jMvi837TuCSXa0Xt7cBvSqkQekyipXuAtqnLJiaAucFVHpMUNyWA=="],
 
     "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
 
@@ -306,7 +306,11 @@
 
     "wrap-ansi-cjs": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
 
-    "zod": ["zod@3.24.3", "", {}, "sha512-HhY1oqzWCQWuUqvBFnsyrtZRhyPeR7SUGv+C4+MsisMuVfSPx8HpwWqH8tRahSlt6M3PiFAcoeFhZAqIXTxoSg=="],
+    "zod": ["zod@3.25.64", "", {}, "sha512-hbP9FpSZf7pkS7hRVUrOjhwKJNyampPgtXKc3AN6DsWtoHsg2Sb4SQaS4Tcay380zSwd2VPo9G9180emBACp5g=="],
+
+    "@tscircuit/layout/zod": ["zod@3.24.3", "", {}, "sha512-HhY1oqzWCQWuUqvBFnsyrtZRhyPeR7SUGv+C4+MsisMuVfSPx8HpwWqH8tRahSlt6M3PiFAcoeFhZAqIXTxoSg=="],
+
+    "@tscircuit/manual-edit-events/zod": ["zod@3.24.3", "", {}, "sha512-HhY1oqzWCQWuUqvBFnsyrtZRhyPeR7SUGv+C4+MsisMuVfSPx8HpwWqH8tRahSlt6M3PiFAcoeFhZAqIXTxoSg=="],
 
     "@tscircuit/schematic-autolayout/@tscircuit/soup-util": ["@tscircuit/soup-util@0.0.38", "", { "dependencies": { "parsel-js": "^1.1.2" }, "peerDependencies": { "circuit-json": "*", "transformation-matrix": "*", "zod": "*" } }, "sha512-GdcuFxk+qnJZv+eI7ZoJ1MJEseFgRyaztMtQ/OXA2SUnxyPEH0UTy9vkhKTm+8GTePryEgdXcc65TgUyrr44ww=="],
 

package/lib/jlc-parts-engine.ts

@@ -54,9 +54,9 @@ export const jlcPartsEngine: PartsEngine = {
       sourceComponent.type === "source_component" &&
       sourceComponent.ftype === "simple_pin_header"
     ) {
-      let pitch
+      let pitch: number | undefined
       if (footprinterString?.includes("_p")) {
-        pitch = footprinterString.split("_p")[1]
+        pitch = Number(footprinterString.split("_p")[1])
       }
       const { headers } = await getJlcPartsCached(
         "headers",
@@ -74,6 +74,127 @@ export const jlcPartsEngine: PartsEngine = {
       return {
         jlcpcb: headers.map((h: any) => `C${h.lcsc}`).slice(0, 3),
       }
+    } else if (
+      sourceComponent.type === "source_component" &&
+      sourceComponent.ftype === "simple_potentiometer"
+    ) {
+      const { potentiometers } = await getJlcPartsCached("potentiometers", {
+        resistance: sourceComponent.max_resistance,
+        package: footprinterString,
+      })
+      return {
+        jlcpcb: potentiometers.map((p: any) => `C${p.lcsc}`).slice(0, 3),
+      }
+    } else if (
+      sourceComponent.type === "source_component" &&
+      sourceComponent.ftype === "simple_diode"
+    ) {
+      const { diodes } = await getJlcPartsCached("diodes", {
+        package: footprinterString,
+      })
+      return {
+        jlcpcb: diodes.map((d: any) => `C${d.lcsc}`).slice(0, 3),
+      }
+    } else if (
+      sourceComponent.type === "source_component" &&
+      sourceComponent.ftype === "simple_chip"
+    ) {
+      const { chips } = await getJlcPartsCached("chips", {
+        package: footprinterString,
+      })
+      return {
+        jlcpcb: chips.map((c: any) => `C${c.lcsc}`).slice(0, 3),
+      }
+    } else if (
+      sourceComponent.type === "source_component" &&
+      sourceComponent.ftype === "simple_transistor"
+    ) {
+      const { transistors } = await getJlcPartsCached("transistors", {
+        package: footprinterString,
+        transistor_type: sourceComponent.transistor_type,
+      })
+      return {
+        jlcpcb: transistors.map((t: any) => `C${t.lcsc}`).slice(0, 3),
+      }
+    } else if (
+      sourceComponent.type === "source_component" &&
+      sourceComponent.ftype === "simple_power_source"
+    ) {
+      const { power_sources } = await getJlcPartsCached("power_sources", {
+        voltage: sourceComponent.voltage,
+        package: footprinterString,
+      })
+      return {
+        jlcpcb: power_sources.map((p: any) => `C${p.lcsc}`).slice(0, 3),
+      }
+    } else if (
+      sourceComponent.type === "source_component" &&
+      sourceComponent.ftype === "simple_inductor"
+    ) {
+      const { inductors } = await getJlcPartsCached("inductors", {
+        inductance: sourceComponent.inductance,
+        package: footprinterString,
+      })
+      return {
+        jlcpcb: inductors.map((i: any) => `C${i.lcsc}`).slice(0, 3),
+      }
+    } else if (
+      sourceComponent.type === "source_component" &&
+      sourceComponent.ftype === "simple_crystal"
+    ) {
+      const { crystals } = await getJlcPartsCached("crystals", {
+        frequency: sourceComponent.frequency,
+        load_capacitance: sourceComponent.load_capacitance,
+        package: footprinterString,
+      })
+      return {
+        jlcpcb: crystals.map((c: any) => `C${c.lcsc}`).slice(0, 3),
+      }
+    } else if (
+      sourceComponent.type === "source_component" &&
+      sourceComponent.ftype === "simple_mosfet"
+    ) {
+      const { mosfets } = await getJlcPartsCached("mosfets", {
+        package: footprinterString,
+        mosfet_mode: sourceComponent.mosfet_mode,
+        channel_type: sourceComponent.channel_type,
+      })
+      return {
+        jlcpcb: mosfets.map((m: any) => `C${m.lcsc}`).slice(0, 3),
+      }
+    } else if (
+      sourceComponent.type === "source_component" &&
+      sourceComponent.ftype === "simple_resonator"
+    ) {
+      const { resonators } = await getJlcPartsCached("resonators", {
+        frequency: sourceComponent.frequency,
+        package: footprinterString,
+      })
+      return {
+        jlcpcb: resonators.map((r: any) => `C${r.lcsc}`).slice(0, 3),
+      }
+    } else if (
+      sourceComponent.type === "source_component" &&
+      sourceComponent.ftype === "simple_switch"
+    ) {
+      const { switches } = await getJlcPartsCached("switches", {
+        switch_type: sourceComponent.type,
+        package: footprinterString,
+      })
+      return {
+        jlcpcb: switches.map((s: any) => `C${s.lcsc}`).slice(0, 3),
+      }
+    }
+    else if (
+      sourceComponent.type === "source_component" &&
+      sourceComponent.ftype === "simple_led"
+    ) {
+      const { leds } = await getJlcPartsCached("leds", {
+        package: footprinterString,
+      })
+      return {
+        jlcpcb: leds.map((l: any) => `C${l.lcsc}`).slice(0, 3),
+      }
     }
     return {}
   },

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@tscircuit/parts-engine",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "main": "./dist/index.js",
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
-    "@tscircuit/props": "^0.0.172",
+    "@tscircuit/props": "^0.0.227",
     "@types/bun": "latest",
-    "circuit-json": "^0.0.159",
+    "circuit-json": "^0.0.209",
     "tsup": "^8.4.0"
   },
   "scripts": {

package/tests/jlc-parts-engine.test.ts

@@ -19,6 +19,13 @@ describe("jlcPartsEngine", () => {
           }),
         } as Response
       }
+      if (url.includes("/potentiometers/")) {
+        return {
+          json: async () => ({
+            potentiometers: [{ lcsc: "1234" }, { lcsc: "5678" }, { lcsc: "9012" }],
+          }),
+        } as Response
+      }
       if (url.includes("/headers/")) {
         return {
           json: async () => ({
@@ -26,6 +33,69 @@ describe("jlcPartsEngine", () => {
           }),
         } as Response
       }
+      if (url.includes("/diodes/")) {
+        return {
+          json: async () => ({
+            diodes: [{ lcsc: "4567" }, { lcsc: "8901" }, { lcsc: "2345" }],
+          }),
+        } as Response
+      }
+      if (url.includes("/chips/")) {
+        return {
+          json: async () => ({
+            chips: [{ lcsc: "5678" }, { lcsc: "9012" }, { lcsc: "3456" }],
+          }),
+        } as Response
+      }
+      if (url.includes("/transistors/")) {
+        return {
+          json: async () => ({
+            transistors: [{ lcsc: "6789" }, { lcsc: "0123" }, { lcsc: "4567" }],
+          }),
+        } as Response
+      }
+      if (url.includes("/power_sources/")) {
+        return {
+          json: async () => ({
+            power_sources: [{ lcsc: "7890" }, { lcsc: "1234" }, { lcsc: "5678" }],
+          }),
+        } as Response
+      }
+      if (url.includes("/inductors/")) {
+        return {
+          json: async () => ({
+            inductors: [{ lcsc: "8901" }, { lcsc: "2345" }, { lcsc: "6789" }],
+          }),
+        } as Response
+      }
+      if (url.includes("/crystals/")) {
+        return {
+          json: async () => ({
+            crystals: [{ lcsc: "9012" }, { lcsc: "3456" }, { lcsc: "7890" }],
+          }),
+        } as Response
+      }
+      if (url.includes("/mosfets/")) {
+        return {
+          json: async () => ({
+            mosfets: [{ lcsc: "0123" }, { lcsc: "4567" }, { lcsc: "8901" }],
+          }),
+        } as Response
+      }
+      if (url.includes("/resonators/")) {
+        return {
+          json: async () => ({
+            resonators: [{ lcsc: "1234" }, { lcsc: "5678" }, { lcsc: "9012" }],
+          }),
+        } as Response
+      }
+      if (url.includes("/switches/")) {
+        return {
+          json: async () => ({
+            switches: [{ lcsc: "2345" }, { lcsc: "6789" }, { lcsc: "0123" }],
+          }),
+        } as Response
+      }
       return {} as Response
     }) as unknown as typeof fetch
   })
@@ -88,6 +158,197 @@ describe("jlcPartsEngine", () => {
     })
   })
 
+  // potentiometers
+  test("should find potentiometers", async () => {
+    const potentiometer: AnySourceComponent = {
+      type: "source_component",
+      ftype: "simple_potentiometer",
+      source_component_id: "source_component_0",
+      name: "P1",
+      max_resistance: 10000,
+    }
+
+    const result = await jlcPartsEngine.findPart({
+      sourceComponent: potentiometer,
+      footprinterString: "10k",
+    })
+
+    expect(result).toEqual({
+      jlcpcb: ["C1234", "C5678", "C9012"],
+    })
+  })
+
+  test("should find diode parts", async () => {
+    const diode: AnySourceComponent = {
+      type: "source_component",
+      ftype: "simple_diode",
+      source_component_id: "source_component_0",
+      name: "D1",
+    }
+
+    const result = await jlcPartsEngine.findPart({
+      sourceComponent: diode,
+      footprinterString: "SOD-123",
+    })
+
+    expect(result).toEqual({
+      jlcpcb: ["C4567", "C8901", "C2345"],
+    })
+  })
+
+  test("should find chip parts", async () => {
+    const chip: AnySourceComponent = {
+      type: "source_component",
+      ftype: "simple_chip",
+      source_component_id: "source_component_0",
+      name: "U1",
+    }
+
+    const result = await jlcPartsEngine.findPart({
+      sourceComponent: chip,
+      footprinterString: "SOIC-8",
+    })
+
+    expect(result).toEqual({
+      jlcpcb: ["C5678", "C9012", "C3456"],
+    })
+  })
+
+  test("should find transistor parts", async () => {
+    const transistor: AnySourceComponent = {
+      type: "source_component",
+      ftype: "simple_transistor",
+      transistor_type: "npn",
+      source_component_id: "source_component_0",
+      name: "Q1",
+    }
+
+    const result = await jlcPartsEngine.findPart({
+      sourceComponent: transistor,
+      footprinterString: "SOT-23",
+    })
+
+    expect(result).toEqual({
+      jlcpcb: ["C6789", "C0123", "C4567"],
+    })
+  })
+
+  test("should find power source parts", async () => {
+    const powerSource: AnySourceComponent = {
+      type: "source_component",
+      ftype: "simple_power_source",
+      voltage: 5,
+      source_component_id: "source_component_0",
+      name: "V1",
+    }
+
+    const result = await jlcPartsEngine.findPart({
+      sourceComponent: powerSource,
+      footprinterString: "SOT-223",
+    })
+
+    expect(result).toEqual({
+      jlcpcb: ["C7890", "C1234", "C5678"],
+    })
+  })
+
+  test("should find inductor parts", async () => {
+    const inductor: AnySourceComponent = {
+      type: "source_component",
+      ftype: "simple_inductor",
+      inductance: 100,
+      source_component_id: "source_component_0",
+      name: "L1",
+    }
+
+    const result = await jlcPartsEngine.findPart({
+      sourceComponent: inductor,
+      footprinterString: "0603",
+    })
+
+    expect(result).toEqual({
+      jlcpcb: ["C8901", "C2345", "C6789"],
+    })
+  })
+
+  test("should find crystal parts", async () => {
+    const crystal: AnySourceComponent = {
+      type: "source_component",
+      ftype: "simple_crystal",
+      frequency: 16000000,
+      load_capacitance: 20,
+      source_component_id: "source_component_0",
+      name: "X1",
+    }
+
+    const result = await jlcPartsEngine.findPart({
+      sourceComponent: crystal,
+      footprinterString: "HC-49S",
+    })
+
+    expect(result).toEqual({
+      jlcpcb: ["C9012", "C3456", "C7890"],
+    })
+  })
+
+  test("should find MOSFET parts", async () => {
+    const mosfet: AnySourceComponent = {
+      type: "source_component",
+      ftype: "simple_mosfet",
+      mosfet_mode: "enhancement",
+      channel_type: "n",
+      source_component_id: "source_component_0",
+      name: "M1",
+    }
+
+    const result = await jlcPartsEngine.findPart({
+      sourceComponent: mosfet,
+      footprinterString: "SOT-23",
+    })
+
+    expect(result).toEqual({
+      jlcpcb: ["C0123", "C4567", "C8901"],
+    })
+  })
+
+  test("should find resonator parts", async () => {
+    const resonator: AnySourceComponent = {
+      type: "source_component",
+      ftype: "simple_resonator",
+      frequency: 16000000,
+      load_capacitance: 20,
+      source_component_id: "source_component_0",
+      name: "Y1",
+    }
+
+    const result = await jlcPartsEngine.findPart({
+      sourceComponent: resonator,
+      footprinterString: "SMD",
+    })
+
+    expect(result).toEqual({
+      jlcpcb: ["C1234", "C5678", "C9012"],
+    })
+  })
+
+  test("should find switch parts", async () => {
+    const switch_: AnySourceComponent = {
+      type: "source_component",
+      ftype: "simple_switch",
+      source_component_id: "source_component_0",
+      name: "SW1",
+    }
+
+    const result = await jlcPartsEngine.findPart({
+      sourceComponent: switch_,
+      footprinterString: "SMD",
+    })
+
+    expect(result).toEqual({
+      jlcpcb: ["C2345", "C6789", "C0123"],
+    })
+  })
+
   test("should return empty object for unknown component types", async () => {
     const unknown: AnySourceComponent = {
       type: "source_component",