@tscircuit/fake-snippets 0.0.1

package/src/lib/download-fns/download-fabrication-files.ts

@@ -0,0 +1,233 @@
+/**
+ * Some relevant code from another project
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+import * as Path from "path"
+import { unlink } from "node:fs/promises"
+import * as fs from "fs"
+import {
+  stringifyGerberCommandLayers,
+  convertSoupToGerberCommands,
+  convertSoupToExcellonDrillCommands,
+  stringifyExcellonDrill,
+} from "circuit-json-to-gerber"
+import kleur from "kleur"
+import archiver from "archiver"
+import { AnyCircuitElement } from "circuit-json"
+
+export const exportGerbersToFile = async (
+  params: {
+    circuitJson: AnyCircuitElement[]
+    example_file_path: string
+    export_name?: string
+    output_zip_path: string
+  },
+  ctx: AppContext,
+) => {
+  console.log(kleur.gray("[soupifying]..."))
+
+  console.log(kleur.gray("[soup to gerber json]..."))
+  const gerber_layer_cmds = convertSoupToGerberCommands(circuitJson, {
+    flip_y_axis: false,
+  })
+
+  console.log(kleur.gray("[soup to drl json]..."))
+  const drill_cmds = convertSoupToExcellonDrillCommands({
+    soup: circuitJson,
+    is_plated: true,
+    flip_y_axis: false,
+  })
+
+  console.log(kleur.gray("[stringify gerber json]..."))
+  const gerber_file_contents = stringifyGerberCommandLayers(gerber_layer_cmds)
+  console.log(kleur.gray("[stringify drl json]..."))
+  const drill_file_contents = {
+    plated: stringifyExcellonDrill(drill_cmds),
+  }
+
+  console.log(kleur.gray("[writing gerbers to tmp dir]..."))
+  const tempDir = Path.join(".tscircuit", "tmp-gerber-export")
+  fs.rmSync(tempDir, { recursive: true, force: true })
+  fs.mkdirSync(tempDir, { recursive: true })
+  for (const [fileName, fileContents] of Object.entries(gerber_file_contents)) {
+    const filePath = Path.join(tempDir, fileName)
+    await fs.writeFileSync(`${filePath}.gbr`, fileContents)
+  }
+  for (const [fileName, fileContents] of Object.entries(drill_file_contents)) {
+    const filePath = Path.join(tempDir, fileName)
+    await fs.writeFileSync(`${filePath}.drl`, fileContents)
+  }
+
+  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)
+
+  const archive = archiver("zip", {
+    zlib: { level: 9 },
+  })
+
+  archive.pipe(output)
+  archive.directory(tempDir, false)
+
+  await new Promise((resolve, reject) => {
+    output.on("close", resolve)
+    output.on("finish", resolve)
+    output.on("end", resolve)
+    output.on("error", reject)
+    archive.finalize()
+  })
+}
+
+export const exportGerbersToZipBuffer = async (
+  params: {
+    example_file_path: string
+    export_name?: string
+  },
+  ctx: AppContext,
+) => {
+  const tempDir = Path.join(".tscircuit", "tmp-gerber-zip")
+  fs.mkdirSync(tempDir, { recursive: true })
+
+  await exportGerbersToFile(
+    {
+      example_file_path: params.example_file_path,
+      export_name: params.export_name,
+      output_zip_path: Path.join(tempDir, "gerbers.zip"),
+    },
+    ctx,
+  )
+
+  const buffer = fs.readFileSync(Path.join(tempDir, "gerbers.zip"))
+
+  fs.rmSync(tempDir, { recursive: true })
+
+  return buffer
+}
+
+
+import { AppContext } from "../util/app-context"
+import { soupify } from "cli/lib/soupify"
+import kleur from "kleur"
+import {
+  convertCircuitJsonToBomRows,
+  convertBomRowsToCsv,
+} from "circuit-json-to-bom-csv"
+
+export const exportBomCsvToBuffer = async (
+  params: {
+    example_file_path: string
+    export_name?: string
+  },
+  ctx: AppContext,
+) => {
+  console.log(kleur.gray("[soupifying]..."))
+  const circuitJson = await circuitJsonify(
+    {
+      filePath: params.example_file_path,
+      exportName: params.export_name,
+    },
+    ctx,
+  )
+
+  console.log(kleur.gray("[circuitJson to bom rows]..."))
+  const bom_rows = await convertCircuitJsonToBomRows({ circuitJson: circuitJson })
+
+  console.log(kleur.gray("[bom rows to csv]..."))
+  const bom_csv = await convertBomRowsToCsv(bom_rows)
+
+  return Buffer.from(bom_csv, "utf-8")
+}
+
+
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+import * as Path from "path"
+import { unlink } from "node:fs/promises"
+import { soupify } from "cli/lib/soupify"
+import { convertCircuitJsonToPickAndPlaceCsv } from "circuit-json-to-pnp-csv"
+import * as fs from "fs"
+import kleur from "kleur"
+import archiver from "archiver"
+
+export const exportPnpCsvToBuffer = async (
+  params: {
+    example_file_path: string
+    export_name?: string
+  },
+  ctx: AppContext,
+) => {
+  console.log(kleur.gray("[soupifying]..."))
+  const circuitJson = await soupify(
+    {
+      filePath: params.example_file_path,
+      exportName: params.export_name,
+    },
+    ctx,
+  )
+
+  console.log(kleur.gray("[circuitJson to pnp csv string]..."))
+  const pnp_csv = await convertCircuitJsonToPickAndPlaceCsv(circuitJson)
+
+  return Buffer.from(pnp_csv, "utf-8")
+}
+
+
+
+*/
+
+import { AnyCircuitElement } from "circuit-json"
+import { saveAs } from "file-saver"
+import JSZip from "jszip"
+import {
+  stringifyGerberCommandLayers,
+  convertSoupToGerberCommands,
+  convertSoupToExcellonDrillCommands,
+  stringifyExcellonDrill,
+} from "circuit-json-to-gerber"
+import {
+  convertCircuitJsonToBomRows,
+  convertBomRowsToCsv,
+} from "circuit-json-to-bom-csv"
+import { convertCircuitJsonToPickAndPlaceCsv } from "circuit-json-to-pnp-csv"
+
+export const downloadFabricationFiles = async ({
+  circuitJson,
+  snippetUnscopedName,
+}: {
+  circuitJson: AnyCircuitElement[]
+  snippetUnscopedName: string
+}) => {
+  const zip = new JSZip()
+
+  // Generate Gerber files
+  const gerberLayerCmds = convertSoupToGerberCommands(circuitJson, {
+    flip_y_axis: false,
+  })
+  const gerberFileContents = stringifyGerberCommandLayers(gerberLayerCmds)
+
+  for (const [fileName, fileContents] of Object.entries(gerberFileContents)) {
+    zip.file(`gerber/${fileName}.gbr`, fileContents)
+  }
+
+  // Generate Drill files
+  const drillCmds = convertSoupToExcellonDrillCommands({
+    circuitJson,
+    is_plated: true,
+    flip_y_axis: false,
+  })
+  const drillFileContents = stringifyExcellonDrill(drillCmds)
+  zip.file("gerber/drill.drl", drillFileContents)
+
+  // Generate BOM CSV
+  const bomRows = await convertCircuitJsonToBomRows({ circuitJson })
+  const bomCsv = await convertBomRowsToCsv(bomRows)
+  zip.file("bom.csv", bomCsv)
+
+  // Generate Pick and Place CSV
+  const pnpCsv = await convertCircuitJsonToPickAndPlaceCsv(circuitJson)
+  zip.file("pick_and_place.csv", pnpCsv)
+
+  // Generate and download the zip file
+  const zipBlob = await zip.generateAsync({ type: "blob" })
+  saveAs(zipBlob, `${snippetUnscopedName}_fabrication_files.zip`)
+}

