easyeda 0.0.2

package/lib/convert-easyeda-json-to-tscircuit-soup-json.ts

@@ -0,0 +1,204 @@
+import {
+  PadSchema,
+  TrackSchema,
+  ArcSchema,
+  SVGNodeSchema,
+} from "./schemas/package-detail-shape-schema"
+import { z } from "zod"
+import type { EasyEdaJson } from "./schemas/easy-eda-json-schema"
+import type {
+  AnySoupElement,
+  PCBSMTPad,
+  PcbSilkscreenPath,
+  PCBPlatedHole,
+  PCBPlatedHoleInput,
+} from "@tscircuit/soup"
+import {
+  any_source_component,
+  pcb_smtpad,
+  pcb_silkscreen_path,
+  pcb_plated_hole,
+} from "@tscircuit/soup"
+import * as Soup from "@tscircuit/soup"
+import { generateArcFromSweep, generateArcPathWithMid } from "./math/arc-utils"
+import { transformPCBElements } from "@tscircuit/builder"
+import { scale } from "transformation-matrix"
+
+const handleSilkscreenPath = (
+  track: z.infer<typeof TrackSchema>,
+  index: number
+) => {
+  return pcb_silkscreen_path.parse({
+    type: "pcb_silkscreen_path",
+    pcb_silkscreen_path_id: `pcb_silkscreen_path_${index + 1}`,
+    pcb_component_id: "pcb_component_1",
+    layer: "top", // Assuming all silkscreen is on top layer
+    route: track.points.map((point) => ({ x: point.x, y: point.y })),
+    stroke_width: track.width,
+  })
+}
+
+const handleSilkscreenArc = (arc: z.infer<typeof ArcSchema>, index: number) => {
+  const arcPath = generateArcFromSweep(
+    arc.start.x,
+    arc.start.y,
+    arc.end.x,
+    arc.end.y,
+    arc.radiusX,
+    arc.largeArc,
+    arc.sweepDirection === "CW"
+  )
+
+  return pcb_silkscreen_path.parse({
+    type: "pcb_silkscreen_path",
+    pcb_silkscreen_path_id: `pcb_silkscreen_arc_${index + 1}`,
+    pcb_component_id: "pcb_component_1",
+    layer: "top", // Assuming all silkscreen is on top layer
+    route: arcPath,
+    stroke_width: arc.width,
+  })
+}
+
+interface Options {
+  useModelCdn?: boolean
+}
+
+export const convertEasyEdaJsonToTscircuitSoupJson = (
+  easyEdaJson: EasyEdaJson,
+  { useModelCdn }: Options = {}
+): AnySoupElement[] => {
+  const soupElements: AnySoupElement[] = []
+
+  // Add source component
+  const source_component = any_source_component.parse({
+    type: "source_component",
+    source_component_id: "source_component_1",
+    name: "U1",
+    ftype: "simple_bug",
+  })
+
+  const pcb_component = Soup.pcb_component.parse({
+    type: "pcb_component",
+    pcb_component_id: "pcb_component_1",
+    source_component_id: "source_component_1",
+    name: "U1",
+    ftype: "simple_bug",
+    width: 0, // TODO compute width
+    height: 0, // TODO compute height
+    rotation: 0,
+    center: { x: 0, y: 0 },
+    layer: "top",
+  } as Soup.PCBComponentInput)
+
+  soupElements.push(source_component, pcb_component)
+
+  // Add source ports and pcb_smtpads
+  easyEdaJson.packageDetail.dataStr.shape
+    .filter((shape): shape is z.infer<typeof PadSchema> => shape.type === "PAD")
+    .forEach((pad, index) => {
+      const portNumber = pad.number.toString()
+
+      // Add source port
+      soupElements.push({
+        type: "source_port",
+        source_port_id: `source_port_${index + 1}`,
+        source_component_id: "source_component_1",
+        name: portNumber,
+      })
+
+      if (pad.holeRadius !== undefined && pad.holeRadius !== 0) {
+        // Add pcb_plated_hole
+        soupElements.push(
+          pcb_plated_hole.parse({
+            type: "pcb_plated_hole",
+            pcb_plated_hole_id: `pcb_plated_hole_${index + 1}`,
+            shape: "circle",
+            x: pad.center.x,
+            y: pad.center.y,
+            hole_diameter: pad.holeRadius * 2,
+            outer_diameter: pad.width,
+            radius: pad.holeRadius,
+            port_hints: [portNumber],
+            pcb_component_id: "pcb_component_1",
+            pcb_port_id: `pcb_port_${index + 1}`,
+            layers: ["top"],
+          } as PCBPlatedHoleInput)
+        )
+      } else {
+        // Add pcb_smtpad
+        let soupShape: PCBSMTPad["shape"] | undefined
+        if (pad.shape === "RECT") {
+          soupShape = "rect"
+        } else if (pad.shape === "ELLIPSE") {
+          // This is just a bug
+          soupShape = "rect"
+        } else if (pad.shape === "OVAL") {
+          // OVAL is often a rect, especially when holeRadius is 0
+          soupShape = "rect"
+        }
+        if (!soupShape) {
+          throw new Error(`unknown pad.shape: "${pad.shape}"`)
+        }
+        soupElements.push(
+          pcb_smtpad.parse({
+            type: "pcb_smtpad",
+            pcb_smtpad_id: `pcb_smtpad_${index + 1}`,
+            shape: soupShape,
+            x: pad.center.x,
+            y: pad.center.y,
+            ...(soupShape === "rect"
+              ? { width: pad.width, height: pad.height }
+              : { radius: Math.min(pad.width, pad.height) / 2 }),
+            layer: "top",
+            port_hints: [portNumber],
+            pcb_component_id: "pcb_component_1",
+            pcb_port_id: `pcb_port_${index + 1}`,
+          } as PCBSMTPad)
+        )
+      }
+    })
+
+  // Add silkscreen paths and arcs
+  easyEdaJson.packageDetail.dataStr.shape.forEach((shape, index) => {
+    if (shape.type === "TRACK") {
+      soupElements.push(handleSilkscreenPath(shape, index))
+    } else if (shape.type === "ARC") {
+      soupElements.push(handleSilkscreenArc(shape, index))
+    }
+  })
+
+  // easyeda uses a flipped Y axis ( tscircuit = y+ is up, easyeda = y- is up )
+  transformPCBElements(soupElements, scale(1, -1))
+
+  // TODO Change pcb_component width & height
+
+  // TODO compute pcb center based on all elements and transform elements such
+  // that the center is (0,0)
+
+  // Add 3d component
+  const objFileUuid = easyEdaJson.packageDetail.dataStr.shape.find(
+    (a): a is z.input<typeof SVGNodeSchema> =>
+      Boolean(a.type === "SVGNODE" && a.svgData.attrs?.uuid)
+  )?.svgData?.attrs?.uuid
+
+  const objFileUrl = objFileUuid
+    ? useModelCdn
+      ? `https://modelcdn.tscircuit.com/easyeda_models/download?uuid=${objFileUuid}&pn=${easyEdaJson.lcsc.number}`
+      : `https://modules.easyeda.com/3dmodel/${objFileUuid}`
+    : undefined
+
+  if (objFileUrl !== undefined) {
+    soupElements.push(
+      Soup.cad_component.parse({
+        type: "cad_component",
+        cad_component_id: "cad_component_1",
+        source_component_id: "source_component_1",
+        pcb_component_id: "pcb_component_1",
+        position: { x: 0, y: 0, z: 0 },
+        model_obj_url: objFileUrl,
+      } as Soup.CadComponentInput)
+    )
+  }
+
+  return soupElements
+}

