@tscircuit/footprinter 0.0.22 → 0.0.24

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@tscircuit/footprinter",
   "type": "module",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "",
   "main": "dist/index.cjs",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "test": "FULL_RUN=1 ava",
     "build": "tsup ./src/index.ts --dts --sourcemap"

package/.github/workflows/release.yml

@@ -1,19 +0,0 @@
-name: Publish to npm
-on:
-  push:
-    branches:
-      - main
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 20
-          registry-url: https://registry.npmjs.org/
-      - run: npm install -g pver
-      - run: npm ci
-      - run: pver release
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/ava.config.js

@@ -1,5 +0,0 @@
-export default {
-  files: ["tests/**/*.test.ts"],
-  extensions: ["ts"],
-  require: ["esbuild-register"],
-}

package/biome.json

@@ -1,15 +0,0 @@
-{
-  "$schema": "https://biomejs.dev/schemas/1.7.3/schema.json",
-  "organizeImports": {
-    "enabled": true
-  },
-  "linter": {
-    "enabled": true,
-    "rules": {
-      "recommended": true,
-      "style": {
-        "noNonNullAssertion": "off"
-      }
-    }
-  }
-}

package/src/fn/bga.ts

@@ -1,138 +0,0 @@
-import type { AnySoupElement, PCBSMTPad } from "@tscircuit/soup"
-import { rectpad } from "../helpers/rectpad"
-import { ALPHABET } from "../helpers/zod/ALPHABET"
-import { z } from "zod"
-import { length, distance } from "@tscircuit/soup"
-import { dim2d } from "src/helpers/zod/dim-2d"
-import { function_call } from "src/helpers/zod/function-call"
-import type { NowDefined } from "src/helpers/zod/now-defined"
-
-export const bga_def = z
-  .object({
-    num_pins: z.number(),
-    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"),
-
-    tlorigin: z.boolean().optional(),
-    blorigin: z.boolean().optional(),
-    trorigin: z.boolean().optional(),
-    brorigin: z.boolean().optional(),
-
-    missing: function_call.default([]),
-  })
-  .transform((a) => {
-    let origin: "tl" | "bl" | "tr" | "br" = "tl"
-    if (a.blorigin) origin = "bl"
-    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
-        if (s === "center") return "center"
-        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
-      })
-    }
-
-    const new_def = { ...a, origin }
-
-    return new_def as NowDefined<typeof new_def, "w" | "h" | "grid">
-  })
-
-export type BgaDefInput = z.input<typeof bga_def>
-export type BgaDef = z.infer<typeof bga_def>
-
-export const bga = (params: BgaDefInput): AnySoupElement[] => {
-  const bga_params = bga_def.parse(params)
-  let { num_pins, grid, p, w, h, ball, pad, missing } = bga_params
-
-  ball ??= (0.75 / 1.27) * p
-
-  pad ??= ball * 0.8
-
-  const pads: PCBSMTPad[] = []
-
-  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
-    const square_size = Math.floor(Math.sqrt(num_pins_missing))
-
-    // Find the top left coordinate of the inner square, keep
-    // in mind the full grid size is grid.x x grid.y
-    const inner_square_x = Math.floor((grid.x - square_size) / 2)
-    const inner_square_y = Math.floor((grid.y - square_size) / 2)
-
-    // Add all the missing square pin numbers to missing_pin_nums
-    for (let y = inner_square_y; y < inner_square_y + square_size; y++) {
-      for (let x = inner_square_x; x < inner_square_x + square_size; x++) {
-        missing_pin_nums.push(y * grid.x + x + 1)
-      }
-    }
-  }
-
-  if (missing?.includes("topleft")) {
-    missing_pin_nums.push(1)
-  }
-
-  if (num_pins_missing !== missing_pin_nums.length) {
-    throw new Error(
-      `not able to create bga component, unable to determine missing pins (try specifying them with "missing+1+2+..."\n\n${JSON.stringify(
-        bga_params,
-        null,
-        "  "
-      )}`
-    )
-  }
-
-  const missing_pin_nums_set = new Set(missing_pin_nums)
-
-  let missing_pins_passed = 0
-  for (let y = 0; y < grid.y; y++) {
-    for (let x = 0; x < grid.x; x++) {
-      let pin_num = y * grid.x + x + 1
-      if (missing_pin_nums_set.has(pin_num)) {
-        missing_pins_passed++
-        continue
-      }
-      pin_num -= missing_pins_passed
-
-      const pad_x = (x - (grid.x - 1) / 2) * p
-      const pad_y = -(y - (grid.y - 1) / 2) * p
-
-      // TODO handle >26 rows
-      pads.push(
-        rectpad([pin_num, `${ALPHABET[y]}${x + 1}`], pad_x, pad_y, pad, pad)
-      )
-    }
-  }
-
-  return [...pads]
-}

