@tscircuit/circuit-json-util 0.0.41

package/dist/index.cjs

@@ -0,0 +1,636 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var soup_util_exports = {};
+__export(soup_util_exports, {
+  applySelector: () => applySelector,
+  applySelectorAST: () => applySelectorAST,
+  directionToVec: () => directionToVec,
+  getBoundsOfPcbElements: () => getBoundsOfPcbElements,
+  getElementById: () => getElementById,
+  getElementId: () => getElementId,
+  getReadableNameForElement: () => getReadableNameForElement,
+  getReadableNameForPcbPort: () => getReadableNameForPcbPort,
+  getReadableNameForPcbSmtpad: () => getReadableNameForPcbSmtpad,
+  getReadableNameForPcbTrace: () => getReadableNameForPcbTrace,
+  oppositeDirection: () => oppositeDirection,
+  oppositeSide: () => oppositeSide,
+  rotateClockwise: () => rotateClockwise,
+  rotateCounterClockwise: () => rotateCounterClockwise,
+  rotateDirection: () => rotateDirection,
+  su: () => su_default,
+  transformPCBElement: () => transformPCBElement,
+  transformPCBElements: () => transformPCBElements,
+  transformSchematicElement: () => transformSchematicElement,
+  transformSchematicElements: () => transformSchematicElements,
+  vecToDirection: () => vecToDirection
+});
+module.exports = __toCommonJS(soup_util_exports);
+
+// lib/su.ts
+var Soup = __toESM(require("@tscircuit/soup"), 1);
+var su = (soup, options = {}) => {
+  let internalStore = soup._internal_store;
+  if (!internalStore) {
+    internalStore = {
+      counts: {}
+    };
+    soup._internal_store = internalStore;
+    for (const elm of soup) {
+      const type = elm.type;
+      const idVal = elm[`${type}_id`];
+      if (!idVal)
+        continue;
+      const idNum = Number.parseInt(idVal.split("_").pop());
+      if (!Number.isNaN(idNum)) {
+        internalStore.counts[type] = Math.max(
+          internalStore.counts[type] ?? 0,
+          idNum
+        );
+      }
+    }
+  }
+  const su2 = new Proxy(
+    {},
+    {
+      get: (proxy_target, component_type) => {
+        if (component_type === "toArray") {
+          return () => soup;
+        }
+        return {
+          get: (id) => soup.find(
+            (e) => e.type === component_type && e[`${component_type}_id`] === id
+          ),
+          getUsing: (using) => {
+            const keys = Object.keys(using);
+            if (keys.length !== 1) {
+              throw new Error(
+                "getUsing requires exactly one key, e.g. { pcb_component_id }"
+              );
+            }
+            const join_key = keys[0];
+            const join_type = join_key.replace("_id", "");
+            const joiner = soup.find(
+              (e) => e.type === join_type && e[join_key] === using[join_key]
+            );
+            if (!joiner)
+              return null;
+            return soup.find(
+              (e) => e.type === component_type && e[`${component_type}_id`] === joiner[`${component_type}_id`]
+            );
+          },
+          getWhere: (where) => {
+            const keys = Object.keys(where);
+            return soup.find(
+              (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
+            );
+          },
+          list: (where) => {
+            const keys = !where ? [] : Object.keys(where);
+            return soup.filter(
+              (e) => e.type === component_type && keys.every((key) => e[key] === where[key])
+            );
+          },
+          insert: (elm) => {
+            internalStore.counts[component_type] ??= -1;
+            internalStore.counts[component_type]++;
+            const index = internalStore.counts[component_type];
+            const newElm = {
+              type: component_type,
+              [`${component_type}_id`]: `${component_type}_${index}`,
+              ...elm
+            };
+            if (options.validateInserts) {
+              const parser = Soup[component_type] ?? Soup.any_soup_element;
+              parser.parse(newElm);
+            }
+            soup.push(newElm);
+            return newElm;
+          },
+          delete: (id) => {
+            const elm = soup.find(
+              (e) => e[`${component_type}_id`] === id
+            );
+            if (!elm)
+              return;
+            soup.splice(soup.indexOf(elm), 1);
+          },
+          update: (id, newProps) => {
+            const elm = soup.find(
+              (e) => e[`${component_type}_id`] === id
+            );
+            if (!elm)
+              return;
+            Object.assign(elm, newProps);
+            return elm;
+          },
+          select: (selector) => {
+            if (component_type === "source_component") {
+              return soup.find(
+                (e) => e.type === "source_component" && e.name === selector.replace(/\./g, "")
+              );
+            } else if (component_type === "pcb_port" || component_type === "source_port" || component_type === "schematic_port") {
+              const [component_name, port_selector] = selector.replace(/\./g, "").split(/[\s\>]+/);
+              const source_component = soup.find(
+                (e) => e.type === "source_component" && e.name === component_name
+              );
+              if (!source_component)
+                return null;
+              const source_port = soup.find(
+                (e) => e.type === "source_port" && e.source_component_id === source_component.source_component_id && (e.name === port_selector || (e.port_hints ?? []).includes(port_selector))
+              );
+              if (!source_port)
+                return null;
+              if (component_type === "source_port")
+                return source_port;
+              if (component_type === "pcb_port") {
+                return soup.find(
+                  (e) => e.type === "pcb_port" && e.source_port_id === source_port.source_port_id
+                );
+              } else if (component_type === "schematic_port") {
+                return soup.find(
+                  (e) => e.type === "schematic_port" && e.source_port_id === source_port.source_port_id
+                );
+              }
+            }
+          }
+        };
+      }
+    }
+  );
+  return su2;
+};
+su.unparsed = su;
+var su_default = su;
+
+// lib/transform-soup-elements.ts
+var import_transformation_matrix = require("transformation-matrix");
+
+// lib/direction-to-vec.ts
+var directionToVec = (direction) => {
+  if (direction === "up")
+    return { x: 0, y: 1 };
+  else if (direction === "down")
+    return { x: 0, y: -1 };
+  else if (direction === "left")
+    return { x: -1, y: 0 };
+  else if (direction === "right")
+    return { x: 1, y: 0 };
+  else
+    throw new Error("Invalid direction");
+};
+var vecToDirection = ({ x, y }) => {
+  if (x > y)
+    y = 0;
+  if (y > x)
+    x = 0;
+  if (x > 0 && y === 0)
+    return "right";
+  else if (x < 0 && y === 0)
+    return "left";
+  else if (x === 0 && y > 0)
+    return "up";
+  else if (x === 0 && y < 0)
+    return "down";
+  else
+    throw new Error(`Invalid vector for direction conversion (${x}, ${y})`);
+};
+var rotateClockwise = (direction) => {
+  if (direction === "up")
+    return "right";
+  else if (direction === "right")
+    return "down";
+  else if (direction === "down")
+    return "left";
+  else if (direction === "left")
+    return "up";
+  throw new Error(`Invalid direction: ${direction}`);
+};
+var rotateCounterClockwise = (direction) => {
+  if (direction === "up")
+    return "left";
+  else if (direction === "left")
+    return "down";
+  else if (direction === "down")
+    return "right";
+  else if (direction === "right")
+    return "up";
+  throw new Error(`Invalid direction: ${direction}`);
+};
+var rotateDirection = (direction, num90DegreeClockwiseTurns) => {
+  while (num90DegreeClockwiseTurns > 0) {
+    direction = rotateClockwise(direction);
+    num90DegreeClockwiseTurns--;
+  }
+  while (num90DegreeClockwiseTurns < 0) {
+    direction = rotateCounterClockwise(direction);
+    num90DegreeClockwiseTurns++;
+  }
+  return direction;
+};
+var oppositeDirection = (direction) => {
+  if (direction === "up")
+    return "down";
+  else if (direction === "down")
+    return "up";
+  else if (direction === "left")
+    return "right";
+  else if (direction === "right")
+    return "left";
+  throw new Error(`Invalid direction: ${direction}`);
+};
+var oppositeSide = (sideOrDir) => {
+  if (sideOrDir === "top" || sideOrDir === "up")
+    return "bottom";
+  else if (sideOrDir === "bottom" || sideOrDir === "down")
+    return "top";
+  else if (sideOrDir === "left")
+    return "right";
+  else if (sideOrDir === "right")
+    return "left";
+  throw new Error(`Invalid sideOrDir: ${sideOrDir}`);
+};
+
+// lib/transform-soup-elements.ts
+var transformSchematicElement = (elm, matrix) => {
+  if (elm.type === "schematic_component") {
+    elm.center = (0, import_transformation_matrix.applyToPoint)(matrix, elm.center);
+  } else if (elm.type === "schematic_port") {
+    elm.center = (0, import_transformation_matrix.applyToPoint)(matrix, elm.center);
+    if (elm.facing_direction) {
+      elm.facing_direction = rotateDirection(
+        elm.facing_direction,
+        -(Math.atan2(matrix.b, matrix.a) / Math.PI) * 2
+      );
+    }
+  } else if (elm.type === "schematic_text") {
+    elm.position = (0, import_transformation_matrix.applyToPoint)(matrix, elm.position);
+  } else if (elm.type === "schematic_trace") {
+  } else if (elm.type === "schematic_box") {
+    const { x, y } = (0, import_transformation_matrix.applyToPoint)(matrix, { x: elm.x, y: elm.y });
+    elm.x = x;
+    elm.y = y;
+  } else if (elm.type === "schematic_line") {
+    const { x: x1, y: y1 } = (0, import_transformation_matrix.applyToPoint)(matrix, { x: elm.x1, y: elm.y1 });
+    const { x: x2, y: y2 } = (0, import_transformation_matrix.applyToPoint)(matrix, { x: elm.x2, y: elm.y2 });
+    elm.x1 = x1;
+    elm.y1 = y1;
+    elm.x2 = x2;
+    elm.y2 = y2;
+  }
+  return elm;
+};
+var transformSchematicElements = (elms, matrix) => {
+  return elms.map((elm) => transformSchematicElement(elm, matrix));
+};
+var transformPCBElement = (elm, matrix) => {
+  if (elm.type === "pcb_plated_hole" || elm.type === "pcb_hole" || elm.type === "pcb_via" || elm.type === "pcb_smtpad" || elm.type === "pcb_port") {
+    const { x, y } = (0, import_transformation_matrix.applyToPoint)(matrix, { x: elm.x, y: elm.y });
+    elm.x = x;
+    elm.y = y;
+  } else if (elm.type === "pcb_keepout" || elm.type === "pcb_board") {
+    elm.center = (0, import_transformation_matrix.applyToPoint)(matrix, elm.center);
+  } else if (elm.type === "pcb_silkscreen_text" || elm.type === "pcb_fabrication_note_text") {
+    elm.anchor_position = (0, import_transformation_matrix.applyToPoint)(matrix, elm.anchor_position);
+  } else if (elm.type === "pcb_silkscreen_circle" || elm.type === "pcb_silkscreen_rect" || elm.type === "pcb_component") {
+    elm.center = (0, import_transformation_matrix.applyToPoint)(matrix, elm.center);
+  } else if (elm.type === "pcb_silkscreen_path" || elm.type === "pcb_trace" || elm.type === "pcb_fabrication_note_path") {
+    elm.route = elm.route.map((rp) => {
+      const tp = (0, import_transformation_matrix.applyToPoint)(matrix, rp);
+      rp.x = tp.x;
+      rp.y = tp.y;
+      return rp;
+    });
+  } else if (elm.type === "pcb_silkscreen_line") {
+    const p1 = { x: elm.x1, y: elm.y1 };
+    const p2 = { x: elm.x2, y: elm.y2 };
+    const p1t = (0, import_transformation_matrix.applyToPoint)(matrix, p1);
+    const p2t = (0, import_transformation_matrix.applyToPoint)(matrix, p2);
+    elm.x1 = p1t.x;
+    elm.y1 = p1t.y;
+    elm.x2 = p2t.x;
+    elm.y2 = p2t.y;
+  } else if (elm.type === "cad_component") {
+    const newPos = (0, import_transformation_matrix.applyToPoint)(matrix, {
+      x: elm.position.x,
+      y: elm.position.y
+    });
+    elm.position.x = newPos.x;
+    elm.position.y = newPos.y;
+  }
+  return elm;
+};
+var transformPCBElements = (elms, matrix) => {
+  const tsr = (0, import_transformation_matrix.decomposeTSR)(matrix);
+  const flipPadWidthHeight = Math.round(tsr.rotation.angle / (Math.PI / 2)) % 2 === 1;
+  let transformedElms = elms.map((elm) => transformPCBElement(elm, matrix));
+  if (flipPadWidthHeight) {
+    transformedElms = transformedElms.map((elm) => {
+      if (elm.type === "pcb_smtpad" && elm.shape === "rect") {
+        ;
+        [elm.width, elm.height] = [elm.height, elm.width];
+      }
+      return elm;
+    });
+  }
+  return transformedElms;
+};
+
+// lib/apply-selector.ts
+var parsel = __toESM(require("parsel-js"), 1);
+
+// lib/convert-abbreviation-to-soup-element-type.ts
+var convertAbbrToType = (abbr) => {
+  switch (abbr) {
+    case "port":
+      return "source_port";
+    case "net":
+      return "source_net";
+    case "power":
+      return "simple_power_source";
+  }
+  return abbr;
+};
+
+// lib/apply-selector.ts
+var filterByType = (elements, type) => {
+  type = convertAbbrToType(type);
+  return elements.filter(
+    (elm) => "ftype" in elm && elm.ftype === type || elm.type === type
+  );
+};
+var applySelector = (elements, selectorRaw) => {
+  const selectorAST = parsel.parse(selectorRaw);
+  return applySelectorAST(elements, selectorAST);
+};
+var doesElmMatchClassName = (elm, className) => "name" in elm && elm.name === className || "port_hints" in elm && elm.port_hints?.includes(className);
+var applySelectorAST = (elements, selectorAST) => {
+  switch (selectorAST.type) {
+    case "complex": {
+      switch (selectorAST.combinator) {
+        case " ":
+        case ">": {
+          const { left, right } = selectorAST;
+          if (left.type === "class" || left.type === "type") {
+            let matchElms;
+            if (left.type === "class") {
+              matchElms = elements.filter(
+                (elm) => doesElmMatchClassName(elm, left.name)
+              );
+            } else if (left.type === "type") {
+              matchElms = filterByType(elements, left.name);
+            } else {
+              matchElms = [];
+            }
+            const childrenOfMatchingElms = matchElms.flatMap(
+              (matchElm) => elements.filter(
+                (elm) => elm[`${matchElm.type}_id`] === matchElm[`${matchElm.type}_id`] && elm !== matchElm
+              )
+            );
+            return applySelectorAST(childrenOfMatchingElms, right);
+          } else {
+            throw new Error(`unsupported selector type "${left.type}" `);
+          }
+        }
+        default: {
+          throw new Error(
+            `Couldn't apply selector AST for complex combinator "${selectorAST.combinator}"`
+          );
+        }
+      }
+      return [];
+    }
+    case "compound": {
+      const conditionsToMatch = selectorAST.list.map((part) => {
+        switch (part.type) {
+          case "class": {
+            return (elm) => doesElmMatchClassName(elm, part.name);
+          }
+          case "type": {
+            const name = convertAbbrToType(part.name);
+            return (elm) => elm.type === name;
+          }
+        }
+      });
+      return elements.filter(
+        (elm) => conditionsToMatch.every((condFn) => condFn?.(elm))
+      );
+    }
+    case "type": {
+      return filterByType(elements, selectorAST.name);
+    }
+    case "class": {
+      return elements.filter(
+        (elm) => doesElmMatchClassName(elm, selectorAST.name)
+      );
+    }
+    default: {
+      throw new Error(
+        `Couldn't apply selector AST for type: "${selectorAST.type}" ${JSON.stringify(selectorAST, null, " ")}`
+      );
+    }
+  }
+};
+
+// lib/get-element-id.ts
+var getElementId = (elm) => {
+  const type = elm.type;
+  const id = elm[`${type}_id`];
+  return id;
+};
+
+// lib/get-element-by-id.ts
+var getElementById = (soup, id) => {
+  return soup.find((elm) => getElementId(elm) === id) ?? null;
+};
+
+// lib/readable-name-functions/get-readable-name-for-pcb-trace.ts
+function getReadableNameForPcbTrace(soup, pcb_trace_id) {
+  const pcbTrace = su(soup).pcb_trace.get(pcb_trace_id);
+  if (!pcbTrace) {
+    return `trace[${pcb_trace_id}]`;
+  }
+  const connectedPcbPortIds = pcbTrace.route.flatMap((point) => [point.start_pcb_port_id, point.end_pcb_port_id]).filter(Boolean);
+  if (connectedPcbPortIds.length === 0) {
+    return `trace[${pcb_trace_id}]`;
+  }
+  function getComponentAndPortInfo(pcb_port_id) {
+    const pcbPort = su(soup).pcb_port.get(pcb_port_id);
+    if (!pcbPort)
+      return null;
+    const pcbComponent = su(soup).pcb_component.get(pcbPort.pcb_component_id);
+    if (!pcbComponent)
+      return null;
+    const sourceComponent = su(soup).source_component.get(
+      pcbComponent.source_component_id
+    );
+    if (!sourceComponent)
+      return null;
+    const sourcePort = su(soup).source_port.get(pcbPort.source_port_id);
+    const portHint = sourcePort?.port_hints ? sourcePort.port_hints[1] : "";
+    return {
+      componentName: sourceComponent.name,
+      portHint
+    };
+  }
+  const selectorParts = connectedPcbPortIds.map((portId) => {
+    const info = getComponentAndPortInfo(portId);
+    if (info) {
+      return `.${info.componentName} > port.${info.portHint}`;
+    }
+    return `port[${portId}]`;
+  });
+  return `trace[${selectorParts.join(", ")}]`;
+}
+
+// lib/readable-name-functions/get-readable-name-for-pcb-port.ts
+var getReadableNameForPcbPort = (soup, pcb_port_id) => {
+  const pcbPort = su(soup).pcb_port.get(pcb_port_id);
+  if (!pcbPort) {
+    return `pcb_port[#${pcb_port_id}]`;
+  }
+  const pcbComponent = su(soup).pcb_component.get(pcbPort?.pcb_component_id);
+  if (!pcbComponent) {
+    return `pcb_port[#${pcb_port_id}]`;
+  }
+  const sourceComponent = su(soup).source_component.get(
+    pcbComponent.source_component_id
+  );
+  if (!sourceComponent) {
+    return `pcb_port[#${pcb_port_id}]`;
+  }
+  const sourcePort = su(soup).source_port.get(pcbPort.source_port_id);
+  if (!sourcePort) {
+    return `pcb_port[#${pcb_port_id}]`;
+  }
+  let padIdentifier;
+  if (sourcePort?.port_hints && sourcePort.port_hints.length > 0) {
+    padIdentifier = sourcePort.port_hints[0];
+  } else if (sourcePort.port_hints && sourcePort.port_hints.length > 0) {
+    padIdentifier = sourcePort.port_hints[0];
+  } else {
+    padIdentifier = pcb_port_id;
+  }
+  return `pcb_port[.${sourceComponent.name} > .${padIdentifier}]`;
+};
+
+// lib/readable-name-functions/get-readable-name-for-pcb-smtpad.ts
+function getReadableNameForPcbSmtpad(soup, pcb_smtpad_id) {
+  const pcbSmtpad = su(soup).pcb_smtpad.get(pcb_smtpad_id);
+  if (!pcbSmtpad || !pcbSmtpad.pcb_port_id) {
+    return `smtpad[${pcb_smtpad_id}]`;
+  }
+  return getReadableNameForPcbPort(soup, pcbSmtpad.pcb_port_id);
+}
+
+// lib/readable-name-functions/get-readable-name-for-element.ts
+var getReadableNameForElement = (soup, elm) => {
+  if (typeof elm === "string") {
+    const elmObj = getElementById(soup, elm);
+    if (!elmObj)
+      `unknown (could not find element with id ${elm})`;
+    return getReadableNameForElement(soup, elmObj);
+  }
+  switch (elm.type) {
+    case "pcb_port":
+      return getReadableNameForPcbPort(soup, elm.pcb_port_id);
+    case "pcb_smtpad":
+      return getReadableNameForPcbSmtpad(soup, elm.pcb_smtpad_id);
+    case "pcb_trace":
+      return getReadableNameForPcbTrace(soup, elm.pcb_trace_id);
+    case "source_component":
+      return `source_component[${elm.name}]`;
+    default:
+      return `${elm.type}[#${getElementId(elm)}]`;
+  }
+};
+
+// lib/get-bounds-of-pcb-elements.ts
+var getBoundsOfPcbElements = (elements) => {
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = Number.NEGATIVE_INFINITY;
+  let maxY = Number.NEGATIVE_INFINITY;
+  for (const elm of elements) {
+    if (!elm.type.startsWith("pcb_"))
+      continue;
+    if ("x" in elm && "y" in elm) {
+      minX = Math.min(minX, elm.x);
+      minY = Math.min(minY, elm.y);
+      maxX = Math.max(maxX, elm.x);
+      maxY = Math.max(maxY, elm.y);
+      if ("width" in elm) {
+        maxX = Math.max(maxX, elm.x + elm.width);
+      }
+      if ("height" in elm) {
+        maxY = Math.max(maxY, elm.y + elm.height);
+      }
+      if ("radius" in elm) {
+        minX = Math.min(minX, elm.x - elm.radius);
+        minY = Math.min(minY, elm.y - elm.radius);
+        maxX = Math.max(maxX, elm.x + elm.radius);
+        maxY = Math.max(maxY, elm.y + elm.radius);
+      }
+    } else if (elm.type === "pcb_trace") {
+      for (const point of elm.route) {
+        minX = Math.min(minX, point.x);
+        minY = Math.min(minY, point.y);
+        maxX = Math.max(maxX, point.x);
+        maxY = Math.max(maxY, point.y);
+      }
+    }
+  }
+  return { minX, minY, maxX, maxY };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applySelector,
+  applySelectorAST,
+  directionToVec,
+  getBoundsOfPcbElements,
+  getElementById,
+  getElementId,
+  getReadableNameForElement,
+  getReadableNameForPcbPort,
+  getReadableNameForPcbSmtpad,
+  getReadableNameForPcbTrace,
+  oppositeDirection,
+  oppositeSide,
+  rotateClockwise,
+  rotateCounterClockwise,
+  rotateDirection,
+  su,
+  transformPCBElement,
+  transformPCBElements,
+  transformSchematicElement,
+  transformSchematicElements,
+  vecToDirection
+});
+//# sourceMappingURL=index.cjs.map