package/src/lib/download-fns/download-gltf.ts

@@ -0,0 +1,49 @@
+import { AnyCircuitElement } from "circuit-json"
+import { convertCircuitJsonToAssemblySvg } from "circuit-to-svg"
+import { GLTFExporter, type GLTFExporterOptions } from "three-stdlib"
+import { saveAs } from "file-saver"
+import * as THREE from "three"
+
+export const downloadGltf = async (
+  circuitJson: AnyCircuitElement[],
+  fileName: string,
+) => {
+  const threeJsObject = window.TSCIRCUIT_3D_OBJECT_REF
+    ?.current as THREE.Object3D
+
+  if (!threeJsObject) {
+    throw new Error(
+      "No 3D object found, run the snippet before downloading the 3d model",
+    )
+  }
+
+  const exporter = new GLTFExporter()
+
+  const options: GLTFExporterOptions = {
+    binary: true,
+  }
+
+  const {
+    promise: gltfPromise,
+    resolve: resolveGltf,
+    reject: rejectGltf,
+  } = Promise.withResolvers<Blob>()
+
+  exporter.parse(
+    threeJsObject,
+    (gltf) => {
+      const type = options.binary ? "gltf-binary" : "gltf+json"
+      const blob = new Blob(
+        [gltf instanceof ArrayBuffer ? gltf : JSON.stringify(gltf)],
+        { type: `model/${type}` },
+      )
+      resolveGltf(blob)
+    },
+    rejectGltf,
+    options,
+  )
+
+  const gltfBlob = await gltfPromise
+
+  saveAs(gltfBlob, fileName + ".gltf")
+}

