easyeda 0.0.2

package/lib/schemas/package-detail-shape-schema.ts

@@ -0,0 +1,251 @@
+import { z } from "zod"
+
+export const PointSchema = z
+  .any()
+  .transform((p) => {
+    if (Array.isArray(p)) {
+      const [x, y] = p
+      return { x, y }
+    } else if (typeof p === "object") {
+      return p
+    }
+    throw new Error(`Invalid point: ${p}`)
+  })
+  .pipe(
+    z.object({
+      x: z.number(),
+      y: z.number(),
+    })
+  )
+
+export const BaseShapeSchema = z.object({
+  type: z.string(),
+  id: z.string().optional(),
+  layer: z.coerce.number().optional(),
+})
+
+export const TrackSchema = BaseShapeSchema.extend({
+  type: z.literal("TRACK"),
+  width: z.coerce.number(),
+  points: z.array(PointSchema),
+})
+
+export const PadSchema = BaseShapeSchema.extend({
+  type: z.literal("PAD"),
+  shape: z.enum(["RECT", "ELLIPSE", "OVAL"]),
+  center: z.object({
+    x: z.number(),
+    y: z.number(),
+  }),
+  width: z.number(),
+  height: z.number(),
+  layermask: z.number(),
+  net: z.union([z.string(), z.number()]).optional(),
+  number: z.number(),
+  holeRadius: z.number(),
+  points: z.array(PointSchema).optional(),
+  rotation: z.number().optional(),
+  plated: z.boolean(),
+})
+
+// TODO this should be in "arc sweep" format with the following fields:
+// start, end, radius, largeArc, sweepDirection
+export const ArcSchema = BaseShapeSchema.extend({
+  type: z.literal("ARC"),
+  width: z.number(),
+  start: PointSchema,
+  end: PointSchema,
+  radiusX: z.number(),
+  radiusY: z.number(),
+  largeArc: z.boolean(),
+  sweepDirection: z.enum(["CW", "CCW"]),
+})
+
+export const CircleSchema = BaseShapeSchema.extend({
+  type: z.literal("CIRCLE"),
+  center: PointSchema,
+  radius: z.number(),
+  width: z.number(),
+})
+
+export const SolidRegionSchema = BaseShapeSchema.extend({
+  type: z.literal("SOLIDREGION"),
+  layermask: z.number(),
+  points: z.array(PointSchema),
+  fillStyle: z.string(),
+})
+
+export const SVGNodeSchema = BaseShapeSchema.extend({
+  type: z.literal("SVGNODE"),
+  svgData: z.object({
+    gId: z.string(),
+    nodeName: z.string(),
+    nodeType: z.number(),
+    layerid: z.string(),
+    attrs: z.record(z.string(), z.string()),
+    childNodes: z.array(z.unknown()),
+  }),
+})
+
+// e.g. "HOLE~3999.449~3004.213~1.378~gge152~0"
+export const HoleSchema = BaseShapeSchema.extend({
+  type: z.literal("HOLE"),
+  center: PointSchema,
+  radius: z.number(),
+})
+
+export const PackageDetailShapeSchema = z.discriminatedUnion("type", [
+  TrackSchema,
+  PadSchema,
+  ArcSchema,
+  CircleSchema,
+  SolidRegionSchema,
+  SVGNodeSchema,
+  HoleSchema,
+])
+
+const pairs = <T>(arr: T[]): [T, T][] => {
+  const pairs: [T, T][] = []
+  for (let i = 0; i < arr.length; i += 2) {
+    pairs.push([arr[i], arr[i + 1]])
+  }
+  return pairs
+}
+
+const parsePoints = (pointsStr: string): number[][] =>
+  pairs(
+    pointsStr
+      .trim()
+      .split(" ")
+      .map((n) => Number(n))
+  )
+
+export const ShapeItemSchema = z
+  .object({
+    type: z.string(),
+    data: z.string(),
+  })
+  .transform((shape) => {
+    const [firstParam, ...restParams] = shape.data.split("~")
+    const lastParam = restParams.pop()
+
+    switch (shape.type) {
+      case "TRACK": {
+        const [width, layer, _, pointsStr, id, _n] = shape.data.split("~")
+        const points = parsePoints(pointsStr)
+        return TrackSchema.parse({ type: "TRACK", width, layer, points, id })
+      }
+      case "PAD": {
+        const [padShape, ...params] = shape.data.split("~")
+        const [
+          centerX,
+          centerY,
+          width,
+          height,
+          layermask,
+          net,
+          number,
+          holeRadius,
+          ...rest
+        ] = params.map((p) => (isNaN(Number(p)) ? p : Number(p)))
+        const center = { x: centerX, y: centerY }
+        let points, rotation
+        if (padShape === "RECT") {
+          points = parsePoints(rest[0] as any)
+          rotation = Number(rest[1])
+        }
+        return PadSchema.parse({
+          type: "PAD",
+          shape: padShape,
+          center,
+          width,
+          height,
+          layermask,
+          net,
+          number,
+          holeRadius,
+          points,
+          rotation,
+          plated: rest.includes("Y"),
+        })
+      }
+      case "ARC": {
+        const [width, layer, , arcData] = shape.data.split("~")
+        // A rx ry x-axis-rotation large-arc-flag sweep-flag x  y
+        // A rx ry x-axis-rotation large-arc-flag sweep-flag dx dy
+        const [
+          ,
+          startX,
+          startY,
+          radiusX,
+          radiusY,
+          xAxisRotation,
+          largeArcFlag,
+          sweepFlag,
+          endX,
+          endY,
+        ] = arcData.match(
+          /M ([\d.]+) ([\d.]+) A ([\d.]+) ([\d.]+) ([\d.]+) ([\d.]+) ([\d.]+) ([\d.]+) ([\d.]+)/
+        )!
+        const start: [number, number] = [Number(startX), Number(startY)]
+        const end: [number, number] = [Number(endX), Number(endY)]
+        return ArcSchema.parse({
+          type: "ARC",
+          width: Number(width),
+          layer: Number(layer),
+          start,
+          end,
+          radiusX: Number(radiusX),
+          radiusY: Number(radiusY),
+          largeArc: largeArcFlag === "1",
+          sweepDirection: sweepFlag === "1" ? "CW" : "CCW",
+        })
+      }
+      case "CIRCLE": {
+        const [centerX, centerY, radius, width, layer, id] =
+          shape.data.split("~")
+        const center: [number, number] = [Number(centerX), Number(centerY)]
+        return CircleSchema.parse({
+          type: "CIRCLE",
+          center,
+          radius: Number(radius),
+          width: Number(width),
+          layer: Number(layer),
+          id,
+        })
+      }
+      case "HOLE": {
+        const [centerX, centerY, radius, id] = shape.data.split("~")
+        const center: [number, number] = [Number(centerX), Number(centerY)]
+        return HoleSchema.parse({
+          type: "HOLE",
+          center,
+          radius: Number(radius),
+          id,
+        })
+      }
+      case "SOLIDREGION": {
+        const [layermask, , pathData, fillStyle, id] = shape.data.split("~")
+        const points = pathData
+          .match(/[ML] ?([\d.]+[ ,][\d.]+)/g)!
+          .map((point) => point.slice(2).split(/[ ,]/).map(Number))
+        return SolidRegionSchema.parse({
+          type: "SOLIDREGION",
+          layermask: Number(layermask),
+          points,
+          fillStyle,
+          id,
+        })
+      }
+      case "SVGNODE": {
+        const svgData = JSON.parse(shape.data)
+        return SVGNodeSchema.parse({ type: "SVGNODE", svgData })
+      }
+      default:
+        throw new Error(`Unknown shape type: ${shape.type}`)
+        return BaseShapeSchema.parse({ type: shape.type })
+    }
+  })
+  .pipe(PackageDetailShapeSchema)
+
+export const ShapesArraySchema = z.array(ShapeItemSchema)

