easyeda 0.0.2 → 0.0.3

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

@@ -1,204 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

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

package/lib/math/arc-utils.ts

@@ -1,170 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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>