package/src/lib/download-fns/download-kicad-files.ts

@@ -0,0 +1,27 @@
+import { saveAs } from "file-saver"
+import { convertCircuitJsonToKiCadPcb } from "kicad-converter"
+import { convertCircuitJsonToKicadPro } from "kicad-converter"
+import { AnyCircuitElement } from "circuit-json"
+import JSZip from "jszip"
+
+export const downloadKicadFiles = (
+  circuitJson: AnyCircuitElement[],
+  fileName: string,
+) => {
+  const kicadPcbString = convertCircuitJsonToKiCadPcb(circuitJson)
+  const pcbContent =
+    typeof kicadPcbString === "object"
+      ? JSON.stringify(kicadPcbString)
+      : kicadPcbString
+
+  const kicadProContent = convertCircuitJsonToKicadPro(circuitJson)
+  const proContent = JSON.stringify(kicadProContent)
+
+  const zip = new JSZip()
+  zip.file(`${fileName}.kicad_pcb`, pcbContent)
+  zip.file(`${fileName}.kicad_pro`, proContent)
+
+  zip.generateAsync({ type: "blob" }).then((content) => {
+    saveAs(content, `${fileName}_kicad.zip`)
+  })
+}

package/src/lib/download-fns/download-readable-netlist.ts

@@ -0,0 +1,12 @@
+import { AnyCircuitElement } from "circuit-json"
+import { saveAs } from "file-saver"
+import { convertCircuitJsonToReadableNetlist } from "circuit-json-to-readable-netlist"
+
+export const downloadReadableNetlist = (
+  circuitJson: AnyCircuitElement[],
+  fileName: string,
+) => {
+  const readableNetlistString = convertCircuitJsonToReadableNetlist(circuitJson)
+  const blob = new Blob([readableNetlistString], { type: "text/plain" })
+  saveAs(blob, fileName + ".txt")
+}

package/src/lib/download-fns/download-schematic-svg.ts

@@ -0,0 +1,12 @@
+import { AnyCircuitElement } from "circuit-json"
+import { convertCircuitJsonToSchematicSvg } from "circuit-to-svg"
+import { saveAs } from "file-saver"
+
+export const downloadSchematicSvg = (
+  circuitJson: AnyCircuitElement[],
+  fileName: string,
+) => {
+  const svg = convertCircuitJsonToSchematicSvg(circuitJson)
+  const blob = new Blob([svg], { type: "image/svg" })
+  saveAs(blob, fileName + ".svg")
+}

package/src/lib/download-fns/download-simple-route-json.ts

