@tscircuit/checks 0.0.1

package/README.md

@@ -0,0 +1,121 @@
+# @tscircuit/checks
+
+## `checkEachPcbPortConnected(soup: AnySoupElement[]) => PCBTraceError[]`
+
+Returns `pcb_trace_error` if any `source_port` is not connected to a net or it's other
+source ports.
+
+## `checkEachPcbTraceNonOverlapping(soup: AnySoupElement[]) => PCBTraceError[]`
+
+Returns `pcb_trace_error` if any `pcb_trace` is overlapping with another `pcb_trace`
+that is not connected to the same net.
+
+## Implementation Details
+
+> [!NOTE]
+> It can be helpful to look at an [example soup file](./tests/assets/unrouted-soup-example.json)
+
+tscircuit soup JSON array containing elements. For checks involving source ports,
+and pcb traces here are the relevant elements (the types are produced below)
+
+> [!NOTE]
+> For the most up-to-date types, check out [@tscircuit/soup](https://github.com/tscircuit/soup)
+
+```ts
+// You can import these types from the @tscircuit/soup package e.g.
+// import type { PCBPort, PCBTrace, AnySoupElement } from "@tscircuit/soup"
+
+import { z } from "zod"
+import { distance } from "../units"
+
+export const pcb_trace = z.object({
+  type: z.literal("pcb_trace"),
+  source_trace_id: z.string().optional(),
+  pcb_component_id: z.string().optional(),
+  pcb_trace_id: z.string(),
+  route: z.array(
+    z.union([
+      z.object({
+        route_type: z.literal("wire"),
+        x: distance,
+        y: distance,
+        width: distance,
+        start_pcb_port_id: z.string().optional(),
+        end_pcb_port_id: z.string().optional(),
+        layer: z.string(),
+      }),
+      z.object({
+        route_type: z.literal("via"),
+        x: distance,
+        y: distance,
+        from_layer: z.string(),
+        to_layer: z.string(),
+      }),
+    ])
+  ),
+})
+
+export type PCBTraceInput = z.input<typeof pcb_trace>
+export type PCBTrace = z.output<typeof pcb_trace>
+
+import { distance } from "../units"
+import { layer_ref } from "./properties/layer_ref"
+
+export const pcb_port = z
+  .object({
+    type: z.literal("pcb_port"),
+    pcb_port_id: z.string(),
+    source_port_id: z.string(),
+    pcb_component_id: z.string(),
+    x: distance,
+    y: distance,
+    layers: z.array(layer_ref),
+  })
+  .describe("Defines a port on the PCB")
+
+export type PCBPort = z.infer<typeof pcb_port>
+export type PCBPortInput = z.input<typeof pcb_port>
+
+export const source_port = z.object({
+  type: z.literal("source_port"),
+  pin_number: z.number().optional(),
+  port_hints: z.array(z.string()).optional(),
+  name: z.string(),
+  source_port_id: z.string(),
+  source_component_id: z.string(),
+})
+
+export type SourcePort = z.infer<typeof source_port>
+
+export const source_net = z.object({
+  type: z.literal("source_net"),
+  source_net_id: z.string(),
+  name: z.string(),
+  member_source_group_ids: z.array(z.string()),
+  is_power: z.boolean().optional(),
+  is_ground: z.boolean().optional(),
+  is_digital_signal: z.boolean().optional(),
+  is_analog_signal: z.boolean().optional(),
+})
+
+export type SourceNet = z.infer<typeof source_net>
+export type SourceNetInput = z.input<typeof source_net>
+
+import { z } from "zod"
+
+export const pcb_trace_error = z
+  .object({
+    pcb_error_id: z.string(),
+    type: z.literal("pcb_error"),
+    error_type: z.literal("pcb_trace_error"),
+    message: z.string(),
+    pcb_trace_id: z.string(),
+    source_trace_id: z.string(),
+    pcb_component_ids: z.array(z.string()),
+    pcb_port_ids: z.array(z.string()),
+  })
+  .describe("Defines a trace error on the PCB")
+
+export type PCBTraceErrorInput = z.input<typeof pcb_trace_error>
+export type PCBTraceError = z.infer<typeof pcb_trace_error>
+```

package/dist/index.cjs

@@ -0,0 +1,291 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var checks_exports = {};
+__export(checks_exports, {
+  checkEachPcbPortConnected: () => checkEachPcbPortConnected,
+  checkEachPcbTraceNonOverlapping: () => checkEachPcbTraceNonOverlapping
+});
+module.exports = __toCommonJS(checks_exports);
+
+// lib/check-each-pcb-port-connected.ts
+function distance(x1, y1, x2, y2) {
+  return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
+}
+function checkEachPcbPortConnected(soup) {
+  const pcbPorts = soup.filter((item) => item.type === "pcb_port");
+  const pcbTraces = soup.filter((item) => item.type === "pcb_trace");
+  const sourceTraces = soup.filter(
+    (item) => item.type === "source_trace"
+  );
+  const errors = [];
+  pcbTraces.forEach((trace) => {
+    trace.route.forEach((segment, index) => {
+      if (segment.route_type === "wire") {
+        if (!segment.start_pcb_port_id && index === 0) {
+          const startPort = pcbPorts.find(
+            (port) => distance(port.x, port.y, segment.x, segment.y) < 1e-3
+          );
+          if (startPort) {
+            segment.start_pcb_port_id = startPort.pcb_port_id;
+          }
+        }
+        if (!segment.end_pcb_port_id && index === trace.route.length - 1) {
+          const endPort = pcbPorts.find(
+            (port) => distance(port.x, port.y, segment.x, segment.y) < 1e-3
+          );
+          if (endPort) {
+            segment.end_pcb_port_id = endPort.pcb_port_id;
+          }
+        }
+      }
+    });
+  });
+  for (const port of pcbPorts) {
+    const connectedTraces = pcbTraces.filter(
+      (trace) => trace.route.some(
+        (segment) => segment.route_type === "wire" && (segment.start_pcb_port_id === port.pcb_port_id || segment.end_pcb_port_id === port.pcb_port_id)
+      )
+    );
+    if (connectedTraces.length === 0) {
+      const sourceTrace = sourceTraces.find(
+        (trace) => trace.connected_source_port_ids.includes(port.source_port_id)
+      );
+      errors.push({
+        type: "pcb_error",
+        message: `pcb_trace_error: PCB port ${port.pcb_port_id} is not connected by a PCB trace`,
+        source_trace_id: sourceTrace ? sourceTrace.source_trace_id : "",
+        error_type: "pcb_trace_error",
+        pcb_trace_id: "",
+        pcb_error_id: "",
+        // Add appropriate ID generation if necessary
+        pcb_component_ids: [],
+        pcb_port_ids: [port.pcb_port_id]
+      });
+    }
+  }
+  return errors;
+}
+
+// lib/net-manager.ts
+var NetManager = class {
+  networks = /* @__PURE__ */ new Set();
+  setConnected(nodes) {
+    if (nodes.length < 2) return;
+    let targetNetwork = null;
+    for (const network of this.networks) {
+      for (const node of nodes) {
+        if (network.has(node)) {
+          if (targetNetwork === null) {
+            targetNetwork = network;
+          } else if (targetNetwork !== network) {
+            for (const mergeNode of network) {
+              targetNetwork.add(mergeNode);
+            }
+            this.networks.delete(network);
+          }
+          break;
+        }
+      }
+      if (targetNetwork !== null && targetNetwork !== network) break;
+    }
+    if (targetNetwork === null) {
+      targetNetwork = new Set(nodes);
+      this.networks.add(targetNetwork);
+    } else {
+      for (const node of nodes) {
+        targetNetwork.add(node);
+      }
+    }
+  }
+  isConnected(nodes) {
+    if (nodes.length < 2) return true;
+    for (const network of this.networks) {
+      if (nodes.every((node) => network.has(node))) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// lib/check-each-pcb-trace-non-overlapping.ts
+function lineIntersects(x1, y1, x2, y2, x3, y3, x4, y4) {
+  const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+  if (denom === 0) return false;
+  const ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denom;
+  const ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denom;
+  return ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1;
+}
+function tracesOverlap(trace1, trace2) {
+  for (let i = 0; i < trace1.route.length - 1; i++) {
+    for (let j = 0; j < trace2.route.length - 1; j++) {
+      const seg1 = trace1.route[i];
+      const seg2 = trace1.route[i + 1];
+      const seg3 = trace2.route[j];
+      const seg4 = trace2.route[j + 1];
+      if (seg1.route_type === "wire" && seg2.route_type === "wire" && seg3.route_type === "wire" && seg4.route_type === "wire" && seg1.layer === seg3.layer && lineIntersects(
+        seg1.x,
+        seg1.y,
+        seg2.x,
+        seg2.y,
+        seg3.x,
+        seg3.y,
+        seg4.x,
+        seg4.y
+      )) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function traceOverlapsWithPad(trace, pad) {
+  for (let i = 0; i < trace.route.length - 1; i++) {
+    const seg1 = trace.route[i];
+    const seg2 = trace.route[i + 1];
+    if (seg1.route_type === "wire" && seg2.route_type === "wire" && seg1.layer === pad.layer && pad.shape === "rect") {
+      const padLeft = pad.x - pad.width / 2;
+      const padRight = pad.x + pad.width / 2;
+      const padTop = pad.y - pad.height / 2;
+      const padBottom = pad.y + pad.height / 2;
+      if (lineIntersects(
+        seg1.x,
+        seg1.y,
+        seg2.x,
+        seg2.y,
+        padLeft,
+        padTop,
+        padRight,
+        padTop
+      ) || lineIntersects(
+        seg1.x,
+        seg1.y,
+        seg2.x,
+        seg2.y,
+        padRight,
+        padTop,
+        padRight,
+        padBottom
+      ) || lineIntersects(
+        seg1.x,
+        seg1.y,
+        seg2.x,
+        seg2.y,
+        padRight,
+        padBottom,
+        padLeft,
+        padBottom
+      ) || lineIntersects(
+        seg1.x,
+        seg1.y,
+        seg2.x,
+        seg2.y,
+        padLeft,
+        padBottom,
+        padLeft,
+        padTop
+      )) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function getPortIdsConnectedToTrace(trace) {
+  const connectedPorts = /* @__PURE__ */ new Set();
+  for (const segment of trace.route) {
+    if (segment.route_type === "wire") {
+      if (segment.start_pcb_port_id)
+        connectedPorts.add(segment.start_pcb_port_id);
+      if (segment.end_pcb_port_id) connectedPorts.add(segment.end_pcb_port_id);
+    }
+  }
+  return Array.from(connectedPorts);
+}
+function getPortIdsConnectedToTraces(...traces) {
+  const connectedPorts = /* @__PURE__ */ new Set();
+  for (const trace of traces) {
+    getPortIdsConnectedToTrace(trace).forEach(
+      (portId) => connectedPorts.add(portId)
+    );
+  }
+  return Array.from(connectedPorts);
+}
+function checkEachPcbTraceNonOverlapping(soup) {
+  const pcbTraces = soup.filter(
+    (item) => item.type === "pcb_trace"
+  );
+  const pcbSMTPads = soup.filter(
+    (item) => item.type === "pcb_smtpad"
+  );
+  const errors = [];
+  const netManager = new NetManager();
+  pcbTraces.forEach(
+    (trace) => netManager.setConnected(getPortIdsConnectedToTrace(trace))
+  );
+  for (let i = 0; i < pcbTraces.length; i++) {
+    for (let j = i + 1; j < pcbTraces.length; j++) {
+      if (netManager.isConnected(
+        getPortIdsConnectedToTraces(pcbTraces[i], pcbTraces[j])
+      )) {
+        continue;
+      }
+      if (tracesOverlap(pcbTraces[i], pcbTraces[j])) {
+        errors.push({
+          type: "pcb_error",
+          error_type: "pcb_trace_error",
+          message: `PCB trace ${pcbTraces[i].pcb_trace_id} overlaps with ${pcbTraces[j].pcb_trace_id}`,
+          pcb_trace_id: pcbTraces[i].pcb_trace_id,
+          source_trace_id: "",
+          pcb_error_id: `overlap_${pcbTraces[i].pcb_trace_id}_${pcbTraces[j].pcb_trace_id}`,
+          pcb_component_ids: [],
+          pcb_port_ids: getPortIdsConnectedToTraces(pcbTraces[i], pcbTraces[j])
+        });
+      }
+    }
+    for (const pad of pcbSMTPads) {
+      if (pad.pcb_port_id && netManager.isConnected(
+        getPortIdsConnectedToTrace(pcbTraces[i]).concat([pad.pcb_port_id])
+      )) {
+        continue;
+      }
+      if (traceOverlapsWithPad(pcbTraces[i], pad)) {
+        errors.push({
+          type: "pcb_error",
+          error_type: "pcb_trace_error",
+          message: `PCB trace ${pcbTraces[i].pcb_trace_id} overlaps with pcb_smtpad ${pad.pcb_smtpad_id}`,
+          pcb_trace_id: pcbTraces[i].pcb_trace_id,
+          source_trace_id: "",
+          pcb_error_id: `overlap_${pcbTraces[i].pcb_trace_id}_${pad.pcb_smtpad_id}`,
+          pcb_component_ids: [],
+          pcb_port_ids: getPortIdsConnectedToTrace(pcbTraces[i])
+        });
+      }
+    }
+  }
+  return errors;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkEachPcbPortConnected,
+  checkEachPcbTraceNonOverlapping
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../index.ts","../lib/check-each-pcb-port-connected.ts","../lib/net-manager.ts","../lib/check-each-pcb-trace-non-overlapping.ts"],"sourcesContent":["export { checkEachPcbPortConnected } from \"./lib/check-each-pcb-port-connected\"\nexport { checkEachPcbTraceNonOverlapping } from \"./lib/check-each-pcb-trace-non-overlapping\"\n","import type {\n  PCBPort,\n  PCBTrace,\n  SourceTrace,\n  AnySoupElement,\n  PCBTraceError,\n} from \"@tscircuit/soup\"\n\nfunction distance(x1: number, y1: number, x2: number, y2: number): number {\n  return Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2))\n}\n\nfunction checkEachPcbPortConnected(soup: AnySoupElement[]): PCBTraceError[] {\n  const pcbPorts: PCBPort[] = soup.filter((item) => item.type === \"pcb_port\")\n  const pcbTraces: PCBTrace[] = soup.filter((item) => item.type === \"pcb_trace\")\n  const sourceTraces: SourceTrace[] = soup.filter(\n    (item) => item.type === \"source_trace\"\n  )\n  const errors: PCBTraceError[] = []\n\n  // Add start_pcb_port_id and end_pcb_port_id if not present\n  pcbTraces.forEach((trace) => {\n    trace.route.forEach((segment, index) => {\n      if (segment.route_type === \"wire\") {\n        if (!segment.start_pcb_port_id && index === 0) {\n          const startPort = pcbPorts.find(\n            (port) =>\n              distance(port.x, port.y, segment.x, segment.y) < 0.001\n          )\n          if (startPort) {\n            segment.start_pcb_port_id = startPort.pcb_port_id\n          }\n        }\n        if (!segment.end_pcb_port_id && index === trace.route.length - 1) {\n          const endPort = pcbPorts.find(\n            (port) =>\n              distance(port.x, port.y, segment.x, segment.y) < 0.001\n          )\n          if (endPort) {\n            segment.end_pcb_port_id = endPort.pcb_port_id\n          }\n        }\n      }\n    })\n  })\n\n  for (const port of pcbPorts) {\n    const connectedTraces = pcbTraces.filter((trace) =>\n      trace.route.some(\n        (segment) =>\n          segment.route_type === \"wire\" &&\n          (segment.start_pcb_port_id === port.pcb_port_id ||\n            segment.end_pcb_port_id === port.pcb_port_id)\n      )\n    )\n\n    if (connectedTraces.length === 0) {\n      const sourceTrace = sourceTraces.find((trace) =>\n        trace.connected_source_port_ids.includes(port.source_port_id)\n      )\n\n      errors.push({\n        type: \"pcb_error\",\n        message: `pcb_trace_error: PCB port ${port.pcb_port_id} is not connected by a PCB trace`,\n        source_trace_id: sourceTrace ? sourceTrace.source_trace_id : \"\",\n        error_type: \"pcb_trace_error\",\n        pcb_trace_id: \"\",\n        pcb_error_id: \"\", // Add appropriate ID generation if necessary\n        pcb_component_ids: [],\n        pcb_port_ids: [port.pcb_port_id],\n      })\n    }\n  }\n\n  return errors\n}\n\nexport { checkEachPcbPortConnected }\n","export class NetManager {\n  private networks: Set<Set<string>> = new Set()\n\n  setConnected(nodes: string[]): void {\n    if (nodes.length < 2) return\n\n    let targetNetwork: Set<string> | null = null\n\n    // Check if any of the nodes are already in a network\n    for (const network of this.networks) {\n      for (const node of nodes) {\n        if (network.has(node)) {\n          if (targetNetwork === null) {\n            targetNetwork = network\n          } else if (targetNetwork !== network) {\n            // Merge networks\n            for (const mergeNode of network) {\n              targetNetwork.add(mergeNode)\n            }\n            this.networks.delete(network)\n          }\n          break\n        }\n      }\n      if (targetNetwork !== null && targetNetwork !== network) break\n    }\n\n    // If no existing network found, create a new one\n    if (targetNetwork === null) {\n      targetNetwork = new Set(nodes)\n      this.networks.add(targetNetwork)\n    } else {\n      // Add all nodes to the target network\n      for (const node of nodes) {\n        targetNetwork.add(node)\n      }\n    }\n  }\n\n  isConnected(nodes: string[]): boolean {\n    if (nodes.length < 2) return true\n\n    for (const network of this.networks) {\n      if (nodes.every((node) => network.has(node))) {\n        return true\n      }\n    }\n\n    return false\n  }\n}\n","import type {\n  PCBTrace,\n  PCBSMTPad,\n  AnySoupElement,\n  PCBTraceError,\n} from \"@tscircuit/soup\"\nimport { NetManager } from \"./net-manager\"\n\n/**\n * Checks if lines given by (x1, y1) and (x2, y2) intersect with line\n * given by (x3, y3) and (x4, y4)\n */\nfunction lineIntersects(\n  x1: number,\n  y1: number,\n  x2: number,\n  y2: number,\n  x3: number,\n  y3: number,\n  x4: number,\n  y4: number\n): boolean {\n  const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1)\n  if (denom === 0) return false // parallel lines\n\n  const ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denom\n  const ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denom\n\n  return ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1\n}\n\nfunction tracesOverlap(trace1: PCBTrace, trace2: PCBTrace): boolean {\n  for (let i = 0; i < trace1.route.length - 1; i++) {\n    for (let j = 0; j < trace2.route.length - 1; j++) {\n      const seg1 = trace1.route[i]\n      const seg2 = trace1.route[i + 1]\n      const seg3 = trace2.route[j]\n      const seg4 = trace2.route[j + 1]\n\n      if (\n        seg1.route_type === \"wire\" &&\n        seg2.route_type === \"wire\" &&\n        seg3.route_type === \"wire\" &&\n        seg4.route_type === \"wire\" &&\n        seg1.layer === seg3.layer &&\n        lineIntersects(\n          seg1.x,\n          seg1.y,\n          seg2.x,\n          seg2.y,\n          seg3.x,\n          seg3.y,\n          seg4.x,\n          seg4.y\n        )\n      ) {\n        return true\n      }\n    }\n  }\n  return false\n}\n\nfunction traceOverlapsWithPad(trace: PCBTrace, pad: PCBSMTPad): boolean {\n  for (let i = 0; i < trace.route.length - 1; i++) {\n    const seg1 = trace.route[i]\n    const seg2 = trace.route[i + 1]\n\n    if (\n      seg1.route_type === \"wire\" &&\n      seg2.route_type === \"wire\" &&\n      seg1.layer === pad.layer &&\n      pad.shape === \"rect\"\n    ) {\n      const padLeft = pad.x - pad.width / 2\n      const padRight = pad.x + pad.width / 2\n      const padTop = pad.y - pad.height / 2\n      const padBottom = pad.y + pad.height / 2\n\n      if (\n        lineIntersects(\n          seg1.x,\n          seg1.y,\n          seg2.x,\n          seg2.y,\n          padLeft,\n          padTop,\n          padRight,\n          padTop\n        ) ||\n        lineIntersects(\n          seg1.x,\n          seg1.y,\n          seg2.x,\n          seg2.y,\n          padRight,\n          padTop,\n          padRight,\n          padBottom\n        ) ||\n        lineIntersects(\n          seg1.x,\n          seg1.y,\n          seg2.x,\n          seg2.y,\n          padRight,\n          padBottom,\n          padLeft,\n          padBottom\n        ) ||\n        lineIntersects(\n          seg1.x,\n          seg1.y,\n          seg2.x,\n          seg2.y,\n          padLeft,\n          padBottom,\n          padLeft,\n          padTop\n        )\n      ) {\n        return true\n      }\n    }\n  }\n  return false\n}\n\nfunction getPortIdsConnectedToTrace(trace: PCBTrace) {\n  const connectedPorts = new Set<string>()\n  for (const segment of trace.route) {\n    if (segment.route_type === \"wire\") {\n      if (segment.start_pcb_port_id)\n        connectedPorts.add(segment.start_pcb_port_id)\n      if (segment.end_pcb_port_id) connectedPorts.add(segment.end_pcb_port_id)\n    }\n  }\n  return Array.from(connectedPorts)\n}\n\nfunction getPortIdsConnectedToTraces(...traces: PCBTrace[]) {\n  const connectedPorts = new Set<string>()\n  for (const trace of traces) {\n    getPortIdsConnectedToTrace(trace).forEach((portId) =>\n      connectedPorts.add(portId)\n    )\n  }\n  return Array.from(connectedPorts)\n}\n\nfunction checkEachPcbTraceNonOverlapping(\n  soup: AnySoupElement[]\n): PCBTraceError[] {\n  const pcbTraces: PCBTrace[] = soup.filter(\n    (item): item is PCBTrace => item.type === \"pcb_trace\"\n  )\n  const pcbSMTPads: PCBSMTPad[] = soup.filter(\n    (item): item is PCBSMTPad => item.type === \"pcb_smtpad\"\n  )\n  const errors: PCBTraceError[] = []\n  const netManager = new NetManager()\n\n  // TODO use source port ids instead of port ids, parse source ports for connections\n  pcbTraces.forEach((trace) =>\n    netManager.setConnected(getPortIdsConnectedToTrace(trace))\n  )\n\n  for (let i = 0; i < pcbTraces.length; i++) {\n    for (let j = i + 1; j < pcbTraces.length; j++) {\n      if (\n        netManager.isConnected(\n          getPortIdsConnectedToTraces(pcbTraces[i], pcbTraces[j])\n        )\n      ) {\n        continue\n      }\n      if (tracesOverlap(pcbTraces[i], pcbTraces[j])) {\n        errors.push({\n          type: \"pcb_error\",\n          error_type: \"pcb_trace_error\",\n          message: `PCB trace ${pcbTraces[i].pcb_trace_id} overlaps with ${pcbTraces[j].pcb_trace_id}`,\n          pcb_trace_id: pcbTraces[i].pcb_trace_id,\n          source_trace_id: \"\",\n          pcb_error_id: `overlap_${pcbTraces[i].pcb_trace_id}_${pcbTraces[j].pcb_trace_id}`,\n          pcb_component_ids: [],\n          pcb_port_ids: getPortIdsConnectedToTraces(pcbTraces[i], pcbTraces[j]),\n        })\n      }\n    }\n\n    for (const pad of pcbSMTPads) {\n      if (\n        pad.pcb_port_id &&\n        netManager.isConnected(\n          getPortIdsConnectedToTrace(pcbTraces[i]).concat([pad.pcb_port_id])\n        )\n      ) {\n        continue\n      }\n      if (traceOverlapsWithPad(pcbTraces[i], pad)) {\n        errors.push({\n          type: \"pcb_error\",\n          error_type: \"pcb_trace_error\",\n          message: `PCB trace ${pcbTraces[i].pcb_trace_id} overlaps with pcb_smtpad ${pad.pcb_smtpad_id}`,\n          pcb_trace_id: pcbTraces[i].pcb_trace_id,\n          source_trace_id: \"\",\n          pcb_error_id: `overlap_${pcbTraces[i].pcb_trace_id}_${pad.pcb_smtpad_id}`,\n          pcb_component_ids: [],\n          pcb_port_ids: getPortIdsConnectedToTrace(pcbTraces[i]),\n        })\n      }\n    }\n  }\n\n  return errors\n}\n\nexport { checkEachPcbTraceNonOverlapping }\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,7 @@
+import { AnySoupElement, PCBTraceError } from '@tscircuit/soup';
+
+declare function checkEachPcbPortConnected(soup: AnySoupElement[]): PCBTraceError[];
+
+declare function checkEachPcbTraceNonOverlapping(soup: AnySoupElement[]): PCBTraceError[];
+
+export { checkEachPcbPortConnected, checkEachPcbTraceNonOverlapping };

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@tscircuit/checks",
+  "module": "index.ts",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "version": "0.0.1",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup index.ts --dts --sourcemap"
+  },
+  "devDependencies": {
+    "@tscircuit/log-soup": "^1.0.2",
+    "@tscircuit/soup": "^0.0.40",
+    "@tscircuit/soup-util": "^0.0.13",
+    "@types/bun": "latest",
+    "tsup": "^8.2.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5.5.3"
+  }
+}