@tscircuit/cli 0.1.1434 → 0.1.1435

package/dist/cli/main.js

@@ -100688,7 +100688,7 @@ var import_perfect_cli = __toESM2(require_dist2(), 1);
 // lib/getVersion.ts
 import { createRequire as createRequire2 } from "node:module";
 // package.json
-var version = "0.1.1432";
+var version = "0.1.1434";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -100702,7 +100702,7 @@ var package_default = {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#700017d79a608295cc275dcb9c2e1d160809ef9e",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#40f49bb8ae9dabedb19b47ec0a621c713b40615c",
     "@tscircuit/eval": "^0.0.835",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",
@@ -244585,6 +244585,7 @@ var addAttr = (attrs, key, value, options) => {
 
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/CapacitorOrientationSolver/CapacitorOrientationSolver.ts
 class CapacitorOrientationSolver extends BaseSolver6 {
+  static ORIENTATION_MESSAGE = 'Use schOrientation="vertical" on this capacitor to fix the symbol orientation';
   ctx;
   out;
   schematicComponentById;
@@ -244681,7 +244682,8 @@ class CapacitorOrientationSolver extends BaseSolver6 {
       return;
     return {
       lineItemType: "CapacitorSymbolHorizontal",
-      schematicBox: this.createIssuePlacement(placement)
+      schematicBox: this.createIssuePlacement(placement),
+      message: CapacitorOrientationSolver.ORIENTATION_MESSAGE
     };
   }
   static issueToString(issue) {
@@ -244691,6 +244693,7 @@ class CapacitorOrientationSolver extends BaseSolver6 {
     addAttr(attrs, "schY", issue.schematicBox.schY);
     addAttr(attrs, "width", issue.schematicBox.width);
     addAttr(attrs, "height", issue.schematicBox.height);
+    addAttr(attrs, "message", issue.message, { escape: false });
     return `<CapacitorSymbolHorizontal ${attrs.join(" ")} />`;
   }
 }
@@ -244835,6 +244838,8 @@ class SchematicBoxInnerLabelCollisionSolver extends BaseSolver9 {
     this.placementById = this.getPlacementBySchematicComponentId(componentPlacements);
     this.sourcePortById = this.getSourcePortById(circuitJson);
     this.entries = Array.from(this.getPortsBySchematicComponentId(circuitJson));
+    const passiveComponentIds = new Set(circuitJson.filter((el3) => el3.type === "schematic_component").filter((el3) => el3.symbol_name).map((el3) => el3.schematic_component_id));
+    this.entries = this.entries.filter(([id2]) => !passiveComponentIds.has(id2));
     this.solved = this.entries.length === 0;
   }
   _step() {
@@ -245676,6 +245681,349 @@ class DiodeResistorAlignmentSolver extends BaseSolver13 {
   }
 }
 
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
+import { BaseSolver as BaseSolver14 } from "@tscircuit/solver-utils";
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/utils/geometry.ts
+function centeredRect(cx2, cy2, w4, h4) {
+  return {
+    left: cx2 - w4 / 2,
+    right: cx2 + w4 / 2,
+    top: cy2 + h4 / 2,
+    bottom: cy2 - h4 / 2
+  };
+}
+function rectOverlap(a2, b) {
+  const ow = Math.min(a2.right, b.right) - Math.max(a2.left, b.left);
+  const oh2 = Math.min(a2.top, b.top) - Math.max(a2.bottom, b.bottom);
+  return ow > 0 && oh2 > 0 ? { ow, oh: oh2 } : null;
+}
+
+// node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/ComponentNetLabelCollisionSolver/ComponentNetLabelCollisionSolver.ts
+class ComponentNetLabelCollisionSolver extends BaseSolver14 {
+  params;
+  LABEL_HALF_HEIGHT = 0.1;
+  LABEL_BOUNDS_SLACK = 0.1;
+  SCH_CHAR_WIDTH = 0.13;
+  placements;
+  netLabelsByComponentId;
+  rawCollisions = [];
+  firstIndex = 0;
+  secondIndex = 1;
+  constructor(params2) {
+    super();
+    this.params = params2;
+    this.placements = params2.ctx.componentPlacements;
+    this.netLabelsByComponentId = this.buildNetLabelsByComponentId(params2.ctx.circuitJson);
+    this.solved = this.placements.length < 2;
+  }
+  _step() {
+    if (this.firstIndex >= this.placements.length - 1) {
+      this.buildAndPushIssues();
+      this.solved = true;
+      return;
+    }
+    const compA = this.placements[this.firstIndex];
+    const compB = this.placements[this.secondIndex];
+    this.detectPair(compA, compB);
+    this.secondIndex++;
+    if (this.secondIndex >= this.placements.length) {
+      this.firstIndex++;
+      this.secondIndex = this.firstIndex + 1;
+    }
+  }
+  detectPair(compA, compB) {
+    this.rawCollisions.push(...this.detectLabelLabel(compA, compB));
+    this.rawCollisions.push(...this.detectBoxLabel(compA, compB));
+    this.rawCollisions.push(...this.detectBoxLabel(compB, compA));
+  }
+  detectLabelLabel(firstComponent, secondComponent) {
+    let leftComp = firstComponent;
+    let rightComp = secondComponent;
+    if (firstComponent.schX > secondComponent.schX) {
+      leftComp = secondComponent;
+      rightComp = firstComponent;
+    }
+    const leftId = leftComp.schematicComponentId;
+    const rightId = rightComp.schematicComponentId;
+    if (!leftId || !rightId)
+      return [];
+    const leftLabels = this.netLabelsByComponentId.get(leftId) ?? [];
+    const rightLabels = this.netLabelsByComponentId.get(rightId) ?? [];
+    if (leftLabels.length === 0 || rightLabels.length === 0)
+      return [];
+    const hits = [];
+    for (const leftLabel of leftLabels) {
+      for (const rightLabel of rightLabels) {
+        const leftBounds = this.getNetLabelBounds(leftLabel);
+        const rightBounds = this.getNetLabelBounds(rightLabel);
+        if (rectOverlap(leftBounds, rightBounds)) {
+          hits.push({
+            type: "label-label",
+            leftComp,
+            rightComp,
+            leftId,
+            rightId,
+            xSeparation: leftBounds.right - rightBounds.left + 0.1
+          });
+        }
+      }
+    }
+    return hits;
+  }
+  detectBoxLabel(boxComp, labelComp) {
+    const boxId = boxComp.schematicComponentId;
+    const labelId = labelComp.schematicComponentId;
+    if (!boxId || !labelId)
+      return [];
+    const labels = this.netLabelsByComponentId.get(labelId) ?? [];
+    if (labels.length === 0)
+      return [];
+    const boxBounds = centeredRect(boxComp.schX, boxComp.schY, boxComp.width, boxComp.height);
+    const boxIsLeft = boxComp.schX <= labelComp.schX;
+    const hits = [];
+    for (const label of labels) {
+      const labelBounds = this.getNetLabelBounds(label);
+      if (!rectOverlap(boxBounds, labelBounds))
+        continue;
+      let xSeparation;
+      if (boxIsLeft) {
+        xSeparation = boxBounds.right - labelBounds.left + 0.1;
+      } else {
+        xSeparation = labelBounds.right - boxBounds.left + 0.1;
+      }
+      hits.push({
+        type: "box-label",
+        boxComp,
+        labelComp,
+        boxId,
+        labelId,
+        xSeparation
+      });
+    }
+    return hits;
+  }
+  buildAndPushIssues() {
+    if (this.rawCollisions.length === 0)
+      return;
+    const globalFixes = this.computeGlobalFixes();
+    if (globalFixes.size === 0)
+      return;
+    const seenPairs = new Set;
+    const pairs3 = [];
+    for (const collision of this.rawCollisions) {
+      let comp1Name;
+      let comp2Name;
+      if (collision.type === "label-label") {
+        comp1Name = collision.leftComp.sourceComponentName ?? "";
+        comp2Name = collision.rightComp.sourceComponentName ?? "";
+      } else {
+        comp1Name = collision.boxComp.sourceComponentName ?? "";
+        comp2Name = collision.labelComp.sourceComponentName ?? "";
+      }
+      const key = `${comp1Name}/${comp2Name}`;
+      if (!seenPairs.has(key)) {
+        seenPairs.add(key);
+        pairs3.push({ comp1Name, comp2Name });
+      }
+    }
+    this.params.issues.push({
+      lineItemType: "NetLabelCollision",
+      pairs: pairs3,
+      moves: Array.from(globalFixes.values())
+    });
+  }
+  computeGlobalFixes() {
+    const compById = new Map;
+    for (const placement of this.placements) {
+      if (placement.schematicComponentId)
+        compById.set(placement.schematicComponentId, placement);
+    }
+    const constraintMap = new Map;
+    const addConstraint = (leftId, rightId, xSeparation) => {
+      const leftComp = compById.get(leftId);
+      const rightComp = compById.get(rightId);
+      if (!leftComp || !rightComp)
+        return;
+      const minSep = rightComp.schX - leftComp.schX + xSeparation;
+      const key = `${leftId}|${rightId}`;
+      constraintMap.set(key, Math.max(constraintMap.get(key) ?? 0, minSep));
+    };
+    for (const collision of this.rawCollisions) {
+      if (collision.type === "label-label") {
+        addConstraint(collision.leftId, collision.rightId, collision.xSeparation);
+      } else if (collision.boxComp.schX <= collision.labelComp.schX) {
+        addConstraint(collision.boxId, collision.labelId, collision.xSeparation);
+      } else {
+        addConstraint(collision.labelId, collision.boxId, collision.xSeparation);
+      }
+    }
+    const constraints = [...constraintMap.entries()].map(([key, minSep]) => {
+      const pipeIndex = key.indexOf("|");
+      return {
+        leftId: key.slice(0, pipeIndex),
+        rightId: key.slice(pipeIndex + 1),
+        minSep
+      };
+    });
+    const allIds = new Set;
+    const adjacency = new Map;
+    for (const { leftId, rightId } of constraints) {
+      allIds.add(leftId);
+      allIds.add(rightId);
+      if (!adjacency.has(leftId))
+        adjacency.set(leftId, new Set);
+      if (!adjacency.has(rightId))
+        adjacency.set(rightId, new Set);
+      adjacency.get(leftId).add(rightId);
+      adjacency.get(rightId).add(leftId);
+    }
+    const visited = new Set;
+    const result = new Map;
+    for (const startId of allIds) {
+      if (visited.has(startId))
+        continue;
+      const group = [];
+      const queue = [startId];
+      visited.add(startId);
+      while (queue.length) {
+        const compId = queue.shift();
+        group.push(compId);
+        for (const neighbor of adjacency.get(compId) ?? []) {
+          if (!visited.has(neighbor)) {
+            visited.add(neighbor);
+            queue.push(neighbor);
+          }
+        }
+      }
+      group.sort((idA, idB) => (compById.get(idA)?.schX ?? 0) - (compById.get(idB)?.schX ?? 0));
+      const groupIds = new Set(group);
+      const groupConstraints = constraints.filter((c3) => groupIds.has(c3.leftId) && groupIds.has(c3.rightId));
+      const assigned = new Map;
+      for (const compId of group) {
+        let newX = compById.get(compId)?.schX ?? 0;
+        for (const { leftId, rightId, minSep } of groupConstraints) {
+          if (rightId === compId && assigned.has(leftId)) {
+            newX = Math.max(newX, assigned.get(leftId) + minSep);
+          }
+        }
+        assigned.set(compId, newX);
+      }
+      const totalPush = [...assigned.entries()].reduce((sum, [compId, newX]) => sum + (newX - (compById.get(compId)?.schX ?? 0)), 0);
+      if (totalPush > 0.000000001) {
+        const pullBack = totalPush / group.length;
+        const shifted = new Map;
+        for (const compId of group) {
+          let newX = (compById.get(compId)?.schX ?? 0) - pullBack;
+          for (const { leftId, rightId, minSep } of groupConstraints) {
+            if (rightId === compId && shifted.has(leftId)) {
+              newX = Math.max(newX, shifted.get(leftId) + minSep);
+            }
+          }
+          shifted.set(compId, newX);
+        }
+        const maxDisplacement = (positions) => [...positions.entries()].reduce((currentMax, [compId, newX]) => Math.max(currentMax, Math.abs(newX - (compById.get(compId)?.schX ?? 0))), 0);
+        if (maxDisplacement(shifted) < maxDisplacement(assigned)) {
+          for (const [compId, newX] of shifted)
+            assigned.set(compId, newX);
+        }
+      }
+      for (const [compId, newX] of assigned) {
+        const comp = compById.get(compId);
+        if (!comp || Math.abs(newX - comp.schX) < 0.000000001)
+          continue;
+        result.set(compId, {
+          componentName: comp.sourceComponentName ?? compId,
+          newSchX: Math.round(newX * 100) / 100,
+          newSchY: Math.round(comp.schY * 100) / 100
+        });
+      }
+    }
+    return result;
+  }
+  buildNetLabelsByComponentId(circuitJson) {
+    const MATCH_EPSILON = 0.0001;
+    const portPositions = [];
+    for (const element of circuitJson) {
+      if (element.type !== "schematic_port")
+        continue;
+      const port = element;
+      if (!port.schematic_component_id)
+        continue;
+      portPositions.push({
+        componentId: port.schematic_component_id,
+        cx: port.center.x,
+        cy: port.center.y
+      });
+    }
+    const result = new Map;
+    for (const element of circuitJson) {
+      if (element.type !== "schematic_net_label")
+        continue;
+      const label = element;
+      if (!label.anchor_position)
+        continue;
+      const { x: anchorX, y: anchorY } = label.anchor_position;
+      const matches = portPositions.filter((port) => Math.hypot(port.cx - anchorX, port.cy - anchorY) < MATCH_EPSILON);
+      if (matches.length === 0)
+        continue;
+      const componentIds = new Set(matches.map((match) => match.componentId));
+      if (componentIds.size !== 1)
+        continue;
+      const componentId = matches[0].componentId;
+      const labels = result.get(componentId) ?? [];
+      labels.push(label);
+      result.set(componentId, labels);
+    }
+    return result;
+  }
+  getNetLabelBounds(label) {
+    const anchorSide = label.anchor_side;
+    const isVertical3 = anchorSide === "top" || anchorSide === "bottom";
+    if (isVertical3) {
+      const anchorY = label.anchor_position?.y ?? label.center.y;
+      const textHalfExtent = (label.text?.length ?? 8) * this.SCH_CHAR_WIDTH / 2 + this.LABEL_BOUNDS_SLACK;
+      const left = label.center.x - this.LABEL_HALF_HEIGHT;
+      const right = label.center.x + this.LABEL_HALF_HEIGHT;
+      if (anchorSide === "top") {
+        return {
+          left,
+          right,
+          top: anchorY,
+          bottom: anchorY - textHalfExtent * 2
+        };
+      }
+      return { left, right, top: anchorY + textHalfExtent * 2, bottom: anchorY };
+    }
+    const anchorX = label.anchor_position?.x ?? label.center.x;
+    const halfWidth = Math.abs(label.center.x - anchorX);
+    const farHalfWidth = halfWidth + this.LABEL_BOUNDS_SLACK;
+    const top = label.center.y + this.LABEL_HALF_HEIGHT;
+    const bottom = label.center.y - this.LABEL_HALF_HEIGHT;
+    if (label.center.x >= anchorX) {
+      return {
+        left: anchorX,
+        right: label.center.x + farHalfWidth,
+        top,
+        bottom
+      };
+    }
+    return { left: label.center.x - farHalfWidth, right: anchorX, top, bottom };
+  }
+  static netLabelCollisionToString(issue) {
+    const pairAttrs = issue.pairs.map((pair, i2) => `pair${i2 + 1}="${pair.comp1Name}/${pair.comp2Name}"`).join(" ");
+    const moves = issue.moves.map((move) => `    <Move componentName="${move.componentName}" newSchX="${move.newSchX}" newSchY="${move.newSchY}" />`);
+    return [
+      `<ComponentNetLabelCollision ${pairAttrs}>`,
+      `  <SuggestedFix note="Apply all moves simultaneously. Set schAutoLayoutEnabled on your circuit.">`,
+      ...moves,
+      `  </SuggestedFix>`,
+      `</ComponentNetLabelCollision>`
+    ].join(`
+`);
+  }
+}
+
 // node_modules/@tscircuit/circuit-json-schematic-placement-analysis/lib/solvers/SchematicPlacementPipeline/SchematicPlacementPipeline.ts
 class SchematicPlacementPipeline extends BasePipelineSolver2 {
   ctx;
@@ -245701,6 +246049,9 @@ class SchematicPlacementPipeline extends BasePipelineSolver2 {
     ]),
     definePipelineStep3("DiodeResistorAlignmentSolver", DiodeResistorAlignmentSolver, (p3) => [
       { ctx: p3.ctx, issues: p3.issues }
+    ]),
+    definePipelineStep3("ComponentNetLabelCollisionSolver", ComponentNetLabelCollisionSolver, (p3) => [
+      { ctx: p3.ctx, issues: p3.issues }
     ])
   ];
   _setup() {
@@ -245753,6 +246104,8 @@ class SchematicPlacementAnalysis {
         return SchematicPinPaddingToEdgeSolver.issueToString(issue);
       case "DiodeResistorNotAligned":
         return DiodeResistorAlignmentSolver.issueToString(issue);
+      case "NetLabelCollision":
+        return ComponentNetLabelCollisionSolver.netLabelCollisionToString(issue);
       default:
         return "";
     }

package/dist/lib/index.js

@@ -65733,7 +65733,7 @@ var getNodeHandler = (winterSpec, { port, middleware = [] }) => {
   }));
 };
 // package.json
-var version = "0.1.1432";
+var version = "0.1.1434";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -65747,7 +65747,7 @@ var package_default = {
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#700017d79a608295cc275dcb9c2e1d160809ef9e",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#40f49bb8ae9dabedb19b47ec0a621c713b40615c",
     "@tscircuit/eval": "^0.0.835",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.1434",
+  "version": "0.1.1435",
   "main": "dist/cli/main.js",
   "exports": {
     ".": "./dist/cli/main.js",
@@ -11,7 +11,7 @@
     "@biomejs/biome": "^1.9.4",
     "@tscircuit/circuit-json-placement-analysis": "^0.0.6",
     "@tscircuit/circuit-json-routing-analysis": "^0.0.1",
-    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#700017d79a608295cc275dcb9c2e1d160809ef9e",
+    "@tscircuit/circuit-json-schematic-placement-analysis": "github:tscircuit/circuit-json-schematic-placement-analysis#40f49bb8ae9dabedb19b47ec0a621c713b40615c",
     "@tscircuit/eval": "^0.0.835",
     "@tscircuit/fake-snippets": "^0.0.182",
     "@tscircuit/file-server": "^0.0.32",