@@ -0,0 +1,17 @@
+import { AnyCircuitElement } from "circuit-json"
+import { getSimpleRouteJsonFromCircuitJson } from "@tscircuit/core"
+import { saveAs } from "file-saver"
+
+export const downloadSimpleRouteJson = (
+  circuitJson: AnyCircuitElement[],
+  fileName: string,
+) => {
+  const simpleRouteJson = getSimpleRouteJsonFromCircuitJson({
+    circuitJson: circuitJson as any,
+    minTraceWidth: 0.1,
+  })
+  const blob = new Blob([JSON.stringify(simpleRouteJson, null, 2)], {
+    type: "application/json",
+  })
+  saveAs(blob, fileName + "_routes.json")
+}

package/src/lib/encodeTextToUrlHash.ts

@@ -0,0 +1,17 @@
+import { gzipSync, strToU8 } from "fflate"
+import { bytesToBase64 } from "./bytesToBase64"
+
+export function encodeTextToUrlHash(
+  text: string,
+  snippet_type?: string,
+): string {
+  // Compress the input string
+  const compressedData = gzipSync(strToU8(text))
+
+  // Convert to base64
+  const base64Data = bytesToBase64(compressedData)
+
+  // Construct the URL
+  const typeParam = snippet_type ? `&snippet_type=${snippet_type}` : ""
+  return `${window.location.origin}/editor?${typeParam}#data:application/gzip;base64,${base64Data}`
+}

package/src/lib/get-snippet-template.ts

@@ -0,0 +1,26 @@
+import { blankPackageTemplate } from "@/lib/templates/blank-package-template"
+import { blankFootprintTemplate } from "@/lib/templates/blank-footprint-template"
+import { blankCircuitBoardTemplate } from "@/lib/templates/blank-circuit-board-template"
+import { blank3dModelTemplate } from "@/lib/templates/blank-3d-model-template"
+import { defaultCodeForBlankPage } from "@/lib/defaultCodeForBlankCode"
+import { blinkingLedBoardTemplate } from "@/lib/templates/blinking-led-board-template"
+import { usbCLedFlashlightTemplate } from "@/lib/templates/usb-c-led-flashlight-template"
+
+export const getSnippetTemplate = (template: string | undefined) => {
+  switch (template) {
+    case "blank-circuit-module":
+      return blankPackageTemplate
+    case "blank-footprint":
+      return blankFootprintTemplate
+    case "blank-circuit-board":
+      return blankCircuitBoardTemplate
+    case "blank-3d-model":
+      return blank3dModelTemplate
+    case "blinking-led-board":
+      return blinkingLedBoardTemplate
+    case "usb-c-led-flashlight":
+      return usbCLedFlashlightTemplate
+    default:
+      return { code: defaultCodeForBlankPage, type: "board" }
+  }
+}

package/src/lib/handleManualEditsImport.tsx

