@tscircuit/footprinter 0.0.5 → 0.0.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/footprinter",
   "type": "module",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "",
   "main": "dist/index.cjs",
   "scripts": {
@@ -23,6 +23,6 @@
     "typescript": "^5.4.5"
   },
   "dependencies": {
-    "@tscircuit/mm": "^0.0.6"
+    "@tscircuit/mm": "^0.0.7"
   }
 }

package/src/fn/bga.ts

@@ -1,7 +1,7 @@
 import type { AnySoupElement, PCBSMTPad } from "@tscircuit/soup"
 import { rectpad } from "../helpers/rectpad"
-import { PassiveDef, passive } from "../helpers/passive-fn"
-import { BgaDef, BgaDefInput, bga_def } from "../helpers/zod/bga-def"
+import { type BgaDefInput, bga_def } from "../helpers/zod/bga-def"
+import { ALPHABET } from "../helpers/zod/ALPHABET"
 
 export const bga = (params: BgaDefInput): AnySoupElement[] => {
   const bga_params = bga_def.parse(params)
@@ -16,6 +16,16 @@ export const bga = (params: BgaDefInput): AnySoupElement[] => {
   const missing_pin_nums = (missing ?? []).filter((a) => typeof a === "number")
   const num_pins_missing = grid.x * grid.y - num_pins
 
+  if (missing.length === 0 && num_pins_missing > 0) {
+    // No missing pins specified, let's see if a squared center works
+    // if num_pins_missing is a square
+    if (Math.sqrt(num_pins_missing) % 1 === 0) {
+      missing.push("center")
+    } else if (num_pins_missing === 1) {
+      missing.push("topleft")
+    }
+  }
+
   if (missing?.includes("center")) {
     // Find the largest square that's square is less than
     // the number of missing pins
@@ -63,7 +73,10 @@ export const bga = (params: BgaDefInput): AnySoupElement[] => {
       const pad_x = (x - (grid.x - 1) / 2) * p
       const pad_y = -(y - (grid.y - 1) / 2) * p
 
-      pads.push(rectpad(pin_num, pad_x, pad_y, pad, pad))
+      // TODO handle >26 rows
+      pads.push(
+        rectpad([pin_num, `${ALPHABET[y]}${x + 1}`], pad_x, pad_y, pad, pad)
+      )
     }
   }
 

package/src/fn/dip.ts

@@ -2,15 +2,42 @@ import type { AnySoupElement } from "@tscircuit/soup"
 import { platedhole } from "../helpers/platedhole"
 import { z } from "zod"
 import { length } from "@tscircuit/soup"
+import type { NowDefined } from "../helpers/zod/now-defined"
 
-const dip_def = z.object({
-  dip: z.literal(true),
-  num_pins: z.number(),
-  w: length,
-  p: length.optional(),
-  id: length.optional(),
-  od: length.optional(),
-})
+const dip_def = z
+  .object({
+    dip: z.literal(true),
+    num_pins: z.number(),
+    wide: z.boolean().optional(),
+    narrow: z.boolean().optional(),
+    w: length.optional(),
+    p: length.default(length.parse("2.54mm")),
+    id: length.optional(),
+    od: length.optional(),
+  })
+  .transform((v) => {
+    // Default inner diameter and outer diameter
+    if (!v.id && !v.od) {
+      v.id = length.parse("1.0mm")
+      v.od = length.parse("1.2mm")
+    } else if (!v.id) {
+      v.id = v.od! * (1.0 / 1.2)
+    } else if (!v.od) {
+      v.od = v.id! * (1.2 / 1.0)
+    }
+
+    // Default width (TODO high pin counts should probably be wide?)
+    if (!v.w) {
+      if (v.wide) {
+        v.w = length.parse("600mil")
+      } else if (v.narrow) {
+        v.w = length.parse("300mil")
+      } else {
+        v.w = length.parse("300mil")
+      }
+    }
+    return v as NowDefined<typeof v, "w" | "p" | "id" | "od">
+  })
 
 export const getCcwDipCoords = (
   pinCount: number,
@@ -43,7 +70,7 @@ export const getCcwDipCoords = (
 /**
  * Returns the plated holes for a DIP package.
  */
-export const dip = (params: {
+export const dip = (raw_params: {
   dip: true
   num_pins: number
   w: number
@@ -51,7 +78,7 @@ export const dip = (params: {
   id?: string | number
   od?: string | number
 }): AnySoupElement[] => {
-  params = dip_def.parse(params)
+  const params = dip_def.parse(raw_params)
   const platedHoles: AnySoupElement[] = []
   for (let i = 0; i < params.num_pins; i++) {
     const { x, y } = getCcwDipCoords(

package/src/footprinter.ts

@@ -5,6 +5,7 @@ import { led } from "./fn/led"
 import { res } from "./fn/res"
 import { bga } from "./fn/bga"
 import type { AnySoupElement } from "@tscircuit/soup"
+import { isNotNull } from "./helpers/is-not-null"
 
 export type FootprinterParamsBuilder<K extends string> = {
   [P in K | "params" | "soup"]: P extends "params" | "soup"
@@ -23,7 +24,9 @@ type CommonPassiveOptionKey =
   | "h"
 
 export type Footprinter = {
-  dip: (num_pins: number) => FootprinterParamsBuilder<"w" | "p" | "id" | "od">
+  dip: (
+    num_pins: number
+  ) => FootprinterParamsBuilder<"w" | "p" | "id" | "od" | "wide" | "narrow">
   cap: () => FootprinterParamsBuilder<CommonPassiveOptionKey>
   res: () => FootprinterParamsBuilder<CommonPassiveOptionKey>
   diode: () => FootprinterParamsBuilder<CommonPassiveOptionKey>
@@ -46,11 +49,15 @@ export type Footprinter = {
 export const string = (def: string): Footprinter => {
   let fp = footprinter()
 
-  const def_parts = def.split("_").map((s) => {
-    const m = s.match(/([a-z]+)([\(\d\.\+].*)?/)
-    const [_, fn, v] = m ?? []
-    return { fn: m?.[1]!, v: m?.[2]! }
-  })
+  const def_parts = def
+    .split("_")
+    .map((s) => {
+      const m = s.match(/([a-z]+)([\(\d\.\+\?].*)?/)
+      const [_, fn, v] = m ?? []
+      if (v?.includes("?")) return null
+      return { fn: m?.[1]!, v: m?.[2]! }
+    })
+    .filter(isNotNull)
 
   for (const { fn, v } of def_parts) {
     fp = fp[fn](v)

package/src/helpers/is-not-null.ts

@@ -0,0 +1,3 @@
+export function isNotNull<T>(value: T | null): value is T {
+  return value !== null
+}

package/src/helpers/rectpad.ts

@@ -1,6 +1,6 @@
 import type { PCBSMTPad } from "@tscircuit/soup"
 export const rectpad = (
-  pn: number,
+  pn: number | Array<string | number>,
   x: number,
   y: number,
   w: number,
@@ -15,6 +15,8 @@ export const rectpad = (
     layer: "top",
     shape: "rect",
     pcb_smtpad_id: "",
-    port_hints: [pn.toString()],
+    port_hints: Array.isArray(pn)
+      ? pn.map((item) => item.toString())
+      : [pn.toString()],
   }
 }

package/src/helpers/zod/ALPHABET.ts

@@ -0,0 +1 @@
+export const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

package/src/helpers/zod/bga-def.ts

@@ -2,16 +2,16 @@ import { z } from "zod"
 import { length, distance } from "@tscircuit/soup"
 import { dim2d } from "./dim-2d"
 import { function_call } from "./function-call"
-
-const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+import type { NowDefined } from "./now-defined"
+import { ALPHABET } from "./ALPHABET"
 
 export const bga_def = z
   .object({
     num_pins: z.number(),
-    grid: dim2d,
-    p: distance,
-    w: length,
-    h: length,
+    grid: dim2d.optional(),
+    p: distance.default("0.8mm"),
+    w: length.optional(),
+    h: length.optional(),
     ball: length.optional().describe("ball diameter"),
     pad: length.optional().describe("pad width/height"),
 
@@ -20,7 +20,7 @@ export const bga_def = z
     trorigin: z.boolean().optional(),
     brorigin: z.boolean().optional(),
 
-    missing: function_call,
+    missing: function_call.default([]),
   })
   .transform((a) => {
     let origin: "tl" | "bl" | "tr" | "br" = "tl"
@@ -28,6 +28,12 @@ export const bga_def = z
     if (a.trorigin) origin = "tr"
     if (a.brorigin) origin = "br"
 
+    if (!a.grid) {
+      // find the largest square for the number of pins
+      const largest_square = Math.ceil(Math.sqrt(a.num_pins))
+      a.grid = { x: largest_square, y: largest_square }
+    }
+
     if (a.missing) {
       a.missing = a.missing.map((s) => {
         if (typeof s === "number") return s
@@ -35,13 +41,15 @@ export const bga_def = z
         if (s === "topleft") return "topleft"
         const m = s.match(/([A-Z]+)(\d+)/)
         if (!m) return s
-        let Y = ALPHABET.indexOf(m[1])
-        let X = parseInt(m[2]) - 1
-        return Y * a.grid.x + X + 1
+        let Y = ALPHABET.indexOf(m[1]!)
+        let X = parseInt(m[2]!) - 1
+        return Y * a.grid!.x + X + 1
       })
     }
 
-    return { ...a, origin }
+    const new_def = { ...a, origin }
+
+    return new_def as NowDefined<typeof new_def, "w" | "h" | "grid">
   })
 
 export type BgaDefInput = z.input<typeof bga_def>

package/src/helpers/zod/now-defined.ts

@@ -0,0 +1,2 @@
+/* Define a utility type to make certain keys required */
+export type NowDefined<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>

package/tests/fixtures/get-test-fixture.ts

@@ -10,5 +10,9 @@ export const getTestFixture = async (t: ExecutionContext) => {
       if (process.env.CI) return
       return logSoup(`footprinter: ${t.title}`, soup)
     },
+    logSoupWithPrefix: (prefix: string, soup: AnySoupElement[]) => {
+      if (process.env.CI) return
+      return logSoup(`footprinter: ${t.title} ${prefix}`, soup)
+    },
   }
 }

package/tests/slop/slop1.test.ts

@@ -2,17 +2,45 @@ import test from "ava"
 import { getTestFixture } from "../fixtures"
 import type { AnySoupElement } from "@tscircuit/soup"
 
-export const SLOP_LIST = ["dip3"]
+/**
+ * Slop is an underdefined definition.
+ */
+export const SLOP_LIST = [
+  "dip3",
+  "bga64",
+  "bga48",
+  "bga48_grid8x8",
+  "bga48_p2_pad0.2",
+]
 
 test("slop1", async (t) => {
-  const { fp, logSoup } = await getTestFixture(t)
+  const { fp, logSoupWithPrefix } = await getTestFixture(t)
 
   const soups: AnySoupElement[][] = []
+  const failures: Array<{
+    slop_string: string
+    error: any
+  }> = []
 
   for (const slop of SLOP_LIST) {
-    const soup = fp.string(slop).soup()
-    soups.push(soup)
+    try {
+      const soup = fp.string(slop).soup()
+      soups.push(soup)
+      if (slop === SLOP_LIST[SLOP_LIST.length - 1]) {
+        await logSoupWithPrefix(slop, soup)
+      }
+    } catch (e: any) {
+      failures.push({
+        slop_string: slop,
+        error: e,
+      })
+      throw e
+    }
   }
 
-  await logSoup(soups[0]!)
+  if (failures.length > 0) {
+    t.fail(`Failures:\n${failures.map((f) => f.slop_string).join("\n")}`)
+  } else {
+    t.pass()
+  }
 })