@tscircuit/footprinter 0.0.22 → 0.0.24

package/src/fn/soic.ts

@@ -1,106 +0,0 @@
-import type { AnySoupElement, PcbSilkscreenPath } 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"
-import { u_curve } from "../helpers/u-curve"
-
-const soic_def = z
-  .object({
-    soic: z.literal(true),
-    num_pins: z.number(),
-    w: length,
-    p: length.default(length.parse("1.27mm")),
-    id: length.optional(),
-    od: length.optional(),
-  })
-  .transform((v) => {
-    // Default inner diameter and outer diameter
-    if (!v.id && !v.od) {
-      v.id = length.parse("0.6mm")
-      v.od = length.parse("1.0mm")
-    } else if (!v.id) {
-      v.id = v.od! * (0.6 / 1.0)
-    } else if (!v.od) {
-      v.od = v.id! * (1.0 / 0.6)
-    }
-    return v as NowDefined<typeof v, "w" | "p" | "id" | "od">
-  })
-
-export const getCcwSoicCoords = (
-  pinCount: number,
-  pn: number,
-  w: number,
-  p: number
-) => {
-  /** pin height */
-  const ph = pinCount / 2
-  const isLeft = pn <= ph
-
-  /** Number of gaps between pins on each side, e.g. 4 pins = 3 spaces */
-  const leftPinGaps = ph - 1
-
-  /** gap size (pitch) */
-  const gs = p
-
-  const h = gs * leftPinGaps
-
-  if (isLeft) {
-    // The y position starts at h/2, then goes down by gap size
-    // for each pin
-    return { x: -w / 2, y: h / 2 - (pn - 1) * gs }
-  } else {
-    // The y position starts at -h/2, then goes up by gap size
-    return { x: w / 2, y: -h / 2 + (pn - ph - 1) * gs }
-  }
-}
-
-/**
- * Returns the plated holes for a SOIC package.
- */
-export const soic = (raw_params: {
-  soic: true
-  num_pins: number
-  w: number
-  p?: number
-  id?: string | number
-  od?: string | number
-}): AnySoupElement[] => {
-  const params = soic_def.parse(raw_params)
-  const platedHoles: AnySoupElement[] = []
-  for (let i = 0; i < params.num_pins; i++) {
-    const { x, y } = getCcwSoicCoords(
-      params.num_pins,
-      i + 1,
-      params.w,
-      params.p ?? 1.27
-    )
-    platedHoles.push(
-      platedhole(i + 1, x, y, params.id ?? "0.6mm", params.od ?? "1mm")
-    )
-  }
-
-  /** silkscreen width */
-  const sw = params.w - params.od - 0.4
-  const sh = (params.num_pins / 2 - 1) * params.p + params.od + 0.4
-  const silkscreenBorder: PcbSilkscreenPath = {
-    layer: "top",
-    pcb_component_id: "",
-    pcb_silkscreen_path_id: "silkscreen_path_1",
-    route: [
-      { x: -sw / 2, y: -sh / 2 },
-      { x: -sw / 2, y: sh / 2 },
-      // Little U shape at the top
-      ...u_curve.map(({ x, y }) => ({
-        x: (x * sw) / 6,
-        y: (y * sw) / 6 + sh / 2,
-      })),
-      { x: sw / 2, y: sh / 2 },
-      { x: sw / 2, y: -sh / 2 },
-      { x: -sw / 2, y: -sh / 2 },
-    ],
-    type: "pcb_silkscreen_path",
-  }
-
-  return [...platedHoles, silkscreenBorder]
-}

package/src/footprinter.ts

