@tscircuit/parts-engine 0.0.1 → 0.0.2

package/bun.lock

@@ -7,7 +7,7 @@
         "@biomejs/biome": "^1.9.4",
         "@tscircuit/props": "^0.0.172",
         "@types/bun": "latest",
-        "circuit-json": "^0.0.159",
+        "circuit-json": "^0.0.180",
         "tsup": "^8.4.0",
       },
       "peerDependencies": {
@@ -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.180", "", { "dependencies": { "nanoid": "^5.0.7", "zod": "^3.23.6" } }, "sha512-kKaMOWbrymFyg3NoSCadaAdwBBE20p0xNdO9AISLkEytWgvAQCP2Mfb4n99nTYxVIhdD8inPpf5Hzw4xQfSRtA=="],
 
     "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
 

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,116 @@ 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),
+      }
     }
     return {}
   },

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@tscircuit/parts-engine",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "main": "./dist/index.js",
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/props": "^0.0.172",
     "@types/bun": "latest",
-    "circuit-json": "^0.0.159",
+    "circuit-json": "^0.0.180",
     "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",