package/lib/schemas/single-letter-shape-schema.ts

@@ -0,0 +1,201 @@
+import { z } from "zod"
+
+/**
+ I'll break down the elements in the `dataStr.head.shape` array and explain what they represent. This array contains instructions for drawing the schematic symbol of the component.
+1. `"R~365~275~2~2~70~50~#880000~1~0~none~gge1~0~"`
+   This represents a rectangle:
+   - Starting position: (365, 275)
+   - Width: 70
+   - Height: 50
+   - Color: #880000 (dark red)
+   - Line width: 1
+   - Other parameters are for internal use
+2. `"E~370~280~1.5~1.5~#880000~1~0~#880000~gge2~0"`
+   This draws an ellipse:
+   - Center: (370, 280)
+   - Radius X: 1.5
+   - Radius Y: 1.5
+   - Color: #880000 (dark red)
+   - Line width: 1
+3-10. `"P~show~0~1~355~285~180~gge5~0^^355~285^^M355,285h10~#000000^^1~368.7~289~0~GND~start~~~#000000^^1~364.5~284~0~1~end~~~#000000^^0~362~285^^0~M 365 288 L 368 285 L 365 282"`
+   These represent pins of the component. Each pin has:
+   - Pin number
+   - Position
+   - Orientation
+   - Label (e.g., GND, TRIG, OUT)
+   - Color
+   - Drawing instructions for the pin shape
+To parse this data:
+1. Split the string by `~` to get individual parameters.
+2. For rectangles (R), use parameters 2-7 for position, size, and color.
+3. For ellipses (E), use parameters 2-5 for position and size, and 6 for color.
+4. For pins (P), split further by `^^` to get different sections:
+   - First section: general pin properties
+   - Second section: pin position
+   - Third section: line drawing instruction
+   - Fourth and Fifth sections: label position and text
+   - Sixth section: additional drawing instruction for pin shape
+This data structure allows for a compact representation of the schematic symbol, which can be rendered by CAD software to display the component in circuit diagrams.
+ */
+// Examples
+// "R~365~275~2~2~70~50~#880000~1~0~none~gge1~0~",
+// "E~370~280~1.5~1.5~#880000~1~0~#880000~gge2~0",
+// "P~show~0~1~355~285~180~gge5~0^^355~285^^M355,285h10~#000000^^1~368.7~289~0~GND~start~~~#000000^^1~364.5~284~0~1~end~~~#000000^^0~362~285^^0~M 365 288 L 368 285 L 365 282",
+// "P~show~0~2~355~295~180~gge6~0^^355~295^^M355,295h10~#880000^^1~368.7~299~0~TRIG~start~~~#0000FF^^1~364.5~294~0~2~end~~~#0000FF^^0~362~295^^0~M 365 298 L 368 295 L 365 292",
+// "P~show~0~3~355~305~180~gge7~0^^355~305^^M355,305h10~#880000^^1~368.7~309~0~OUT~start~~~#0000FF^^1~364.5~304~0~3~end~~~#0000FF^^0~362~305^^0~M 365 308 L 368 305 L 365 302",
+// "P~show~0~4~355~315~180~gge8~0^^355~315^^M355,315h10~#880000^^1~368.7~319~0~RESET~start~~~#0000FF^^1~364.5~314~0~4~end~~~#0000FF^^0~362~315^^0~M 365 318 L 368 315 L 365 312",
+// "P~show~0~5~445~315~0~gge9~0^^445~315^^M445,315h-10~#880000^^1~431.3~319~0~CONT~end~~~#0000FF^^1~435.5~314~0~5~start~~~#0000FF^^0~438~315^^0~M 435 312 L 432 315 L 435 318",
+// "P~show~0~6~445~305~0~gge10~0^^445~305^^M445,305h-10~#880000^^1~431.3~309~0~THRES~end~~~#0000FF^^1~435.5~304~0~6~start~~~#0000FF^^0~438~305^^0~M 435 302 L 432 305 L 435 308",
+// "P~show~0~7~445~295~0~gge11~0^^445~295^^M445,295h-10~#880000^^1~431.3~299~0~DISCH~end~~~#0000FF^^1~435.5~294~0~7~start~~~#0000FF^^0~438~295^^0~M 435 292 L 432 295 L 435 298",
+// "P~show~0~8~445~285~0~gge12~0^^445~285^^M445,285h-10~#FF0000^^1~431.3~289~0~VCC~end~~~#FF0000^^1~435.5~284~0~8~start~~~#FF0000^^0~438~285^^0~M 435 282 L 432 285 L 435 288",
+
+const PointSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+})
+
+const RectangleShapeOutputSchema = z.object({
+  type: z.literal("RECTANGLE"),
+  position: PointSchema,
+  width: z.number(),
+  height: z.number(),
+  color: z.string(),
+  lineWidth: z.number(),
+  id: z.string(),
+})
+
+export const RectangleShapeSchema = z
+  .string()
+  .startsWith("R~")
+  .transform((str): z.infer<typeof RectangleShapeOutputSchema> => {
+    const [, x, y, , , width, height, color, lineWidth, , , id] = str.split("~")
+    return {
+      type: "RECTANGLE",
+      position: { x: Number(x), y: Number(y) },
+      width: Number(width),
+      height: Number(height),
+      color,
+      lineWidth: Number(lineWidth),
+      id,
+    }
+  })
+  .pipe(RectangleShapeOutputSchema)
+
+const EllipseShapeOutputSchema = z.object({
+  type: z.literal("ELLIPSE"),
+  center: PointSchema,
+  radiusX: z.number(),
+  radiusY: z.number(),
+  color: z.string(),
+  lineWidth: z.number(),
+  id: z.string(),
+})
+
+export const EllipseShapeSchema = z
+  .string()
+  .startsWith("E~")
+  .transform((str): z.infer<typeof EllipseShapeOutputSchema> => {
+    const [, x, y, radiusX, radiusY, color, lineWidth, , , id] = str.split("~")
+    return {
+      type: "ELLIPSE",
+      center: { x: Number(x), y: Number(y) },
+      radiusX: Number(radiusX),
+      radiusY: Number(radiusY),
+      color,
+      lineWidth: Number(lineWidth),
+      id,
+    }
+  })
+  .pipe(EllipseShapeOutputSchema)
+
+//   type PinDirection = 'left' | 'right';
+
+// interface Pin {
+//   type: 'P';
+//   visibility: string;
+//   id: string;
+//   pin: number;
+//   x: number;
+//   y: number;
+//   rotation: number;
+//   name: string;
+//   color: string;
+//   path: string;
+//   arrow: string;
+//   direction: PinDirection;
+// }
+const PinShapeOutputSchema = z.object({
+  type: z.literal("PIN"),
+  visibility: z.enum(["show", "hide"]),
+  pinNumber: z.number(),
+  x: z.number(),
+  y: z.number(),
+  rotation: z.number(),
+  id: z.string(),
+  label: z.string(),
+  labelColor: z.string(),
+  path: z.string(),
+  arrow: z.string(),
+})
+
+function parsePin(pinString: string): z.infer<typeof PinShapeOutputSchema> {
+  const parts = pinString.split("~")
+  const [_, visibility, __, pinNumber, x, y, rotation, id] = parts
+
+  const nameMatch = pinString.match(/~(\w+)~start~/)
+  const label = nameMatch ? nameMatch[1] : ""
+
+  // TODO: make sure colors are associated properly
+  const colorMatch = pinString.match(/#[0-9A-F]{6}/)
+  const labelColor = colorMatch ? colorMatch[0] : ""
+
+  const pathMatch = pinString.match(/\^\^([^~]+)/)
+  const path = pathMatch ? pathMatch[1] : ""
+
+  const arrowMatch = pinString.match(/\^\^0~(.+)$/)
+  const arrow = arrowMatch ? arrowMatch[1] : ""
+
+  return {
+    type: "PIN",
+    visibility: visibility as "show" | "hide",
+    id,
+    pinNumber: parseInt(pinNumber),
+    x: parseFloat(x),
+    y: parseFloat(y),
+    rotation: parseFloat(rotation),
+    label,
+    labelColor,
+    path,
+    arrow,
+  }
+}
+
+export const PinShapeSchema = z
+  .string()
+  .startsWith("P~")
+  .transform((str): z.infer<typeof PinShapeOutputSchema> => {
+    return parsePin(str)
+  })
+  .pipe(PinShapeOutputSchema)
+
+export const SingleLetterShapeSchema = z
+  .string()
+  .transform((x) => {
+    // We do some discrimination here for better errors
+    if (x.startsWith("R~")) {
+      return RectangleShapeSchema.parse(x)
+    } else if (x.startsWith("E~")) {
+      return EllipseShapeSchema.parse(x)
+    } else if (x.startsWith("P~")) {
+      return PinShapeSchema.parse(x)
+    } else {
+      throw new Error("Invalid shape type: " + x)
+    }
+  })
+  .pipe(
+    z.union([
+      RectangleShapeOutputSchema,
+      EllipseShapeOutputSchema,
+      PinShapeOutputSchema,
+    ])
+  )

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "easyeda",
+  "type": "module",
+  "version": "0.0.2",
+  "scripts": {
+    "test": "bun test",
+    "build": "tsup lib/index.ts cli/main.ts --dts --sourcemap",
+    "aider": "aider"
+  },
+  "main": "./dist/lib/index.cjs",
+  "bin": {
+    "easyeda-converter": "./dist/lib/cli/main.cjs",
+    "easyeda": "./dist/lib/cli/main.cjs"
+  },
+  "devDependencies": {
+    "@tscircuit/builder": "^1.5.131",
+    "@tscircuit/log-soup": "1.0.2",
+    "@tscircuit/soup": "^0.0.37",
+    "@tscircuit/soup-util": "^0.0.11",
+    "@types/bun": "latest",
+    "tsup": "^8.1.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5.5.2"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "transformation-matrix": "^2.16.1",
+    "zod": "^3.23.8"
+  }
+}

package/renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}

package/scripts/get-easyeda-json.ts

@@ -0,0 +1,12 @@
+import { fetchEasyEDAComponent } from "../lib/fetch-easyeda-json"
+import * as fs from "node:fs"
+
+// "C46749" // NE555P - DIP8
+// const partNumber = "C5125085" - SSOP8
+const partNumber = "C95209" // esp32
+
+const outputFile = "./test.json"
+
+const easyEdaJson = await fetchEasyEDAComponent(partNumber)
+
+fs.writeFileSync(outputFile, JSON.stringify(easyEdaJson, null, "  "))