@tscircuit/footprinter 0.0.4 → 0.0.6

package/README.md

@@ -43,3 +43,20 @@ should always confirm these footprints against the datasheet.
 
 - Pins are CCW starting at the top left
 - Y is upward-positive, X is rightward-positive
+
+## Slop
+
+Slop is a "sloppy" definition, it really doesn't have enough
+information to draw a footprint, i.e. it's missing critical dimensions.
+
+footprinter is extremely tolerant to Slop, because it's useful
+when you're iterating incrementally towards a fully constrained
+design, or when you're using footprinter strings as an output format
+for an AI.
+
+Generally when footprinter is interpreting a sloppy definition, it will use
+industry best practices or otherwise "reasonable" defaults. In theory, upgrading
+footprinter could cause the defaults to change, which is why sloppy definitions
+are generally not desirable.
+
+Currently it's not possible to see if a given definition is sloppy.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/footprinter",
   "type": "module",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "",
   "main": "dist/index.cjs",
   "scripts": {
@@ -12,7 +12,10 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@tscircuit/log-soup": "^1.0.1",
     "@tscircuit/soup": "^0.0.17",
+    "@tscircuit/soup-util": "^0.0.11",
+    "@types/node": "^20.12.13",
     "ava": "^6.1.3",
     "esbuild": "^0.21.4",
     "esbuild-register": "^3.5.0",
@@ -20,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

@@ -23,7 +23,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>

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/dip.test.ts

@@ -1,6 +1,6 @@
 import test from "ava"
 import { fp } from "../src/footprinter"
-import { AnySoupElement } from "@tscircuit/soup"
+import type { AnySoupElement } from "@tscircuit/soup"
 import { toPinPositionString } from "./fixtures"
 
 test("dip params", (t) => {

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

@@ -0,0 +1,18 @@
+import type { ExecutionContext } from "ava"
+import { fp } from "../../src"
+import { logSoup } from "@tscircuit/log-soup"
+import type { AnySoupElement } from "@tscircuit/soup"
+
+export const getTestFixture = async (t: ExecutionContext) => {
+  return {
+    fp,
+    logSoup: (soup: AnySoupElement[]) => {
+      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/fixtures/index.ts

@@ -1,5 +1,7 @@
 import type { AnySoupElement } from "@tscircuit/soup"
 
+export { getTestFixture } from "./get-test-fixture"
+
 export const toPinPositionString = (soup: AnySoupElement[]) => {
   return soup
     .map((e: AnySoupElement) => {

package/tests/slop/slop1.test.ts

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