@@ -1,128 +0,0 @@
-import { dip } from "./fn/dip"
-import { diode } from "./fn/diode"
-import { cap } from "./fn/cap"
-import { led } from "./fn/led"
-import { res } from "./fn/res"
-import { bga } from "./fn/bga"
-import { soic } from "./fn/soic"
-import { quad } from "./fn/quad"
-import { qfn } from "./fn/qfn"
-import { qfp } from "./fn/qfp"
-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"
-    ? Footprinter[P]
-    : (v?: number | string) => FootprinterParamsBuilder<K>
-}
-
-type CommonPassiveOptionKey =
-  | "metric"
-  | "imperial"
-  | "tht"
-  | "p"
-  | "pw"
-  | "ph"
-  | "w"
-  | "h"
-
-export type Footprinter = {
-  dip: (
-    num_pins: number
-  ) => FootprinterParamsBuilder<"w" | "p" | "id" | "od" | "wide" | "narrow">
-  cap: () => FootprinterParamsBuilder<CommonPassiveOptionKey>
-  res: () => FootprinterParamsBuilder<CommonPassiveOptionKey>
-  diode: () => FootprinterParamsBuilder<CommonPassiveOptionKey>
-  led: () => FootprinterParamsBuilder<CommonPassiveOptionKey>
-  lr: (num_pins: number) => FootprinterParamsBuilder<"w" | "l" | "pl" | "pr">
-  qfp: (
-    num_pins: number
-  ) => FootprinterParamsBuilder<"w" | "p" | "id" | "od" | "wide" | "narrow">
-  quad: (
-    num_pins: number
-  ) => FootprinterParamsBuilder<
-    "w" | "l" | "square" | "pl" | "pr" | "pb" | "pt" | "p" | "pw" | "ph"
-  >
-  bga: (
-    num_pins: number
-  ) => FootprinterParamsBuilder<
-    "grid" | "p" | "w" | "h" | "ball" | "pad" | "missing"
-  >
-  qfn: (num_pins: number) => FootprinterParamsBuilder<"w" | "h" | "p">
-  soic: (num_pins: number) => FootprinterParamsBuilder<"w" | "p" | "id" | "od">
-  params: () => any
-  soup: () => AnySoupElement[]
-}
-
-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 ?? []
-      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)
-  }
-
-  return fp
-}
-
-export const footprinter = (): Footprinter & { string: typeof string } => {
-  const proxy = new Proxy(
-    {},
-    {
-      get: (target: any, prop) => {
-        if (prop === "soup") {
-          if ("dip" in target) return () => dip(target)
-          if ("diode" in target) return () => diode(target)
-          if ("cap" in target) return () => cap(target)
-          if ("led" in target) return () => led(target)
-          if ("res" in target) return () => res(target)
-          if ("bga" in target) return () => bga(target)
-          if ("soic" in target) return () => soic(target)
-          if ("quad" in target) return () => quad(target)
-          if ("qfn" in target) return () => qfn(target)
-          if ("qfp" in target) return () => qfp(target)
-
-          return () => {
-            // TODO improve error
-            throw new Error(
-              `No function found for footprinter, make sure to specify .dip, .lr, .p, etc. Got \"${prop}\"`
-            )
-          }
-        }
-        if (prop === "params") {
-          // TODO
-          return () => target
-        }
-        return (v: any) => {
-          if (Object.keys(target).length === 0) {
-            target[prop] = true
-            if (prop === "res" || prop === "cap") {
-              if (v) {
-                target.imperial = v // res0402, cap0603 etc.
-              }
-            } else {
-              target.num_pins = parseFloat(v)
-            }
-          } else {
-            target[prop] = v ?? true
-          }
-          return proxy
-        }
-      },
-    }
-  )
-  return proxy as any
-}
-footprinter.string = string
-
-export const fp = footprinter

package/src/helpers/get-quad-pin-map.ts