package/lib/fetch-easyeda-json.ts

@@ -0,0 +1,66 @@
+export async function fetchEasyEDAComponent(
+  jlcpcbPartNumber: string
+): Promise<any> {
+  const searchUrl = "https://easyeda.com/api/components/search"
+  const componentUrl = (uuid: string) =>
+    `https://easyeda.com/api/components/${uuid}?version=6.4.7&uuid=${uuid}&datastrid=`
+
+  const searchHeaders = {
+    authority: "easyeda.com",
+    pragma: "no-cache",
+    "cache-control": "no-cache",
+    accept: "application/json, text/javascript, */*; q=0.01",
+    "x-requested-with": "XMLHttpRequest",
+    "user-agent":
+      "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36",
+    "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+    origin: "https://easyeda.com",
+    "sec-fetch-site": "same-origin",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-dest": "empty",
+    referer: "https://easyeda.com/editor",
+    "accept-language": "cs,en;q=0.9,sk;q=0.8,en-GB;q=0.7",
+    cookie: "<PUT your cookies here>",
+  }
+
+  const searchData = `type=3&doctype%5B%5D=2&uid=0819f05c4eef4c71ace90d822a990e87&returnListStyle=classifyarr&wd=${jlcpcbPartNumber}&version=6.4.7`
+
+  // Perform the search request
+  const searchResponse = await fetch(searchUrl, {
+    method: "POST",
+    headers: searchHeaders,
+    body: searchData,
+  })
+
+  if (!searchResponse.ok) {
+    throw new Error("Failed to search for the component")
+  }
+
+  const searchResult = await searchResponse.json()
+  if (!searchResult.success || !searchResult.result.lists.lcsc.length) {
+    throw new Error("Component not found")
+  }
+
+  const componentUUID = searchResult.result.lists.lcsc[0].uuid
+
+  // Perform the component fetch request
+  const componentResponse = await fetch(componentUrl(componentUUID), {
+    method: "GET",
+    headers: {
+      ...searchHeaders,
+      referer: `https://easyeda.com/editor?uuid=${componentUUID}`,
+    },
+  })
+
+  if (!componentResponse.ok) {
+    throw new Error("Failed to fetch the component details")
+  }
+
+  const componentResult = await componentResponse.json()
+  return componentResult
+}
+
+// Usage example
+// fetchEasyEDAComponent("C558438")
+//   .then((component) => console.log(component))
+//   .catch((error) => console.error(error))