package/src/fn/cap.ts

@@ -1,7 +0,0 @@
-import type { AnySoupElement } from "@tscircuit/soup"
-import { rectpad } from "../helpers/rectpad"
-import { PassiveDef, passive } from "../helpers/passive-fn"
-
-export const cap = (params: PassiveDef): AnySoupElement[] => {
-  return passive(params)
-}

package/src/fn/diode.ts

@@ -1,8 +0,0 @@
-import type { AnySoupElement } from "@tscircuit/soup"
-
-export const diode = (params: {
-  tht: boolean
-  p: number
-}): AnySoupElement[] => {
-  return []
-}

package/src/fn/dip.ts

@@ -1,118 +0,0 @@
-import type { AnySoupElement, PcbSilkscreenPath } from "@tscircuit/soup"
-import { u_curve } from "../helpers/u-curve"
-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(),
-    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,
-  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 DIP package.
- */
-export const dip = (raw_params: {
-  dip: true
-  num_pins: number
-  w: number
-  p?: number
-  id?: string | number
-  od?: string | number
-}): AnySoupElement[] => {
-  const params = dip_def.parse(raw_params)
-  const platedHoles: AnySoupElement[] = []
-  for (let i = 0; i < params.num_pins; i++) {
-    const { x, y } = getCcwDipCoords(
-      params.num_pins,
-      i + 1,
-      params.w,
-      params.p ?? 2.54
-    )
-    platedHoles.push(
-      platedhole(i + 1, x, y, params.id ?? "0.8mm", 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/fn/led.ts

@@ -1,6 +0,0 @@
-import type { AnySoupElement } from "@tscircuit/soup"
-import { PassiveDef, passive } from "../helpers/passive-fn"
-
-export const led = (params: PassiveDef): AnySoupElement[] => {
-  return passive(params)
-}

package/src/fn/qfn.ts

@@ -1,10 +0,0 @@
-import type { AnySoupElement } from "@tscircuit/soup"
-import { base_quad_def, quad, quad_def, quadTransform } from "./quad"
-import type { z } from "zod"
-
-export const qfn_def = base_quad_def.extend({}).transform(quadTransform)
-
-export const qfn = (params: z.input<typeof qfn_def>): AnySoupElement[] => {
-  params.legsoutside = false
-  return quad(params)
-}

package/src/fn/qfp.ts

@@ -1,19 +0,0 @@
-import type { AnySoupElement } from "@tscircuit/soup"
-import { quad, quad_def } from "./quad"
-import type { z } from "zod"
-
-export const qfp_def = quad_def
-
-export const qfp = (raw_params: z.input<typeof quad_def>): AnySoupElement[] => {
-  raw_params.legsoutside = true
-
-  const quad_defaults = quad_def.parse(raw_params)
-
-  if (!raw_params.pl) {
-    // SLOP - eyeballing typical pad width:pad length ratio
-    raw_params.pl = quad_defaults.pl * 4
-    raw_params.pw = quad_defaults.pw
-  }
-
-  return quad(raw_params)
-}

package/src/fn/quad.ts

@@ -1,285 +0,0 @@
-import type { AnySoupElement, PcbSilkscreenPath } from "@tscircuit/soup"
-import { z } from "zod"
-import { length } from "@tscircuit/soup"
-import type { NowDefined } from "../helpers/zod/now-defined"
-import { rectpad } from "../helpers/rectpad"
-import { pin_order_specifier } from "src/helpers/zod/pin-order-specifier"
-import { getQuadPinMap } from "src/helpers/get-quad-pin-map"
-import { dim2d } from "src/helpers/zod/dim-2d"
-
-export const base_quad_def = z.object({
-  cc: z.literal(true).optional(),
-  ccw: z.literal(true).optional(),
-  startingpin: z
-    .string()
-    .or(z.array(pin_order_specifier))
-    .transform((a) => (typeof a === "string" ? a.slice(1, -1).split(",") : a))
-    .pipe(z.array(pin_order_specifier))
-    .optional(),
-  num_pins: z.number(),
-  w: length.optional(),
-  h: length.optional(),
-  p: length.default(length.parse("0.5mm")),
-  pw: length.optional(),
-  pl: length.optional(),
-  thermalpad: z.union([z.literal(true), dim2d]).optional(),
-  legsoutside: z.boolean().optional(),
-})
-
-export const quadTransform = <T extends z.infer<typeof base_quad_def>>(
-  v: T
-) => {
-  if (v.w && !v.h) {
-    v.h = v.w
-  } else if (!v.w && v.h) {
-    v.w = v.h
-  }
-
-  const side_pin_count = v.num_pins / 4
-
-  if (!v.p && !v.pw && !v.pl && v.w) {
-    // HACK: This is wayyy underspecified
-    const approx_pin_size_of_side = side_pin_count + 4
-    v.p = v.w / approx_pin_size_of_side
-  }
-
-  if (!v.p && v.w && v.h && v.pw && v.pl) {
-    // HACK: This is wayyy underspecified
-    v.p = (v.w - v.pl * 2) / (side_pin_count - 1)
-  }
-
-  if (v.p && !v.pw && !v.pl) {
-    v.pw = v.p / 2
-    v.pl = v.p / 2
-  } else if (!v.pw) {
-    v.pw = v.pl! * (0.6 / 1.0)
-  } else if (!v.pl) {
-    v.pl = v.pw! * (1.0 / 0.6)
-  }
-
-  return v as NowDefined<T, "w" | "h" | "p" | "pw" | "pl">
-}
-
-export const quad_def = base_quad_def.transform(quadTransform)
-
-const SIDES_CCW = ["left", "bottom", "right", "top"] as const
-
-export const getQuadCoords = (params: {
-  pin_count: number
-  pn: number // pin number
-  w: number // width of the package
-  h: number // height (length) of the package
-  p: number // pitch between pins
-  pl: number // length of the pin
-  legsoutside?: boolean
-}) => {
-  const { pin_count, pn, w, h, p, pl, legsoutside } = params
-  const sidePinCount = pin_count / 4
-  const side = SIDES_CCW[Math.floor((pn - 1) / sidePinCount)]
-  const pos = (pn - 1) % sidePinCount
-
-  /** inner box width */
-  const ibw = p * (sidePinCount - 1)
-  /** inner box height */
-  const ibh = p * (sidePinCount - 1)
-
-  /** pad center distance from edge (negative is inside, positive is outside) */
-  const pcdfe = legsoutside ? pl / 2 : -pl / 2
-
-  switch (side) {
-    case "left":
-      return { x: -w / 2 - pcdfe, y: ibh / 2 - pos * p, o: "vert" }
-    case "bottom":
-      return { x: -ibw / 2 + pos * p, y: -h / 2 - pcdfe, o: "horz" }
-    case "right":
-      return { x: w / 2 + pcdfe, y: -ibh / 2 + pos * p, o: "vert" }
-    case "top":
-      return { x: ibw / 2 - pos * p, y: h / 2 + pcdfe, o: "horz" }
-    default:
-      throw new Error("Invalid pin number")
-  }
-}
-
-export const quad = (
-  raw_params: z.input<typeof quad_def>
-): AnySoupElement[] => {
-  const params = quad_def.parse(raw_params)
-  const pads: AnySoupElement[] = []
-  const pin_map = getQuadPinMap(params)
-  /** Side pin count */
-  const spc = params.num_pins / 4
-  for (let i = 0; i < params.num_pins; i++) {
-    const {
-      x,
-      y,
-      o: orientation,
-    } = getQuadCoords({
-      pin_count: params.num_pins,
-      pn: i + 1,
-      w: params.w,
-      h: params.h,
-      p: params.p ?? 0.5,
-      pl: params.pl,
-      legsoutside: params.legsoutside,
-    })
-
-    let pw = params.pw
-    let pl = params.pl
-    if (orientation === "vert") {
-      ;[pw, pl] = [pl, pw]
-    }
-
-    const pn = pin_map[i + 1]!
-    pads.push(rectpad(pn, x, y, pw, pl))
-  }
-
-  if (params.thermalpad) {
-    if (typeof params.thermalpad === "boolean") {
-      const ibw = params.p * (spc - 1) + params.pw
-      const ibh = params.p * (spc - 1) + params.pw
-      pads.push(rectpad(["thermalpad"], 0, 0, ibw, ibh))
-    } else {
-      pads.push(
-        rectpad(["thermalpad"], 0, 0, params.thermalpad.x, params.thermalpad.y)
-      )
-    }
-  }
-
-  // Silkscreen corners
-  const silkscreen_corners: PcbSilkscreenPath[] = []
-  for (const [corner, dx, dy] of [
-    ["top-left", -1, 1],
-    ["bottom-left", -1, -1],
-    ["bottom-right", 1, -1],
-    ["top-right", 1, 1],
-  ] as const) {
-    // const dx = Math.floor(corner_index / 2) * 2 - 1
-    // const dy = 1 - (corner_index % 2) * 2
-    const corner_x = (params.w / 2) * dx
-    const corner_y = (params.h / 2) * dy
-    let arrow: "none" | "in1" | "in2" = "none"
-
-    let arrow_x = corner_x
-    let arrow_y = corner_y
-
-    /** corner size */
-    const csz = params.pw * 2
-
-    if (pin_map[1] === 1 && corner === "top-left") {
-      arrow = "in1"
-    } else if (pin_map[spc * 4] === 1 && corner === "top-left") {
-      arrow = "in2"
-    } else if (pin_map[spc * 3 + 1] === 1 && corner === "top-right") {
-      arrow = "in2"
-    } else if (pin_map[spc * 3] === 1 && corner === "top-right") {
-      arrow = "in1"
-    } else if (pin_map[spc] === 1 && corner === "bottom-left") {
-      arrow = "in1"
-    } else if (pin_map[spc + 1] === 1 && corner === "bottom-left") {
-      arrow = "in2"
-    } else if (pin_map[spc * 2] === 1 && corner === "bottom-right") {
-      arrow = "in1"
-    } else if (pin_map[spc * 2 + 1] === 1 && corner === "bottom-right") {
-      arrow = "in2"
-    }
-
-    const rotate_arrow = arrow === "in1" ? 1 : -1
-    if (params.legsoutside) {
-      const arrow_dx = arrow === "in1" ? params.pl / 2 : params.pw / 2
-      const arrow_dy = arrow === "in1" ? params.pw / 2 : params.pl / 2
-      arrow_x += arrow_dx * dx * rotate_arrow
-      arrow_y -= arrow_dy * dy * rotate_arrow
-    }
-
-    // Normal Corner
-    if (arrow === "none" || params.legsoutside) {
-      silkscreen_corners.push({
-        layer: "top",
-        pcb_component_id: "",
-        pcb_silkscreen_path_id: `pcb_silkscreen_path_${corner}`,
-        route: [
-          {
-            x: corner_x - csz * dx,
-            y: corner_y,
-          },
-          {
-            x: corner_x,
-            y: corner_y,
-          },
-          {
-            x: corner_x,
-            y: corner_y - csz * dy,
-          },
-        ],
-        type: "pcb_silkscreen_path",
-      })
-    }
-
-    // Two lines nearly forming a corner, used when the arrow needs to overlap
-    // the corne (QFN components where legs are inside)
-    if ((arrow === "in1" || arrow === "in2") && !params.legsoutside) {
-      silkscreen_corners.push(
-        {
-          layer: "top",
-          pcb_component_id: "",
-          pcb_silkscreen_path_id: `pcb_silkscreen_path_${corner}_1`,
-          route: [
-            {
-              x: corner_x - csz * dx,
-              y: corner_y,
-            },
-            {
-              x: corner_x - (csz * dx) / 2,
-              y: corner_y,
-            },
-          ],
-          type: "pcb_silkscreen_path",
-        },
-        {
-          layer: "top",
-          pcb_component_id: "",
-          pcb_silkscreen_path_id: `pcb_silkscreen_path_${corner}_2`,
-          route: [
-            {
-              x: corner_x,
-              y: corner_y - (csz * dy) / 2,
-            },
-            {
-              x: corner_x,
-              y: corner_y - csz * dy,
-            },
-          ],
-          type: "pcb_silkscreen_path",
-        }
-      )
-    }
-    if (arrow === "in1" || arrow === "in2") {
-      silkscreen_corners.push({
-        layer: "top",
-        pcb_component_id: "",
-        pcb_silkscreen_path_id: `pcb_silkscreen_path_${corner}_3`,
-        route: [
-          {
-            x: arrow_x - 0.2 * -dx,
-            y: arrow_y + 0.2 * rotate_arrow,
-          },
-          {
-            x: arrow_x,
-            y: arrow_y,
-          },
-          {
-            x: arrow_x + 0.2 * rotate_arrow * -dx,
-            y: arrow_y + 0.2,
-          },
-          {
-            x: arrow_x - 0.2 * -dx,
-            y: arrow_y + 0.2 * rotate_arrow,
-          },
-        ],
-        type: "pcb_silkscreen_path",
-      })
-    }
-  }
-
-  return [...pads, ...silkscreen_corners]
-}

package/src/fn/res.ts

@@ -1,6 +0,0 @@
-import type { AnySoupElement } from "@tscircuit/soup"
-import { passive, PassiveDef } from "../helpers/passive-fn"
-
-export const res = (params: PassiveDef): AnySoupElement[] => {
-  return passive(params)
-}