@@ -1,106 +0,0 @@
-import type { PinOrderSpecifier } from "./zod/pin-order-specifier"
-
-/**
- * A counter-clockwise pin map is [1,2,3,4,5,6,7,8] for an 8-pin package
- *
- *     8 7
- *   1     6
- *   2     5
- *     3 4
- *
- * Given some parameters, we're returning how to map the pins in a quad package
- * with a different order. For example, if we pass in cw=true, we'll get the
- * following mapping
- *
- * 1 -> 1
- * 2 -> 8
- * 3 -> 7
- * 4 -> 6
- * 5 -> 5
- * 6 -> 4
- * 7 -> 3
- * 8 -> 2
- *
- * Which allows us to create the CW version of the package using...
- * new_pin = pin_map[normal_ccw_pin]
- *
- *    2 3
- *  1     4
- *  8     5
- *    7 6
- */
-export const getQuadPinMap = ({
-  num_pins,
-  cw,
-  ccw,
-  startingpin,
-}: {
-  num_pins: number
-  cw?: boolean
-  ccw?: boolean
-  startingpin?: PinOrderSpecifier[]
-}): number[] => {
-  const pin_map: number[] = []
-  const pins_per_side = num_pins / 4
-  let current_position_ccw_normal = 1
-
-  /** Starting Flag Pins */
-  const sfp: Record<PinOrderSpecifier, boolean> = {} as any
-  for (const specifier of startingpin ?? []) {
-    sfp[specifier] = true
-  }
-  if (!sfp.leftside && !sfp.topside && !sfp.rightside && !sfp.bottomside) {
-    sfp.leftside = true
-  }
-  if (!sfp.bottompin && !sfp.leftpin && !sfp.rightpin && !sfp.toppin) {
-    if (sfp.leftside) {
-      sfp.toppin = true
-    } else if (sfp.topside) {
-      sfp.rightpin = true
-    } else if (sfp.rightside) {
-      sfp.bottompin = true
-    } else if (sfp.bottomside) {
-      sfp.leftpin = true
-    }
-  }
-
-  if (sfp.leftside && sfp.toppin) {
-    current_position_ccw_normal = 1
-  } else if (sfp.leftside && sfp.bottompin) {
-    current_position_ccw_normal = pins_per_side
-  } else if (sfp.bottomside && sfp.leftpin) {
-    current_position_ccw_normal = pins_per_side + 1
-  } else if (sfp.bottomside && sfp.rightpin) {
-    current_position_ccw_normal = pins_per_side * 2
-  } else if (sfp.rightside && sfp.bottompin) {
-    current_position_ccw_normal = pins_per_side * 2 + 1
-  } else if (sfp.rightside && sfp.toppin) {
-    current_position_ccw_normal = pins_per_side * 3
-  } else if (sfp.topside && sfp.rightpin) {
-    current_position_ccw_normal = pins_per_side * 3 + 1
-  } else if (sfp.topside && sfp.leftpin) {
-    current_position_ccw_normal = pins_per_side * 4
-  }
-
-  pin_map.push(-1) // the first index is meaningless
-
-  // Each iteration we move the current position to the next pin, if we're
-  // going CCW this means incrementing, if we're going CW this means
-  // decrementing
-  for (let i = 0; i < num_pins; i++) {
-    pin_map[current_position_ccw_normal] = i + 1
-    if (ccw || !cw) {
-      current_position_ccw_normal++
-      if (current_position_ccw_normal > num_pins) {
-        current_position_ccw_normal = 1
-      }
-    } else {
-      current_position_ccw_normal--
-      if (current_position_ccw_normal < 1) {
-        current_position_ccw_normal = num_pins
-      }
-    }
-  }
-
-  return pin_map
-}

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

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

package/src/helpers/passive-fn.ts

