@tscircuit/parts-engine 0.0.24 → 0.0.26

package/README.md

@@ -1,2 +1,19 @@
 # parts-engine
-The tscircuit platform parts engine
+
+The tscircuit platform parts engine.
+
+## Supplier engines
+
+```ts
+import {
+  digikeyPartsEngine,
+  jlcPartsEngine,
+  DigiKeyPartsEngine,
+} from "@tscircuit/parts-engine"
+```
+
+`digikeyPartsEngine.findPart(...)` queries
+`https://digikeysearch.tscircuit.com`, which provides the same category route
+shape as jlcsearch while caching DigiKey Product Information V4 calls. Use
+`new DigiKeyPartsEngine({ platformFetch, apiBaseUrl })` to inject a platform
+fetch implementation or a test/self-hosted endpoint.

package/dist/index.d.ts

@@ -4374,4 +4374,39 @@ declare const getFetchWithEasyEdaProxy: ({ platformFetch: upstreamFetch, easyEda
 
 declare const jlcPartsEngine: JlcPcbPartsEngine;
 
-export { type EasyEdaProxyConfig, type FetchPartCircuitJsonParams, JlcPcbPartsEngine, type JlcPcbPartsEngineOptions, type PlatformFetch, cache, getFetchWithEasyEdaProxy, jlcPartsEngine };
+type DigiKeyPartsEngineOptions = {
+    platformFetch?: PlatformFetch;
+    apiBaseUrl?: string;
+};
+type DigiKeySearchPart = {
+    digikey_product_number: string;
+    supplier_part_number?: string;
+    mfr: string;
+    manufacturer?: string;
+    package?: string;
+    description?: string;
+    stock: number;
+    price?: number;
+    normally_stocking?: boolean;
+};
+
+declare class DigiKeyPartsEngine implements PartsEngine {
+    private readonly platformFetch;
+    private readonly apiBaseUrl;
+    constructor(options?: DigiKeyPartsEngineOptions);
+    private getCategoryParts;
+    private getKeywordParts;
+    private toSupplierPartNumbers;
+    findPart({ sourceComponent, footprinterString, }: Parameters<PartsEngine["findPart"]>[0]): Promise<{}>;
+}
+
+declare const digikeyCache: Map<string, unknown>;
+declare const getDigiKeyPartsCached: (path: string, params: Record<string, string | number | boolean | undefined>, options?: {
+    platformFetch?: PlatformFetch;
+    apiBaseUrl?: string;
+}) => Promise<Record<string, DigiKeySearchPart[]>>;
+declare const withDigiKeyStockPreference: (parts: DigiKeySearchPart[] | undefined) => DigiKeySearchPart[];
+
+declare const digikeyPartsEngine: DigiKeyPartsEngine;
+
+export { DigiKeyPartsEngine, type DigiKeyPartsEngineOptions, type DigiKeySearchPart, type EasyEdaProxyConfig, type FetchPartCircuitJsonParams, JlcPcbPartsEngine, type JlcPcbPartsEngineOptions, type PlatformFetch, cache, digikeyCache, digikeyPartsEngine, getDigiKeyPartsCached, getFetchWithEasyEdaProxy, jlcPartsEngine, withDigiKeyStockPreference };

package/dist/index.js

@@ -11282,12 +11282,18 @@ var getFetchWithEasyEdaProxy = ({
     const proxyRequestBody = METHODS_WITHOUT_BODY.has(
       mergedTargetRequest.method
     ) ? void 0 : await mergedTargetRequest.clone().arrayBuffer();
-    return upstreamFetch(easyEdaProxyConfig.proxyEndpointUrl, {
+    const response = await upstreamFetch(easyEdaProxyConfig.proxyEndpointUrl, {
       method: mergedTargetRequest.method,
       headers: proxyRequestHeaders,
       body: proxyRequestBody,
       signal: requestInit?.signal
     });
+    if (response.status === 401) {
+      const proxyErrorResponse = await response.json().catch(() => null);
+      const errorCode = typeof proxyErrorResponse === "object" && proxyErrorResponse !== null && "error_code" in proxyErrorResponse && typeof proxyErrorResponse.error_code === "string" ? proxyErrorResponse.error_code : "unauthorized";
+      throw new Error(`EasyEDA proxy request failed: ${errorCode} (HTTP 401)`);
+    }
+    return response;
   };
 };
 
@@ -11539,10 +11545,195 @@ var JlcPcbPartsEngine = class {
 
 // lib/jlc-parts-engine/index.ts
 var jlcPartsEngine = new JlcPcbPartsEngine();
+
+// lib/digikey-parts-engine/digikey-parts-cache.ts
+var digikeyCache = /* @__PURE__ */ new Map();
+var normalizeBaseUrl = (baseUrl) => baseUrl.replace(/\/$/, "");
+var getDigiKeyPartsCached = async (path, params, options = {}) => {
+  const platformFetch = options.platformFetch ?? globalThis.fetch;
+  const baseUrl = normalizeBaseUrl(
+    options.apiBaseUrl ?? "https://digikeysearch.tscircuit.com"
+  );
+  const url = new URL(path, `${baseUrl}/`);
+  for (const [name, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== "") {
+      url.searchParams.set(name, String(value));
+    }
+  }
+  url.searchParams.set("json", "true");
+  const cacheKey = url.toString();
+  const cached = digikeyCache.get(cacheKey);
+  if (cached) return cached;
+  const response = await platformFetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `DigiKey search failed (${response.status}): ${await response.text()}`
+    );
+  }
+  const responseJson = await response.json();
+  digikeyCache.set(cacheKey, responseJson);
+  return responseJson;
+};
+var withDigiKeyStockPreference = (parts) => [...parts ?? []].sort(
+  (a, b) => Number(b.normally_stocking ?? false) - Number(a.normally_stocking ?? false) || (b.stock ?? 0) - (a.stock ?? 0)
+);
+
+// lib/digikey-parts-engine/DigiKeyPartsEngine.ts
+var DigiKeyPartsEngine = class {
+  platformFetch;
+  apiBaseUrl;
+  constructor(options = {}) {
+    this.platformFetch = options.platformFetch;
+    this.apiBaseUrl = options.apiBaseUrl;
+    this.findPart = this.findPart.bind(this);
+  }
+  async getCategoryParts(path, responseKey, params) {
+    const response = await getDigiKeyPartsCached(path, params, {
+      platformFetch: this.platformFetch,
+      apiBaseUrl: this.apiBaseUrl
+    });
+    return response[responseKey] ?? [];
+  }
+  async getKeywordParts(query) {
+    const response = await getDigiKeyPartsCached(
+      "/api/search",
+      { q: query, limit: 20 },
+      {
+        platformFetch: this.platformFetch,
+        apiBaseUrl: this.apiBaseUrl
+      }
+    );
+    return response.components ?? [];
+  }
+  toSupplierPartNumbers(parts) {
+    return {
+      digikey: withDigiKeyStockPreference(parts).map((part) => part.digikey_product_number).filter(Boolean).slice(0, 3)
+    };
+  }
+  async findPart({
+    sourceComponent,
+    footprinterString
+  }) {
+    if (sourceComponent.type !== "source_component") return {};
+    const packageName = getJlcpcbPackageName(footprinterString);
+    if (sourceComponent.ftype === "simple_resistor") {
+      return this.toSupplierPartNumbers(
+        await this.getCategoryParts("/resistors/list", "resistors", {
+          resistance: sourceComponent.resistance,
+          package: packageName
+        })
+      );
+    }
+    if (sourceComponent.ftype === "simple_capacitor") {
+      return this.toSupplierPartNumbers(
+        await this.getCategoryParts("/capacitors/list", "capacitors", {
+          capacitance: sourceComponent.capacitance,
+          package: packageName
+        })
+      );
+    }
+    if (sourceComponent.ftype === "simple_pin_header") {
+      return this.toSupplierPartNumbers(
+        await this.getCategoryParts(
+          "/headers/list",
+          "headers",
+          getPinHeaderSearchParams(sourceComponent, footprinterString)
+        )
+      );
+    }
+    if (sourceComponent.ftype === "simple_potentiometer") {
+      return this.toSupplierPartNumbers(
+        await this.getCategoryParts("/potentiometers/list", "potentiometers", {
+          resistance: sourceComponent.max_resistance,
+          package: packageName
+        })
+      );
+    }
+    if (sourceComponent.ftype === "simple_diode") {
+      return this.toSupplierPartNumbers(
+        await this.getCategoryParts("/diodes/list", "diodes", {
+          package: packageName
+        })
+      );
+    }
+    if (sourceComponent.ftype === "simple_transistor") {
+      return this.toSupplierPartNumbers(
+        await this.getCategoryParts(
+          "/bjt_transistors/list",
+          "bjt_transistors",
+          { package: packageName }
+        )
+      );
+    }
+    if (sourceComponent.ftype === "simple_mosfet") {
+      return this.toSupplierPartNumbers(
+        await this.getCategoryParts("/mosfets/list", "mosfets", {
+          package: packageName,
+          channel_type: sourceComponent.channel_type,
+          mosfet_mode: sourceComponent.mosfet_mode
+        })
+      );
+    }
+    if (sourceComponent.ftype === "simple_switch") {
+      return this.toSupplierPartNumbers(
+        await this.getCategoryParts("/switches/list", "switches", {
+          package: packageName
+        })
+      );
+    }
+    if (sourceComponent.ftype === "simple_led") {
+      return this.toSupplierPartNumbers(
+        await this.getCategoryParts("/leds/list", "leds", {
+          package: packageName
+        })
+      );
+    }
+    if (sourceComponent.ftype === "simple_fuse") {
+      return this.toSupplierPartNumbers(
+        await this.getCategoryParts("/fuses/list", "fuses", {
+          package: packageName
+        })
+      );
+    }
+    if (sourceComponent.ftype === "simple_connector" && sourceComponent.standard === "usb_c") {
+      return this.toSupplierPartNumbers(
+        await this.getCategoryParts(
+          "/usb_c_connectors/list",
+          "usb_c_connectors",
+          { package: packageName }
+        )
+      );
+    }
+    const keywordByFtype = {
+      simple_chip: "integrated circuit",
+      simple_power_source: "power supply",
+      simple_inductor: "inductor",
+      simple_crystal: "crystal",
+      simple_resonator: "resonator"
+    };
+    const keyword = keywordByFtype[sourceComponent.ftype];
+    if (keyword) {
+      return this.toSupplierPartNumbers(
+        await this.getKeywordParts(
+          [keyword, packageName].filter(Boolean).join(" ")
+        )
+      );
+    }
+    return {};
+  }
+};
+
+// lib/digikey-parts-engine/index.ts
+var digikeyPartsEngine = new DigiKeyPartsEngine();
 export {
+  DigiKeyPartsEngine,
   JlcPcbPartsEngine,
   cache,
+  digikeyCache,
+  digikeyPartsEngine,
+  getDigiKeyPartsCached,
   getFetchWithEasyEdaProxy,
-  jlcPartsEngine
+  jlcPartsEngine,
+  withDigiKeyStockPreference
 };
 //# sourceMappingURL=index.js.map