@tscircuit/core 0.0.624 → 0.0.626

package/dist/index.d.ts

@@ -2705,6 +2705,7 @@ declare class Capacitor extends NormalComponent<typeof capacitorProps, Polarized
         }>;
         sourceFtype: "simple_capacitor";
     };
+    initPorts(): void;
     _getSchematicSymbolDisplayValue(): string | undefined;
     doInitialCreateNetsFromProps(): void;
     doInitialCreateTracesFromProps(): void;

package/dist/index.js

@@ -7952,6 +7952,20 @@ import {
 import { LayoutPipelineSolver } from "@tscircuit/matchpack";
 import Debug6 from "debug";
 var debug5 = Debug6("Group_doInitialSchematicLayoutMatchpack");
+function facingDirectionToSide(facingDirection) {
+  switch (facingDirection) {
+    case "up":
+      return "y+";
+    case "down":
+      return "y-";
+    case "left":
+      return "x-";
+    case "right":
+      return "x+";
+    default:
+      return "y+";
+  }
+}
 function rotateDirection(direction, degrees) {
   const directions = [
     "up",
@@ -7977,7 +7991,18 @@ function convertTreeToInputProblem(tree, db, group) {
     chipGap: 0.4,
     partitionGap: 1.2
   };
+  debug5(
+    `[${group.name}] Processing ${tree.childNodes.length} child nodes for input problem`
+  );
   tree.childNodes.forEach((child, index) => {
+    debug5(
+      `[${group.name}] Processing child ${index}: nodeType=${child.nodeType}`
+    );
+    if (child.nodeType === "component") {
+      debug5(`[${group.name}] - Component: ${child.sourceComponent?.name}`);
+    } else if (child.nodeType === "group") {
+      debug5(`[${group.name}] - Group: ${child.sourceGroup?.name}`);
+    }
     if (child.nodeType === "component" && child.sourceComponent) {
       const chipId = child.sourceComponent.name || `chip_${index}`;
       const schematicComponent = db.schematic_component.getWhere({
@@ -8011,21 +8036,7 @@ function convertTreeToInputProblem(tree, db, group) {
         if (!sourcePort) continue;
         const pinId = `${chipId}.${sourcePort.pin_number || sourcePort.name || port.schematic_port_id}`;
         problem.chipMap[chipId].pins.push(pinId);
-        let side = "y+";
-        switch (port.facing_direction) {
-          case "up":
-            side = "y+";
-            break;
-          case "down":
-            side = "y-";
-            break;
-          case "left":
-            side = "x-";
-            break;
-          case "right":
-            side = "x+";
-            break;
-        }
+        const side = facingDirectionToSide(port.facing_direction);
         problem.chipPinMap[pinId] = {
           pinId,
           offset: {
@@ -8037,67 +8048,226 @@ function convertTreeToInputProblem(tree, db, group) {
       }
     } else if (child.nodeType === "group" && child.sourceGroup) {
       const groupId = child.sourceGroup.name || `group_${index}`;
+      debug5(`[${group.name}] Processing nested group: ${groupId}`);
       const schematicGroup = db.schematic_group?.getWhere?.({
         source_group_id: child.sourceGroup.source_group_id
       });
+      debug5(
+        `[${group.name}] Found schematic_group for ${groupId}:`,
+        schematicGroup
+      );
       if (schematicGroup) {
+        debug5(`[${group.name}] Treating group ${groupId} as composite chip`);
+        const groupComponents = db.schematic_component.list({
+          schematic_group_id: schematicGroup.schematic_group_id
+        });
+        debug5(
+          `[${group.name}] Group ${groupId} has ${groupComponents.length} components:`,
+          groupComponents.map((c) => c.source_component_id)
+        );
+        let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+        let hasValidBounds = false;
+        for (const comp of groupComponents) {
+          if (comp.center && comp.size) {
+            hasValidBounds = true;
+            const halfWidth = comp.size.width / 2;
+            const halfHeight = comp.size.height / 2;
+            minX = Math.min(minX, comp.center.x - halfWidth);
+            maxX = Math.max(maxX, comp.center.x + halfWidth);
+            minY = Math.min(minY, comp.center.y - halfHeight);
+            maxY = Math.max(maxY, comp.center.y + halfHeight);
+          }
+        }
+        const groupWidth = hasValidBounds ? maxX - minX : 2;
+        const groupHeight = hasValidBounds ? maxY - minY : 2;
+        debug5(
+          `[${group.name}] Group ${groupId} computed size: ${groupWidth} x ${groupHeight}`
+        );
+        const groupPins = [];
+        for (const comp of groupComponents) {
+          const ports = db.schematic_port.list({
+            schematic_component_id: comp.schematic_component_id
+          });
+          for (const port of ports) {
+            const sourcePort = db.source_port.get(port.source_port_id);
+            if (!sourcePort) continue;
+            const pinId = `${groupId}.${sourcePort.pin_number || sourcePort.name || port.schematic_port_id}`;
+            groupPins.push(pinId);
+            const groupCenter = schematicGroup.center || { x: 0, y: 0 };
+            const side = facingDirectionToSide(port.facing_direction);
+            problem.chipPinMap[pinId] = {
+              pinId,
+              offset: {
+                x: (port.center?.x || 0) - groupCenter.x,
+                y: (port.center?.y || 0) - groupCenter.y
+              },
+              side
+            };
+          }
+        }
+        debug5(
+          `[${group.name}] Group ${groupId} has ${groupPins.length} pins:`,
+          groupPins
+        );
         problem.chipMap[groupId] = {
           chipId: groupId,
-          pins: [],
+          pins: groupPins,
           size: {
-            x: schematicGroup.size?.width || 2,
-            y: schematicGroup.size?.height || 2
+            x: groupWidth,
+            y: groupHeight
           }
         };
+        debug5(`[${group.name}] Added group ${groupId} to chipMap`);
+      } else {
+        debug5(
+          `[${group.name}] Warning: No schematic_group found for group ${groupId}`
+        );
       }
     }
   });
-  const sourceTraces = db.source_trace.list();
-  const sourceNets = db.source_net.list();
-  for (const net of sourceNets) {
-    problem.netMap[net.name || net.source_net_id] = {
-      netId: net.name || net.source_net_id
-    };
-  }
-  for (const trace of sourceTraces) {
-    const connectedPorts = trace.connected_source_port_ids || [];
-    const connectedNets = trace.connected_source_net_ids || [];
-    const relevantPins = [];
-    for (const portId of connectedPorts) {
-      const sourcePort = db.source_port.get(portId);
-      if (!sourcePort) continue;
-      for (const [chipId, chip] of Object.entries(problem.chipMap)) {
-        const chipSourceComponent = tree.childNodes.find(
-          (n) => n.sourceComponent?.name === chipId
-        )?.sourceComponent;
-        if (chipSourceComponent) {
-          const isPortInComponent = db.source_port.list({
-            source_component_id: chipSourceComponent.source_component_id
-          }).some((p) => p.source_port_id === portId);
-          if (isPortInComponent) {
-            const pinNumber = sourcePort.pin_number || sourcePort.name;
-            const expectedPinId = `${chipId}.${pinNumber}`;
-            if (chip.pins.includes(expectedPinId)) {
-              relevantPins.push(expectedPinId);
-            } else {
-              debug5(
-                `Warning: Could not find pin ${expectedPinId} in chip ${chipId}`
-              );
+  debug5(`[${group.name}] Creating connections using connectivity keys`);
+  const connectivityGroups = /* @__PURE__ */ new Map();
+  for (const [chipId, chip] of Object.entries(problem.chipMap)) {
+    for (const pinId of chip.pins) {
+      const pinNumber = pinId.split(".").pop();
+      const treeNode = tree.childNodes.find((child) => {
+        if (child.nodeType === "component" && child.sourceComponent) {
+          return child.sourceComponent.name === chipId;
+        }
+        if (child.nodeType === "group" && child.sourceGroup) {
+          const expectedChipId = `group_${tree.childNodes.indexOf(child)}`;
+          return expectedChipId === chipId;
+        }
+        return false;
+      });
+      if (treeNode?.nodeType === "group" && treeNode.sourceGroup) {
+        const schematicGroup = db.schematic_group?.getWhere?.({
+          source_group_id: treeNode.sourceGroup.source_group_id
+        });
+        if (schematicGroup) {
+          const groupComponents = db.schematic_component.list({
+            schematic_group_id: schematicGroup.schematic_group_id
+          });
+          for (const comp of groupComponents) {
+            const sourcePorts = db.source_port.list({
+              source_component_id: comp.source_component_id
+            });
+            for (const sourcePort of sourcePorts) {
+              const portNumber = sourcePort.pin_number || sourcePort.name;
+              if (String(portNumber) === String(pinNumber)) {
+                if (sourcePort.subcircuit_connectivity_map_key) {
+                  const connectivityKey = sourcePort.subcircuit_connectivity_map_key;
+                  if (!connectivityGroups.has(connectivityKey)) {
+                    connectivityGroups.set(connectivityKey, []);
+                  }
+                  connectivityGroups.get(connectivityKey).push(pinId);
+                  debug5(
+                    `[${group.name}] \u2713 Pin ${pinId} has connectivity key: ${connectivityKey}`
+                  );
+                } else {
+                  debug5(`[${group.name}] Pin ${pinId} has no connectivity key`);
+                }
+              }
             }
           }
         }
+      } else if (treeNode?.nodeType === "component" && treeNode.sourceComponent) {
+        const sourcePorts = db.source_port.list({
+          source_component_id: treeNode.sourceComponent.source_component_id
+        });
+        for (const sourcePort of sourcePorts) {
+          const portNumber = sourcePort.pin_number || sourcePort.name;
+          if (String(portNumber) === String(pinNumber) && sourcePort.subcircuit_connectivity_map_key) {
+            const connectivityKey = sourcePort.subcircuit_connectivity_map_key;
+            if (!connectivityGroups.has(connectivityKey)) {
+              connectivityGroups.set(connectivityKey, []);
+            }
+            connectivityGroups.get(connectivityKey).push(pinId);
+            debug5(
+              `[${group.name}] Pin ${pinId} has connectivity key: ${connectivityKey}`
+            );
+          }
+        }
       }
     }
-    if (relevantPins.length === 2 && connectedNets.length === 0) {
-      const [pin1, pin2] = relevantPins;
-      problem.pinStrongConnMap[`${pin1}-${pin2}`] = true;
-      problem.pinStrongConnMap[`${pin2}-${pin1}`] = true;
-    }
-    for (const pinId of relevantPins) {
-      for (const netId of connectedNets) {
-        const net = db.source_net.get(netId);
-        const netName = net?.name || netId;
-        problem.netConnMap[`${pinId}-${netName}`] = true;
+  }
+  debug5(
+    `[${group.name}] Found ${connectivityGroups.size} connectivity groups:`,
+    Array.from(connectivityGroups.entries()).map(([key, pins]) => ({
+      key,
+      pins
+    }))
+  );
+  for (const [connectivityKey, pins] of connectivityGroups) {
+    if (pins.length >= 2) {
+      const tracesWithThisKey = db.source_trace.list().filter(
+        (trace) => trace.subcircuit_connectivity_map_key === connectivityKey
+      );
+      const hasNetConnections = tracesWithThisKey.some(
+        (trace) => trace.connected_source_net_ids && trace.connected_source_net_ids.length > 0
+      );
+      const hasDirectConnections = tracesWithThisKey.some(
+        (trace) => trace.connected_source_port_ids && trace.connected_source_port_ids.length >= 2
+      );
+      debug5(
+        `[${group.name}] Connectivity ${connectivityKey}: hasNetConnections=${hasNetConnections}, hasDirectConnections=${hasDirectConnections}`
+      );
+      if (hasDirectConnections) {
+        for (const trace of tracesWithThisKey) {
+          if (trace.connected_source_port_ids && trace.connected_source_port_ids.length >= 2) {
+            const directlyConnectedPins = [];
+            for (const portId of trace.connected_source_port_ids) {
+              for (const pinId of pins) {
+                const pinNumber = pinId.split(".").pop();
+                const sourcePort = db.source_port.get(portId);
+                if (sourcePort && String(sourcePort.pin_number || sourcePort.name) === String(pinNumber)) {
+                  const chipId = pinId.split(".")[0];
+                  const treeNode = tree.childNodes.find((child) => {
+                    if (child.nodeType === "component" && child.sourceComponent) {
+                      return child.sourceComponent.name === chipId;
+                    }
+                    if (child.nodeType === "group" && child.sourceGroup) {
+                      const expectedChipId = `group_${tree.childNodes.indexOf(child)}`;
+                      return expectedChipId === chipId;
+                    }
+                    return false;
+                  });
+                  if (treeNode?.nodeType === "component" && treeNode.sourceComponent) {
+                    const portBelongsToComponent = db.source_port.list({
+                      source_component_id: treeNode.sourceComponent.source_component_id
+                    }).some((p) => p.source_port_id === portId);
+                    if (portBelongsToComponent) {
+                      directlyConnectedPins.push(pinId);
+                    }
+                  }
+                }
+              }
+            }
+            for (let i = 0; i < directlyConnectedPins.length; i++) {
+              for (let j = i + 1; j < directlyConnectedPins.length; j++) {
+                const pin1 = directlyConnectedPins[i];
+                const pin2 = directlyConnectedPins[j];
+                problem.pinStrongConnMap[`${pin1}-${pin2}`] = true;
+                problem.pinStrongConnMap[`${pin2}-${pin1}`] = true;
+                debug5(
+                  `[${group.name}] Created strong connection: ${pin1} <-> ${pin2}`
+                );
+              }
+            }
+          }
+        }
+      }
+      if (hasNetConnections) {
+        problem.netMap[connectivityKey] = {
+          netId: connectivityKey
+        };
+        for (const pinId of pins) {
+          problem.netConnMap[`${pinId}-${connectivityKey}`] = true;
+        }
+        debug5(
+          `[${group.name}] Created net ${connectivityKey} with ${pins.length} pins:`,
+          pins
+        );
       }
     }
   }
@@ -8108,7 +8278,16 @@ function Group_doInitialSchematicLayoutMatchPack(group) {
   const tree = getCircuitJsonTree(db.toArray(), {
     source_group_id: group.source_group_id
   });
-  if (tree.childNodes.length <= 1) return;
+  debug5(
+    `[${group.name}] Starting matchpack layout with ${tree.childNodes.length} children`
+  );
+  debug5(`[${group.name}] Tree structure:`, JSON.stringify(tree, null, 2));
+  if (tree.childNodes.length <= 1) {
+    debug5(
+      `[${group.name}] Only ${tree.childNodes.length} children, skipping layout`
+    );
+    return;
+  }
   debug5("Converting circuit tree to InputProblem...");
   const inputProblem = convertTreeToInputProblem(tree, db, group);
   debug5("InputProblem:", JSON.stringify(inputProblem, null, 2));
@@ -8130,6 +8309,7 @@ function Group_doInitialSchematicLayoutMatchPack(group) {
   }
   const outputLayout = solver.getOutputLayout();
   debug5("OutputLayout:", JSON.stringify(outputLayout, null, 2));
+  debug5("Solver completed successfully:", !solver.failed);
   if (debug5.enabled && global.debugGraphics) {
     const finalViz = solver.visualize();
     global.debugGraphics.push({
@@ -8148,20 +8328,44 @@ function Group_doInitialSchematicLayoutMatchPack(group) {
   }
   const groupOffset = group._getGlobalSchematicPositionBeforeLayout();
   debug5(`Group offset: x=${groupOffset.x}, y=${groupOffset.y}`);
+  debug5(
+    `Applying layout results for ${Object.keys(outputLayout.chipPlacements).length} chip placements`
+  );
   for (const [chipId, placement] of Object.entries(
     outputLayout.chipPlacements
   )) {
+    debug5(
+      `Processing placement for chip: ${chipId} at (${placement.x}, ${placement.y})`
+    );
     const treeNode = tree.childNodes.find((child) => {
       if (child.nodeType === "component" && child.sourceComponent) {
-        return child.sourceComponent.name === chipId;
+        const matches = child.sourceComponent.name === chipId;
+        debug5(
+          `  Checking component ${child.sourceComponent.name}: matches=${matches}`
+        );
+        return matches;
       }
       if (child.nodeType === "group" && child.sourceGroup) {
-        return child.sourceGroup.name === chipId;
+        const groupName = child.sourceGroup.name;
+        const expectedChipId = `group_${tree.childNodes.indexOf(child)}`;
+        const matches = expectedChipId === chipId;
+        debug5(
+          `  Checking group ${groupName} (expected chipId: ${expectedChipId}): matches=${matches}`
+        );
+        return matches;
       }
       return false;
     });
     if (!treeNode) {
       debug5(`Warning: No tree node found for chip: ${chipId}`);
+      debug5(
+        `Available tree nodes:`,
+        tree.childNodes.map((child, idx) => ({
+          type: child.nodeType,
+          name: child.nodeType === "component" ? child.sourceComponent?.name : child.sourceGroup?.name,
+          expectedChipId: child.nodeType === "group" ? `group_${idx}` : child.sourceComponent?.name
+        }))
+      );
       continue;
     }
     const newCenter = {
@@ -8237,7 +8441,55 @@ function Group_doInitialSchematicLayoutMatchPack(group) {
         source_group_id: treeNode.sourceGroup.source_group_id
       });
       if (schematicGroup) {
-        debug5(`Moving group ${chipId} to (${newCenter.x}, ${newCenter.y})`);
+        debug5(
+          `Moving group ${chipId} to (${newCenter.x}, ${newCenter.y}) from (${schematicGroup.center?.x}, ${schematicGroup.center?.y})`
+        );
+        const groupComponents = db.schematic_component.list({
+          schematic_group_id: schematicGroup.schematic_group_id
+        });
+        debug5(
+          `Group ${chipId} has ${groupComponents.length} components to move`
+        );
+        const oldCenter = schematicGroup.center || { x: 0, y: 0 };
+        const positionDelta = {
+          x: newCenter.x - oldCenter.x,
+          y: newCenter.y - oldCenter.y
+        };
+        debug5(
+          `Position delta for group ${chipId}: (${positionDelta.x}, ${positionDelta.y})`
+        );
+        for (const component of groupComponents) {
+          if (component.center) {
+            const oldComponentCenter = { ...component.center };
+            component.center.x += positionDelta.x;
+            component.center.y += positionDelta.y;
+            debug5(
+              `Moved component ${component.source_component_id} from (${oldComponentCenter.x}, ${oldComponentCenter.y}) to (${component.center.x}, ${component.center.y})`
+            );
+            const ports = db.schematic_port.list({
+              schematic_component_id: component.schematic_component_id
+            });
+            const texts = db.schematic_text.list({
+              schematic_component_id: component.schematic_component_id
+            });
+            for (const port of ports) {
+              if (port.center) {
+                port.center.x += positionDelta.x;
+                port.center.y += positionDelta.y;
+              }
+            }
+            for (const text of texts) {
+              if (text.position) {
+                text.position.x += positionDelta.x;
+                text.position.y += positionDelta.y;
+              }
+            }
+          }
+        }
+        schematicGroup.center = newCenter;
+        debug5(
+          `Updated group ${chipId} center to (${newCenter.x}, ${newCenter.y})`
+        );
       }
     }
   }
@@ -9407,14 +9659,11 @@ var Group = class extends NormalComponent {
       const cProps = child._parsedProps;
       return cProps?.schX !== void 0 || cProps?.schY !== void 0;
     });
-    const anyChildIsGroup = this.children.some((child) => child.isGroup);
     const hasManualEdits = (props.manualEdits?.schematic_placements?.length ?? 0) > 0;
-    if (!anyChildHasSchCoords && !hasManualEdits && !anyChildIsGroup)
-      return "match-adapt";
+    if (!anyChildHasSchCoords && !hasManualEdits) return "match-adapt";
     return "relative";
   }
   doInitialSchematicLayout() {
-    const props = this._parsedProps;
     const schematicLayoutMode = this._getSchematicLayoutMode();
     if (schematicLayoutMode === "match-adapt") {
       this._doInitialSchematicLayoutMatchpack();
@@ -9819,6 +10068,18 @@ var Capacitor = class extends NormalComponent {
       sourceFtype: FTYPE.simple_capacitor
     };
   }
+  initPorts() {
+    if (typeof this.props.footprint === "string") {
+      super.initPorts({
+        additionalAliases: {
+          pin1: ["anode", "pos"],
+          pin2: ["cathode", "neg"]
+        }
+      });
+    } else {
+      super.initPorts();
+    }
+  }
   _getSchematicSymbolDisplayValue() {
     const capacitanceDisplay = `${formatSiUnit(this._parsedProps.capacitance)}F`;
     if (this._parsedProps.schShowRatings && this._parsedProps.maxVoltageRating) {
@@ -12064,7 +12325,7 @@ import { identity as identity5 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.623",
+  version: "0.0.625",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.624",
+  "version": "0.0.626",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",