@@ -1,175 +0,0 @@
-import type { AnySoupElement } from "@tscircuit/soup"
-import { rectpad } from "../helpers/rectpad"
-import mm from "@tscircuit/mm"
-import { platedhole } from "./platedhole"
-
-type StandardSize = {
-  imperial: string
-  metric: string
-  Z_mm_min: number
-  G_mm_min: number
-  X_mm_min: number
-  C_mm_ref: number
-}
-
-// https://www.worthingtonassembly.com/perfect-0201-footprint
-// https://static1.squarespace.com/static/54982a02e4b02e9f5e5d9ca7/t/660c692f69a0d83a4afecdf0/1712089391915/Discrete+Component+Footprints.pdf
-// https://page.venkel.com/hubfs/Resources/Technical/Resistors%20Landing%20Pattern.pdf
-const sizes = [
-  {
-    imperial: "01005",
-    metric: "0402",
-    Z_mm_min: 0.58,
-    G_mm_min: 0.18,
-    X_mm_min: 0.21,
-    C_mm_ref: 0.038,
-  },
-  {
-    imperial: "0201",
-    metric: "0603",
-    Z_mm_min: 0.9,
-    G_mm_min: 0.3,
-    X_mm_min: 0.3,
-    C_mm_ref: 0.6,
-  },
-  {
-    imperial: "0402",
-    metric: "1005",
-    Z_mm_min: 1.6,
-    G_mm_min: 0.4,
-    X_mm_min: 0.7,
-    C_mm_ref: 1,
-  },
-  {
-    imperial: "0603",
-    metric: "1608",
-    Z_mm_min: 2.6,
-    G_mm_min: 0.6,
-    X_mm_min: 1.0,
-    C_mm_ref: 1.7,
-  },
-  {
-    imperial: "0805",
-    metric: "2012",
-    Z_mm_min: 3.0,
-    G_mm_min: 0.6,
-    X_mm_min: 1.2,
-    C_mm_ref: 1.9,
-  },
-  {
-    imperial: "1206",
-    metric: "3216",
-    Z_mm_min: 4.2,
-    G_mm_min: 1.2,
-    X_mm_min: 1.4,
-    C_mm_ref: 2.8,
-  },
-  {
-    imperial: "1210",
-    metric: "3225",
-    Z_mm_min: 4.2,
-    G_mm_min: 1.2,
-    X_mm_min: 2.4,
-    C_mm_ref: 2.8,
-  },
-  {
-    imperial: "2010",
-    metric: "5025",
-    Z_mm_min: 6.0,
-    G_mm_min: 2.6,
-    X_mm_min: 2.4,
-    C_mm_ref: 4.4,
-  },
-  {
-    imperial: "2512",
-    metric: "6332",
-    Z_mm_min: 7.2,
-    G_mm_min: 3.8,
-    X_mm_min: 3.0,
-    C_mm_ref: 5.6,
-  },
-]
-const metricMap: Record<string, StandardSize> = sizes.reduce((acc: any, s) => {
-  acc[s.metric] = s
-  return acc
-}, {})
-const imperialMap: Record<string, StandardSize> = sizes.reduce(
-  (acc: any, s) => {
-    acc[s.imperial] = s
-    return acc
-  },
-  {}
-)
-
-export type PassiveDef = {
-  tht: boolean
-  p: number
-  pw?: number
-  ph?: number
-  metric?: string
-  imperial?: string
-  w?: number
-  h?: number
-}
-
-const deriveXFromH = (h: number) => 0.079 * h ** 2 + 0.94 * h - 0.009
-const deriveZFromW = (w: number) => 1.09 * w + 0.6
-const deriveGFromW = (w: number) => 0.59 * w - 0.31
-const deriveCFromW = (w: number) => -0.01 * w ** 2 + 0.94 * w + 0.03
-
-export const passive = (params: PassiveDef): AnySoupElement[] => {
-  let { tht, p, pw, ph, metric, imperial, w, h } = params
-
-  if (typeof w === "string") w = mm(w)
-  if (typeof h === "string") h = mm(h)
-  if (typeof p === "string") p = mm(p)
-  if (typeof pw === "string") pw = mm(pw)
-  if (typeof ph === "string") ph = mm(ph)
-
-  if (h! > w!) {
-    throw new Error(
-      "height cannot be greater than width (rotated footprint not yet implemented)"
-    )
-  }
-
-  /** standard size */
-  let sz: StandardSize | undefined
-  if (metric) {
-    sz = metricMap[metric]
-  }
-
-  if (imperial) {
-    sz = imperialMap[imperial]
-  }
-
-  if (!sz && w && h && !pw && !ph) {
-    sz = {
-      imperial: "custom",
-      metric: "custom",
-      Z_mm_min: deriveZFromW(w),
-      G_mm_min: deriveGFromW(w),
-      X_mm_min: deriveXFromH(h),
-      C_mm_ref: deriveCFromW(w),
-    }
-  }
-
-  if (sz) {
-    w = sz.Z_mm_min
-    h = sz.X_mm_min
-    p = sz.C_mm_ref
-    pw = (sz.Z_mm_min - sz.G_mm_min) / 2
-    ph = (sz.Z_mm_min - sz.G_mm_min) / 2
-  }
-
-  if (pw === undefined) throw new Error(`could not infer pad width`)
-  if (ph === undefined) throw new Error(`could not infer pad width`)
-
-  if (tht) {
-    return [
-      platedhole(1, -p / 2, 0, pw, (pw * 1) / 0.8),
-      platedhole(2, -p / 2, 0, pw, (pw * 1) / 0.8),
-    ]
-  } else {
-    return [rectpad(1, -p / 2, 0, pw, ph), rectpad(2, p / 2, 0, pw, ph)]
-  }
-}