package/lib/index.ts

@@ -0,0 +1,2 @@
+export * from "./convert-easyeda-json-to-tscircuit-soup-json"
+export * from "./fetch-easyeda-json"

package/lib/math/arc-utils.ts

@@ -0,0 +1,170 @@
+export interface Point {
+  x: number
+  y: number
+}
+
+export function calculateCenter(start: Point, mid: Point, end: Point): Point {
+  const mid1 = { x: (start.x + mid.x) / 2, y: (start.y + mid.y) / 2 }
+  const mid2 = { x: (mid.x + end.x) / 2, y: (mid.y + end.y) / 2 }
+
+  const slope1 = -(start.x - mid.x) / (start.y - mid.y)
+  const slope2 = -(mid.x - end.x) / (mid.y - end.y)
+
+  const centerX =
+    (mid1.y - mid2.y + slope2 * mid2.x - slope1 * mid1.x) / (slope2 - slope1)
+  const centerY = mid1.y + slope1 * (centerX - mid1.x)
+
+  return { x: centerX, y: centerY }
+}
+
+function calculateRadius(center: Point, point: Point): number {
+  return Math.sqrt((center.x - point.x) ** 2 + (center.y - point.y) ** 2)
+}
+
+function calculateAngle(center: Point, point: Point): number {
+  return Math.atan2(point.y - center.y, point.x - center.x)
+}
+
+export const getArcLength = (start: Point, mid: Point, end: Point) => {
+  const center = calculateCenter(start, mid, end)
+  const radius = calculateRadius(center, start)
+
+  const angleStart = calculateAngle(center, start)
+  const angleEnd = calculateAngle(center, end)
+
+  let angleDelta = angleEnd - angleStart
+  if (angleDelta < 0) {
+    angleDelta += 2 * Math.PI
+  }
+
+  return radius * angleDelta
+}
+
+export function generateArcPathWithMid(
+  start: Point,
+  mid: Point,
+  end: Point,
+  numPoints: number
+): Point[] {
+  const center = calculateCenter(start, mid, end)
+  const radius = calculateRadius(center, start)
+
+  const angleStart = calculateAngle(center, start)
+  const angleEnd = calculateAngle(center, end)
+
+  let angleDelta = angleEnd - angleStart
+  if (angleDelta < 0) {
+    angleDelta += 2 * Math.PI
+  }
+
+  const path: Point[] = []
+
+  for (let i = 0; i <= numPoints; i++) {
+    const angle = angleStart + (i / numPoints) * angleDelta
+    const x = center.x + radius * Math.cos(angle)
+    const y = center.y + radius * Math.sin(angle)
+    // Check for NaN or Infinity values
+    if (!isNaN(x) && isFinite(x) && !isNaN(y) && isFinite(y)) {
+      path.push({ x, y })
+    }
+  }
+
+  // If the path is empty, add the start and end points
+  if (path.length === 0) {
+    path.push(start, end)
+  }
+
+  return path
+}
+
+/**
+This syntax describes an SVG path command for drawing an arc. Let's break down each part:
+
+1. "M 3923.0512 2968.5197": 
+   - M: Move to
+   - 3923.0512: X-coordinate
+   - 2968.5197: Y-coordinate
+
+2. "A 2.5 2.5 0 0 0 3923.0512 2963.5197":
+   - A: Arc command
+   - 2.5: X-radius of the ellipse
+   - 2.5: Y-radius of the ellipse
+   - 0: X-axis rotation (in degrees)
+   - 0: Large arc flag (0 for small arc, 1 for large arc)
+   - 0: Sweep flag (0 for counterclockwise, 1 for clockwise)
+   - 3923.0512: End X-coordinate
+   - 2963.5197: End Y-coordinate
+
+This command draws an arc starting at (3923.0512, 2968.5197) and ending at (3923.0512, 2963.5197), using a circular path with a radius of 2.5 units.
+ */
+export function generateArcFromSweep(
+  startX: number,
+  startY: number,
+  endX: number,
+  endY: number,
+  radius: number,
+  largeArcFlag: boolean,
+  sweepFlag: boolean
+): Point[] {
+  const start: Point = { x: startX, y: startY }
+  const end: Point = { x: endX, y: endY }
+
+  // Calculate the midpoint between start and end
+  const midX = (startX + endX) / 2
+  const midY = (startY + endY) / 2
+
+  // Calculate the distance between start and end
+  const dx = endX - startX
+  const dy = endY - startY
+  const distance = Math.sqrt(dx * dx + dy * dy)
+
+  // If the distance is zero or the radius is too small, return a straight line
+  if (distance === 0 || radius < distance / 2) {
+    return [start, end]
+  }
+
+  // Calculate the center of the arc
+  const h = Math.sqrt(radius * radius - (distance * distance) / 4)
+  const angle = Math.atan2(dy, dx)
+  const centerX = midX + h * Math.sin(angle) * (sweepFlag ? 1 : -1)
+  const centerY = midY - h * Math.cos(angle) * (sweepFlag ? 1 : -1)
+
+  // Calculate start and end angles
+  const startAngle = Math.atan2(startY - centerY, startX - centerX)
+  let endAngle = Math.atan2(endY - centerY, endX - centerX)
+
+  // Adjust end angle based on sweep and large arc flags
+  if (!sweepFlag && endAngle > startAngle) {
+    endAngle -= 2 * Math.PI
+  } else if (sweepFlag && endAngle < startAngle) {
+    endAngle += 2 * Math.PI
+  }
+
+  if (
+    (!largeArcFlag && Math.abs(endAngle - startAngle) > Math.PI) ||
+    (largeArcFlag && Math.abs(endAngle - startAngle) < Math.PI)
+  ) {
+    if (endAngle > startAngle) {
+      endAngle -= 2 * Math.PI
+    } else {
+      endAngle += 2 * Math.PI
+    }
+  }
+
+  // Generate points along the arc
+  const numPoints = Math.max(
+    2,
+    Math.ceil(Math.abs(endAngle - startAngle) * radius)
+  )
+  const path: Point[] = []
+
+  for (let i = 0; i <= numPoints; i++) {
+    const t = i / numPoints
+    const angle = startAngle + t * (endAngle - startAngle)
+    const x = centerX + radius * Math.cos(angle)
+    const y = centerY + radius * Math.sin(angle)
+    path.push({ x, y })
+  }
+
+  return path
+}