@@ -0,0 +1,65 @@
+import { FileName } from "@/components/CodeEditorHeader"
+
+export const handleManualEditsImport = (
+  files: Record<string, string>,
+  updateFileContent: (filename: FileName, content: string) => void,
+  toast: (options: {
+    title: string
+    description: string
+    variant?: "default" | "destructive"
+  }) => void,
+) => {
+  try {
+    let currentContent = files["index.tsx"]
+    const importRegex =
+      /import\s+(?:\*\s+as\s+)?([a-zA-Z_$][\w$]*)\s+from\s+["']\.\/manual-edits\.json["'];?/
+    const match = importRegex.exec(currentContent)
+    const importVariableName = match ? match[1] : "manualEdits"
+
+    if (!match) {
+      currentContent = `import ${importVariableName} from "./manual-edits.json";\n${currentContent}`
+    }
+
+    const boardRegex = /<board\b[^>]*>/gi
+    const groupSubcircuitRegex = /<group\b[^>]*\bsubcircuit\b[^>]*>/gi
+
+    let modifiedContent = currentContent.replace(boardRegex, (match) =>
+      match.includes(`manualEdits={${importVariableName}}`)
+        ? match
+        : match.replace(">", ` manualEdits={${importVariableName}}>`),
+    )
+
+    modifiedContent = modifiedContent.replace(groupSubcircuitRegex, (match) =>
+      match.includes(`manualEdits={${importVariableName}}`)
+        ? match
+        : match.replace(">", ` manualEdits={${importVariableName}}>`),
+    )
+
+    if (modifiedContent === currentContent) {
+      toast({
+        title: "No Manual Edits Applied",
+        description:
+          "No applicable <board> or <group subcircuit> tags were found to apply manual edits.",
+        variant: "destructive",
+      })
+      return
+    }
+
+    updateFileContent("index.tsx", modifiedContent)
+
+    toast({
+      title: "Manual Edits Imported",
+      description: "Successfully imported and applied manual edits.",
+      variant: "default",
+    })
+  } catch (error) {
+    toast({
+      title: "Import Error",
+      description:
+        error instanceof Error
+          ? error.message
+          : "Failed to import manual edits. Please check the file and apply manually.",
+      variant: "destructive",
+    })
+  }
+}

package/src/lib/jlc-parts-engine.ts

@@ -0,0 +1,69 @@
+import { type PartsEngine, SupplierPartNumbers } from "@tscircuit/props"
+import { AnySourceComponent } from "circuit-json"
+import qs from "qs"
+
+const cache = new Map<string, any>()
+const getJlcPartsCached = async (name: any, params: any) => {
+  const paramString = qs.stringify({ ...params, json: "true" })
+  if (cache.has(paramString)) {
+    return cache.get(paramString)
+  }
+  const response = await fetch(
+    `https://jlcsearch.tscircuit.com/${name}/list?${paramString}`,
+  )
+  const responseJson = await response.json()
+  cache.set(paramString, responseJson)
+  return responseJson
+}
+
+export const jlcPartsEngine: PartsEngine = {
+  findPart: async ({
+    sourceComponent,
+    footprinterString,
+  }): Promise<SupplierPartNumbers> => {
+    if (sourceComponent.ftype === "simple_resistor") {
+      const { resistors } = await getJlcPartsCached("resistors", {
+        resistance: sourceComponent.resistance,
+        package: footprinterString,
+      })
+
+      return {
+        jlcpcb: resistors.map((r: any) => `C${r.lcsc}`).slice(0, 3),
+      }
+    } else if (sourceComponent.ftype === "simple_capacitor") {
+      if (footprinterString?.includes("cap")) {
+        footprinterString = footprinterString.replace("cap", "")
+      }
+      const { capacitors } = await getJlcPartsCached("capacitors", {
+        capacitance: sourceComponent.capacitance,
+        package: footprinterString,
+      })
+
+      return {
+        jlcpcb: capacitors.map((c: any) => `C${c.lcsc}`).slice(0, 3),
+      }
+    } else if (sourceComponent.ftype === "simple_pin_header") {
+      let pitch
+      if (footprinterString?.includes("_p")) {
+        pitch = footprinterString.split("_p")[1]
+      }
+      const { headers } = await getJlcPartsCached(
+        "headers",
+        pitch
+          ? {
+              pitch: pitch,
+              num_pins: sourceComponent.pin_count,
+              gender: sourceComponent.gender,
+            }
+          : {
+              num_pins: sourceComponent.pin_count,
+              gender: sourceComponent.gender,
+            },
+      )
+      return {
+        jlcpcb: headers.map((h: any) => `C${h.lcsc}`).slice(0, 3),
+      }
+    }
+    return {}
+  },
+}

package/src/lib/templates/blank-3d-model-template.ts

@@ -0,0 +1,12 @@
+export const blank3dModelTemplate = {
+  type: "model",
+  code: `
+// Note: Eventually this should have a <jscad> wrapper
+export const MyModel = (props: any) => (
+  <>
+    {/* <cuboid size={[5, 10, 5]} /> */}
+    <cube size={1} />
+  </>
+)
+`.trim(),
+}

package/src/lib/templates/blank-circuit-board-template.ts

@@ -0,0 +1,24 @@
+export const blankCircuitBoardTemplate = {
+  type: "board",
+  code: `
+export default () => (
+  <board width="10mm" height="10mm">
+    <resistor
+      resistance="1k"
+      footprint="0402"
+      name="R1"
+      schX={3}
+      pcbX={3}
+    />
+    <capacitor
+      capacitance="1000pF"
+      footprint="0402"
+      name="C1"
+      schX={-3}
+      pcbX={-3}
+    />
+    <trace from=".R1 > .pin1" to=".C1 > .pin1" />
+  </board>
+)
+`.trim(),
+}

package/src/lib/templates/blank-footprint-template.ts

@@ -0,0 +1,29 @@
+export const blankFootprintTemplate = {
+  type: "footprint",
+  code: `
+export const MyFootprint = (props: any) => (
+  <footprint>
+    <smtpad
+      shape="rect"
+      width="0.5mm"
+      height="0.5mm"
+      schX={-1}
+      schY={0}
+      pcbX={-1}
+      pcbY={0}
+      portHints={["1"]}
+    />
+    <smtpad
+      shape="rect"
+      width="0.5mm"
+      height="0.5mm"
+      schX={1}
+      schY={0}
+      pcbX={1}
+      pcbY={0}
+      portHints={["2"]}
+    />
+  </footprint>
+)
+`.trim(),
+}

package/src/lib/templates/blank-package-template.ts

@@ -0,0 +1,22 @@
+export const blankPackageTemplate = {
+  type: "package",
+  code: `
+import { createUseComponent } from "@tscircuit/core"
+
+export const MyChip = (props: { name: string }) => (
+  <chip {...props} pinLabels={pinLabels} footprint="soic8" />
+)
+const pinLabels = {
+  pin1: [],
+  pin2: [],
+  pin3: [],
+  pin4: [],
+  pin5: [],
+  pin6: [],
+  pin7: [],
+  pin8: [],
+} as const
+
+export const useMyChip = createUseComponent(MyChip, pinLabels)
+`.trim(),
+}

package/src/lib/templates/blinking-led-board-template.ts

@@ -0,0 +1,63 @@
+export const blinkingLedBoardTemplate = {
+  type: "board",
+  code: `
+import { useUsbC } from "@tsci/seveibar.smd-usb-c"
+import { useRedLed } from "@tsci/seveibar.red-led"
+import { A555Timer } from "@tsci/seveibar.a555timer"
+
+export const MyBlinkingLedCircuit = () => {
+  const USBC = useUsbC("USBC")
+  const Led = useRedLed("LED")
+
+  return (
+    <board width="30mm" height="30mm" schAutoLayoutEnabled>
+      <USBC GND1="net.GND" VBUS1="net.VBUS" pcbX={-10} pcbY={-10} />
+      <A555Timer
+        name="B1"
+        pin8="net.VBUS"
+        pin1="net.GND"
+        pin3="net.OUT"
+        pin2="net.TRIG"
+        pin6="net.THRES"
+        pin7="net.DIS"
+      />
+      <resistor name="R1" resistance="1K" footprint="0805" pcbX={-8} pcbY={8} />
+      <resistor
+        name="R2"
+        resistance="470K"
+        footprint="0805"
+        pcbX={0}
+        pcbY={-8}
+      />
+      <resistor
+        name="R3"
+        resistance="1k"
+        footprint="0805"
+        pcbX={2.5}
+        pcbY={8}
+      />
+    
+      <capacitor
+        name="C1"
+        capacitance="1uF"
+        footprint="0805"
+        pcbX={-2.5}
+        pcbY={8}
+      />
+      
+      <Led pos="net.OUT" neg="net.GND" pcbX={5} pcbY={10} />
+      
+      <trace from=".USBC > .VBUS1" to=".R1 > .left" />
+      <trace from=".R1 > .right" to=".R2 > .left" />
+      <trace from=".R2 > .right" to=".C1 > .left" />
+      <trace from=".C1 > .right" to=".USBC > .GND1" />
+      <trace from=".B1 > .pin7" to=".R1 > .right" /> 
+      <trace from=".B1 > .pin6" to=".R2 > .right" />
+      <trace from=".B1 > .pin2" to=".R2 > .right" />
+      <trace from=".B1 > .pin3" to=".R3 > .left" />
+      <trace from=".R3 > .right" to=".LED > .pos" />
+    </board>
+  )
+}
+`.trim(),
+}