package/src/helpers/platedhole.ts

@@ -1,21 +0,0 @@
-import type { PCBPlatedHole, PCBSMTPad } from "@tscircuit/soup"
-import { mm } from "@tscircuit/mm"
-
-export const platedhole = (
-  pn: number,
-  x: number,
-  y: number,
-  id: number | string,
-  od: number | string
-): PCBPlatedHole => {
-  return {
-    type: "pcb_plated_hole",
-    x,
-    y,
-    hole_diameter: mm(id),
-    outer_diameter: mm(od),
-    pcb_port_id: "",
-    layers: ["top", "bottom"],
-    port_hints: [pn.toString()],
-  }
-}

package/src/helpers/rectpad.ts

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

package/src/helpers/u-curve.ts

@@ -1,6 +0,0 @@
-export const u_curve = Array.from({ length: 9 }, (_, i) =>
-  Math.cos((i / 8) * Math.PI - Math.PI)
-).map((x) => ({
-  x,
-  y: -Math.sqrt(1 - x ** 2),
-}))

package/src/helpers/zod/ALPHABET.ts

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

package/src/helpers/zod/dim-2d.ts

@@ -1,17 +0,0 @@
-import { z } from "zod"
-
-export const dim2d = z
-  .string()
-  .transform((a) => {
-    const [x, y] = a.split(/[x ]/)
-    return {
-      x: parseFloat(x),
-      y: parseFloat(y),
-    }
-  })
-  .pipe(
-    z.object({
-      x: z.number(),
-      y: z.number(),
-    })
-  )

package/src/helpers/zod/function-call.ts

@@ -1,16 +0,0 @@
-import { z } from "zod"
-
-export const function_call = z
-  .string()
-  .or(z.array(z.any()))
-  .transform((a) => {
-    if (Array.isArray(a)) return a
-    if (a.startsWith("(") && a.endsWith(")")) {
-      a = a.slice(1, -1)
-    }
-    return a.split(",").map((v) => {
-      const numVal = Number(v)
-      return isNaN(numVal) ? v : numVal
-    })
-  })
-  .pipe(z.array(z.string().or(z.number())))

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

@@ -1,2 +0,0 @@
-/* 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/src/helpers/zod/pin-order-specifier.ts

@@ -1,13 +0,0 @@
-import { z } from "zod"
-export const pin_order_specifier = z.enum([
-  "leftside",
-  "topside",
-  "rightside",
-  "bottomside",
-  "toppin",
-  "bottompin",
-  "leftpin",
-  "rightpin",
-])
-
-export type PinOrderSpecifier = z.infer<typeof pin_order_specifier>

package/src/index.ts

@@ -1 +0,0 @@
-export * from "./footprinter"

package/tests/bga.test.ts

@@ -1,49 +0,0 @@
-import test from "ava"
-import { fp } from "../src/footprinter"
-import { AnySoupElement } from "@tscircuit/soup"
-import { toPinPositionString } from "./fixtures"
-
-test("bga footprint", (t) => {
-  const soup = fp()
-    .bga(8)
-    .w("4mm")
-    .h("4mm")
-    .grid("3x3")
-    .missing("center")
-    .p(1)
-    .soup()
-  // 16pins, 4mm x 4mm, 8x8 grid, 1.27mm pitch
-  const ps = toPinPositionString(soup)
-
-  t.is(
-    ps,
-    `
-1 : -1.00  1.00
-2 :  0.00  1.00
-3 :  1.00  1.00
-4 : -1.00  0.00
-5 :  1.00  0.00
-6 : -1.00 -1.00
-7 :  0.00 -1.00
-8 :  1.00 -1.00
-  `.trim()
-  )
-})
-
-test("bga7_w8_h8_grid3x3_p1_missing(center,B1)", (t) => {
-  const soup = fp.string("bga7_w8_h8_grid3x3_p1_missing(center,B1)").soup()
-  const ps = toPinPositionString(soup)
-
-  t.is(
-    ps,
-    `
-1 : -1.00  1.00
-2 :  0.00  1.00
-3 :  1.00  1.00
-4 :  1.00  0.00
-5 : -1.00 -1.00
-6 :  0.00 -1.00
-7 :  1.00 -1.00
-  `.trim()
-  )
-})