@tscircuit/cli 0.0.203 → 0.0.205

package/bunfig.toml

@@ -0,0 +1,2 @@
+[test]
+preload = ["./cli/tests/fixtures/preload.ts"]

package/cli/lib/cmd-fns/dev/fulfill-export-requests.ts

@@ -60,17 +60,6 @@ export const fulfillExportRequests = async (
 
     if (export_request.export_parameters.should_export_gerber_zip) {
       console.log(kleur.gray(`\n  exporting gerbers...`))
-      if (typeof Bun !== "undefined") {
-        const err_str =
-          "Bun currently isn't capable of exporting due to an archiver bug, exports will not work."
-        console.log(kleur.red(err_str))
-        await dev_server_axios.post("/api/export_requests/update", {
-          export_request_id: export_request.export_request_id,
-          has_error: true,
-          error: err_str,
-        })
-        return
-      }
       const zip_buffer = await exportGerbersToZipBuffer(
         {
           example_file_path: export_request.example_file_path!,

package/cli/lib/cmd-fns/export-gerbers.ts

@@ -5,15 +5,21 @@ import { exportGerbersToFile } from "cli/lib/export-fns/export-gerbers"
 export const exportGerbersCmd = async (ctx: AppContext, args: any) => {
   const params = z
     .object({
-      file: z.string(),
+      file: z.string().optional(),
+      input: z.string().optional(),
       export: z.string().optional(),
       outputfile: z.string().optional().default("gerbers.zip"),
     })
+    .refine((data) => data.file || data.input, {
+      message: "Either 'file' or 'input' must be provided",
+    })
     .parse(args)
 
+  const inputFile = params.input || params.file
+
   await exportGerbersToFile(
     {
-      example_file_path: params.file,
+      example_file_path: inputFile!,
       export_name: params.export,
       output_zip_path: params.outputfile,
     },

package/cli/lib/export-fns/export-gerbers.ts

@@ -63,14 +63,9 @@ export const exportGerbersToFile = async (
   }
 
   console.log(kleur.gray("[zipping tmp dir]..."))
+  console.log(kleur.gray("  writing to " + params.output_zip_path))
   const output = fs.createWriteStream(params.output_zip_path)
 
-  if (typeof Bun !== "undefined") {
-    throw new Error(
-      `Exporting gerbers doesn't currently work with Bun (bug w/ archiver module)`,
-    )
-  }
-
   const archive = archiver("zip", {
     zlib: { level: 9 },
   })

package/cli/lib/get-program.ts

@@ -281,7 +281,11 @@ export const getProgram = (ctx: AppContext) => {
   exportCmd
     .command("gerbers")
     .description("Export Gerber files from an example file")
-    .requiredOption("--file <file>", "Input example files")
+    .option(
+      "--file <file>",
+      "Input example file (deprecated, use --input instead)",
+    )
+    .option("--input <input>", "Input example file")
     .option(
       "--export <export_name>",
       "Name of export to soupify, if not specified, soupify the default/only export",

package/cli/lib/util/create-context-and-run-program.ts

@@ -121,7 +121,12 @@ export const createContextAndRunProgram = async (process_args: any) => {
     params: args,
   }
 
+  if (args["color"] === false) {
+    kleur.enabled = false
+  }
+
   delete args["cwd"]
+  delete args["color"]
 
   const { _: positional, ...flagsAndParams } = args
   const args_without_globals = positional.concat(dargs(flagsAndParams))

package/cli/tests/export-gerber-keyboard.test.ts

@@ -0,0 +1,16 @@
+import { test, expect, describe } from "bun:test"
+import { $ } from "bun"
+import { temporaryDirectory } from "tempy"
+import { join } from "path"
+import { existsSync } from "fs"
+
+test("tsci export gerbers --input example-project/examples/macrokeypad.tsx", async () => {
+  const tempDir = temporaryDirectory()
+  const { stdout, stderr } =
+    await $`bun cli/cli.ts export gerbers --input example-project/examples/macrokeypad.tsx --outputfile ${join(tempDir, "gerbers.zip")} --no-color`
+
+  expect(stderr.toString()).toBe("")
+  expect(stdout.toString()).toContain("gerbers.zip")
+
+  expect(existsSync(join(tempDir, "gerbers.zip"))).toBe(true)
+})

package/cli/tests/export-gerber.test.ts

@@ -0,0 +1,49 @@
+import { test, expect, describe } from "bun:test"
+import { $ } from "bun"
+import { temporaryDirectory } from "tempy"
+import { join } from "path"
+import { existsSync, readdirSync, readFileSync } from "fs"
+import extract from "extract-zip"
+import pcbStackup from "pcb-stackup"
+
+test("tsci export gerbers --input example-project/examples/basic-chip.tsx", async () => {
+  const tempDir = temporaryDirectory()
+  const gerberPath = join(tempDir, "gerbers.zip")
+  const { stdout, stderr } =
+    await $`bun cli/cli.ts export gerbers --input example-project/examples/basic-chip.tsx --outputfile ${gerberPath} --no-color`
+
+  expect(stderr.toString()).toBe("")
+  expect(stdout.toString()).toContain("gerbers.zip")
+
+  expect(existsSync(join(tempDir, "gerbers.zip"))).toBe(true)
+
+  await extract(gerberPath, { dir: join(tempDir, "gerbers") })
+
+  const files = readdirSync(join(tempDir, "gerbers"))
+  const expectedFiles = [
+    "F_Mask.gbr",
+    "F_SilkScreen.gbr",
+    "B_Cu.gbr",
+    "plated.drl",
+    "B_SilkScreen.gbr",
+    "F_Cu.gbr",
+    "B_Paste.gbr",
+    "F_Paste.gbr",
+    "B_Mask.gbr",
+    "Edge_Cuts.gbr",
+  ]
+
+  expectedFiles.forEach((file) => {
+    expect(files).toContain(file)
+  })
+
+  const gerberOutputMap = Object.entries(
+    files.map((filename) => [
+      filename,
+      readFileSync(join(tempDir, "gerbers", filename)),
+    ]),
+  )
+
+  // Unfortunately doesn't work in bun yet due to some bug in node:stream
+  // expect(gerberOutputMap).toMatchGerberSnapshot(import.meta.path)
+})

package/cli/tests/fixtures/preload.ts

@@ -0,0 +1,54 @@
+import "bun-match-svg"
+import { expect } from "bun:test"
+import pcbStackup, { type Stackup } from "pcb-stackup"
+import { Readable } from "stream"
+
+async function toMatchGerberSnapshot(
+  this: any,
+  gerberOutput: Record<string, string>,
+  testPathOriginal: string,
+  svgName?: string,
+) {
+  // Create layers array from gerberOutput
+  const layers = Object.entries(gerberOutput).map(([filename, content]) => ({
+    filename,
+    gerber: Readable.from(content),
+  }))
+
+  try {
+    const stackup = await pcbStackup(layers)
+    const svgArray: string[] = []
+    const svgNames: string[] = []
+
+    for (const item of Object.keys(stackup!) as Array<keyof Stackup>) {
+      const layer = stackup[item] as { svg: string }
+      if (layer.svg) {
+        svgArray.push(layer.svg)
+        svgNames.push(`${svgName}-${item}`)
+      }
+    }
+    return expect(svgArray).toMatchMultipleSvgSnapshots(
+      testPathOriginal,
+      svgNames,
+    )
+  } catch (error) {
+    throw new Error(`Failed to generate PCB stackup: ${error}`)
+  }
+}
+
+expect.extend({
+  // biome-ignore lint/suspicious/noExplicitAny:
+  toMatchGerberSnapshot: toMatchGerberSnapshot as any,
+})
+
+declare module "bun:test" {
+  interface Matchers<T = unknown> {
+    /**
+     * This doesn't currently work in bun, some bug in node:stream
+     */
+    toMatchGerberSnapshot(
+      testImportMetaPath: string,
+      svgName?: string,
+    ): Promise<MatcherResult>
+  }
+}