package/lib/schemas/easy-eda-json-schema.ts

@@ -0,0 +1,158 @@
+import { z } from "zod"
+import {
+  PackageDetailShapeSchema,
+  ShapeItemSchema,
+} from "./package-detail-shape-schema"
+import { SingleLetterShapeSchema } from "./single-letter-shape-schema"
+
+export const maybeNumber = z
+  .any()
+  .transform((k) => (k === "nan" || Number.isNaN(k) ? null : k))
+  .pipe(z.number().nullable().optional())
+
+export const SzlcscSchema = z.object({
+  id: z.number(),
+  number: z.string(),
+  step: z.number().optional(),
+  min: z.number().optional(),
+  price: z.number().optional(),
+  stock: z.number().optional(),
+  url: z.string().url().optional(),
+  image: z.string().optional().optional(),
+})
+
+export const LcscSchema = z.object({
+  id: z.number(),
+  number: z.string(),
+  step: z.number().optional(),
+  min: z.number().optional(),
+  price: z.number().optional(),
+  stock: z.number().optional(),
+  url: z.string().url().optional(),
+})
+
+export const OwnerSchema = z.object({
+  uuid: z.string(),
+  username: z.string(),
+  nickname: z.string(),
+  avatar: z.string(),
+})
+
+export const HeadSchema = z.object({
+  docType: z.string(),
+  editorVersion: z.string(),
+  c_para: z.record(z.string(), z.string()),
+  x: z.number(),
+  y: z.number(),
+  puuid: z.string().optional(),
+  uuid: z.string(),
+  utime: z.number(),
+  importFlag: z.number(),
+  c_spiceCmd: z.any().optional(),
+  hasIdFlag: z.boolean(),
+})
+
+export const BBoxSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+  width: z.number(),
+  height: z.number(),
+})
+
+export const LayerItemSchema = z.object({
+  name: z.string(),
+  color: z.string(),
+  visible: z.boolean(),
+  active: z.boolean(),
+  config: z.boolean(),
+  transparency: z.boolean(),
+})
+
+export const ObjectItemSchema = z.object({
+  name: z.string(),
+  visible: z.boolean(),
+  locked: z.boolean(),
+})
+
+export const DataStrSchema = z.object({
+  head: HeadSchema,
+  canvas: z.string(),
+  shape: z.array(SingleLetterShapeSchema),
+  BBox: BBoxSchema,
+  colors: z.array(z.unknown()),
+})
+
+export const PackageDetailDataStrSchema = z.object({
+  head: HeadSchema,
+  canvas: z.string(),
+  shape: z
+    .array(z.string())
+    .transform((shapes) =>
+      shapes.map((shape) => {
+        const [type, ...data] = shape.split("~")
+        return ShapeItemSchema.parse({ type, data: data.join("~") })
+      })
+    )
+    .pipe(z.array(PackageDetailShapeSchema)),
+  layers: z.array(z.string()).transform((layers) =>
+    layers.map((layer) => {
+      const [name, color, visible, active, config, transparency] =
+        layer.split("~")
+      return LayerItemSchema.parse({
+        name,
+        color,
+        visible: visible === "true",
+        active: active === "true",
+        config: config === "true",
+        transparency: transparency === "true",
+      })
+    })
+  ),
+  objects: z.array(z.string()).transform((objects) =>
+    objects.map((obj) => {
+      const [name, visible, locked] = obj.split("~")
+      return ObjectItemSchema.parse({
+        name,
+        visible: visible === "true",
+        locked: locked === "true",
+      })
+    })
+  ),
+  BBox: BBoxSchema,
+  netColors: z.array(z.unknown()).optional(),
+})
+
+export const PackageDetailSchema = z.object({
+  uuid: z.string(),
+  title: z.string(),
+  docType: z.number(),
+  updateTime: z.number(),
+  owner: OwnerSchema,
+  datastrid: z.string(),
+  writable: z.boolean(),
+  dataStr: PackageDetailDataStrSchema,
+})
+
+export const EasyEdaJsonSchema = z.object({
+  uuid: z.string(),
+  title: z.string(),
+  description: z.string(),
+  docType: z.number(),
+  type: z.number(),
+  szlcsc: SzlcscSchema,
+  lcsc: LcscSchema,
+  owner: OwnerSchema,
+  tags: z.array(z.string()),
+  updateTime: z.number(),
+  updated_at: z.string(),
+  dataStr: DataStrSchema,
+  verify: z.boolean(),
+  SMT: z.boolean(),
+  datastrid: z.string(),
+  jlcOnSale: z.number(),
+  writable: z.boolean(),
+  isFavorite: z.boolean(),
+  packageDetail: PackageDetailSchema,
+})
+
+export type EasyEdaJson = z.infer<typeof EasyEdaJsonSchema>