@tscircuit/core 0.0.707 → 0.0.708

package/dist/index.js

@@ -13,7 +13,7 @@ __export(components_exports, {
   BreakoutPoint: () => BreakoutPoint,
   Capacitor: () => Capacitor,
   Chip: () => Chip,
-  Constraint: () => Constraint2,
+  Constraint: () => Constraint3,
   Crystal: () => Crystal,
   Cutout: () => Cutout,
   Diode: () => Diode,
@@ -9740,8 +9740,7 @@ function getPresetAutoroutingConfig(autorouterConfig) {
   }
 }
 
-// lib/components/primitive-components/Group/Group_doInitialPcbLayoutPack.ts
-import "@tscircuit/circuit-json-util";
+// lib/components/primitive-components/Group/Group_doInitialPcbLayoutPack/Group_doInitialPcbLayoutPack.ts
 import {
   pack,
   convertCircuitJsonToPackOutput,
@@ -9749,64 +9748,263 @@ import {
   getGraphicsFromPackOutput
 } from "calculate-packing";
 import { length as length4 } from "circuit-json";
-import {
-  transformPCBElements
-} from "@tscircuit/circuit-json-util";
-import { translate as translate5, rotate as rotate2, compose as compose4 } from "transformation-matrix";
 import Debug7 from "debug";
-var DEFAULT_MIN_GAP = "1mm";
-var debug6 = Debug7("Group_doInitialPcbLayoutPack");
+
+// lib/components/primitive-components/Group/Group_doInitialPcbLayoutPack/applyComponentConstraintClusters.ts
+import * as kiwi2 from "@lume/kiwi";
+var applyComponentConstraintClusters = (group, packInput) => {
+  const constraints = group.children.filter(
+    (c) => c.componentName === "Constraint" && c._parsedProps.pcb
+  );
+  const clusterByRoot = /* @__PURE__ */ new Map();
+  const parent = {};
+  const find = (x) => {
+    if (parent[x] !== x) parent[x] = find(parent[x]);
+    return parent[x];
+  };
+  const union = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[rb] = ra;
+  };
+  const makeSet = (x) => {
+    if (!(x in parent)) parent[x] = x;
+  };
+  const getIdFromSelector = (sel2) => {
+    const name = sel2.startsWith(".") ? sel2.slice(1) : sel2;
+    const child = group.children.find((c) => c.name === name);
+    return child?.pcb_component_id ?? void 0;
+  };
+  for (const constraint of constraints) {
+    const props = constraint._parsedProps;
+    if ("left" in props && "right" in props) {
+      const a = getIdFromSelector(props.left);
+      const b = getIdFromSelector(props.right);
+      if (a && b) {
+        makeSet(a);
+        makeSet(b);
+        union(a, b);
+      }
+    } else if ("top" in props && "bottom" in props) {
+      const a = getIdFromSelector(props.top);
+      const b = getIdFromSelector(props.bottom);
+      if (a && b) {
+        makeSet(a);
+        makeSet(b);
+        union(a, b);
+      }
+    } else if ("for" in props && Array.isArray(props.for)) {
+      const ids = props.for.map((s) => getIdFromSelector(s)).filter((s) => !!s);
+      for (const id of ids) makeSet(id);
+      for (let i = 1; i < ids.length; i++) union(ids[0], ids[i]);
+    }
+  }
+  for (const id of Object.keys(parent)) {
+    const rootId = find(id);
+    if (!clusterByRoot.has(rootId))
+      clusterByRoot.set(rootId, { componentIds: [], constraints: [] });
+    clusterByRoot.get(rootId).componentIds.push(id);
+  }
+  for (const constraint of constraints) {
+    const props = constraint._parsedProps;
+    let compId;
+    if ("left" in props) compId = getIdFromSelector(props.left);
+    else if ("top" in props) compId = getIdFromSelector(props.top);
+    else if ("for" in props) compId = getIdFromSelector(props.for[0]);
+    if (!compId) continue;
+    const root = find(compId);
+    clusterByRoot.get(root)?.constraints.push(constraint);
+  }
+  const clusterMap = {};
+  const packCompById = Object.fromEntries(
+    packInput.components.map((c) => [c.componentId, c])
+  );
+  for (const [rootId, info] of clusterByRoot.entries()) {
+    if (info.componentIds.length <= 1) continue;
+    const solver = new kiwi2.Solver();
+    const kVars = {};
+    const getVar = (id, axis) => {
+      const key = `${id}_${axis}`;
+      if (!kVars[key]) kVars[key] = new kiwi2.Variable(key);
+      return kVars[key];
+    };
+    const anchor = info.componentIds[0];
+    solver.addConstraint(
+      new kiwi2.Constraint(
+        getVar(anchor, "x"),
+        kiwi2.Operator.Eq,
+        0,
+        kiwi2.Strength.required
+      )
+    );
+    solver.addConstraint(
+      new kiwi2.Constraint(
+        getVar(anchor, "y"),
+        kiwi2.Operator.Eq,
+        0,
+        kiwi2.Strength.required
+      )
+    );
+    for (const constraint of info.constraints) {
+      const props = constraint._parsedProps;
+      if ("xDist" in props) {
+        const left = getIdFromSelector(props.left);
+        const right = getIdFromSelector(props.right);
+        if (left && right) {
+          solver.addConstraint(
+            new kiwi2.Constraint(
+              new kiwi2.Expression(getVar(right, "x"), [-1, getVar(left, "x")]),
+              kiwi2.Operator.Eq,
+              props.xDist,
+              kiwi2.Strength.required
+            )
+          );
+        }
+      } else if ("yDist" in props) {
+        const top = getIdFromSelector(props.top);
+        const bottom = getIdFromSelector(props.bottom);
+        if (top && bottom) {
+          solver.addConstraint(
+            new kiwi2.Constraint(
+              new kiwi2.Expression(getVar(top, "y"), [-1, getVar(bottom, "y")]),
+              kiwi2.Operator.Eq,
+              props.yDist,
+              kiwi2.Strength.required
+            )
+          );
+        }
+      } else if ("sameX" in props && Array.isArray(props.for)) {
+        const ids = props.for.map((s) => getIdFromSelector(s)).filter((s) => !!s);
+        if (ids.length > 1) {
+          const base = getVar(ids[0], "x");
+          for (let i = 1; i < ids.length; i++) {
+            solver.addConstraint(
+              new kiwi2.Constraint(
+                new kiwi2.Expression(getVar(ids[i], "x"), [-1, base]),
+                kiwi2.Operator.Eq,
+                0,
+                kiwi2.Strength.required
+              )
+            );
+          }
+        }
+      } else if ("sameY" in props && Array.isArray(props.for)) {
+        const ids = props.for.map((s) => getIdFromSelector(s)).filter((s) => !!s);
+        if (ids.length > 1) {
+          const base = getVar(ids[0], "y");
+          for (let i = 1; i < ids.length; i++) {
+            solver.addConstraint(
+              new kiwi2.Constraint(
+                new kiwi2.Expression(getVar(ids[i], "y"), [-1, base]),
+                kiwi2.Operator.Eq,
+                0,
+                kiwi2.Strength.required
+              )
+            );
+          }
+        }
+      }
+    }
+    solver.updateVariables();
+    const positions = {};
+    for (const id of info.componentIds) {
+      positions[id] = {
+        x: getVar(id, "x").value(),
+        y: getVar(id, "y").value()
+      };
+    }
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const id of info.componentIds) {
+      const comp = packCompById[id];
+      const pos = positions[id];
+      if (!comp) continue;
+      for (const pad of comp.pads) {
+        const ax = pos.x + pad.offset.x;
+        const ay = pos.y + pad.offset.y;
+        minX = Math.min(minX, ax - pad.size.x / 2);
+        maxX = Math.max(maxX, ax + pad.size.x / 2);
+        minY = Math.min(minY, ay - pad.size.y / 2);
+        maxY = Math.max(maxY, ay + pad.size.y / 2);
+      }
+    }
+    const clusterCenter = { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };
+    const mergedPads = [];
+    const relCenters = {};
+    for (const id of info.componentIds) {
+      const comp = packCompById[id];
+      const pos = positions[id];
+      if (!comp) continue;
+      relCenters[id] = {
+        x: pos.x - clusterCenter.x,
+        y: pos.y - clusterCenter.y
+      };
+      for (const pad of comp.pads) {
+        mergedPads.push({
+          padId: pad.padId,
+          networkId: pad.networkId,
+          type: pad.type,
+          size: pad.size,
+          offset: {
+            x: pos.x + pad.offset.x - clusterCenter.x,
+            y: pos.y + pad.offset.y - clusterCenter.y
+          }
+        });
+      }
+    }
+    packInput.components = packInput.components.filter(
+      (c) => !info.componentIds.includes(c.componentId)
+    );
+    packInput.components.push({
+      componentId: info.componentIds[0],
+      pads: mergedPads,
+      availableRotationDegrees: [0]
+    });
+    info.relativeCenters = relCenters;
+    clusterMap[info.componentIds[0]] = info;
+  }
+  return clusterMap;
+};
+
+// lib/components/primitive-components/Group/Group_doInitialPcbLayoutPack/applyPackOutput.ts
+import { translate as translate5, rotate as rotate2, compose as compose4 } from "transformation-matrix";
+import { transformPCBElements } from "@tscircuit/circuit-json-util";
 var isDescendantGroup = (db, groupId, ancestorId) => {
   if (groupId === ancestorId) return true;
   const group = db.source_group.get(groupId);
   if (!group || !group.parent_source_group_id) return false;
   return isDescendantGroup(db, group.parent_source_group_id, ancestorId);
 };
-var Group_doInitialPcbLayoutPack = (group) => {
+var applyPackOutput = (group, packOutput, clusterMap) => {
   const { db } = group.root;
-  const { _parsedProps: props } = group;
-  const {
-    packOrderStrategy,
-    packPlacementStrategy,
-    gap: gapProp,
-    pcbGap,
-    // @ts-expect-error remove when props introduces pcbPackGap
-    pcbPackGap
-  } = props;
-  const gap = pcbPackGap ?? pcbGap ?? gapProp;
-  const gapMm = length4.parse(gap ?? DEFAULT_MIN_GAP);
-  const packInput = {
-    ...convertPackOutputToPackInput(
-      convertCircuitJsonToPackOutput(db.toArray(), {
-        source_group_id: group.source_group_id,
-        shouldAddInnerObstacles: true
-      })
-    ),
-    // @ts-expect-error we're missing some pack order strategies
-    orderStrategy: packOrderStrategy ?? "largest_to_smallest",
-    placementStrategy: packPlacementStrategy ?? "minimum_sum_squared_distance_to_network",
-    minGap: gapMm
-  };
-  if (debug6.enabled) {
-    group.root?.emit("debug:logOutput", {
-      type: "debug:logOutput",
-      name: `packInput-circuitjson-${group.name}`,
-      content: JSON.stringify(db.toArray())
-    });
-    group.root?.emit("debug:logOutput", {
-      type: "debug:logOutput",
-      name: `packInput-${group.name}`,
-      content: packInput
-    });
-  }
-  const packOutput = pack(packInput);
-  if (debug6.enabled) {
-    const graphics = getGraphicsFromPackOutput(packOutput);
-    graphics.title = `packOutput-${group.name}`;
-    global.debugGraphics?.push(graphics);
-  }
   for (const packedComponent of packOutput.components) {
     const { center, componentId, ccwRotationOffset, ccwRotationDegrees } = packedComponent;
+    const cluster = clusterMap[componentId];
+    if (cluster) {
+      const rotationDegrees2 = ccwRotationDegrees ?? ccwRotationOffset ?? 0;
+      const angleRad = rotationDegrees2 * Math.PI / 180;
+      for (const memberId of cluster.componentIds) {
+        const rel = cluster.relativeCenters[memberId];
+        if (!rel) continue;
+        const rotatedRel = {
+          x: rel.x * Math.cos(angleRad) - rel.y * Math.sin(angleRad),
+          y: rel.x * Math.sin(angleRad) + rel.y * Math.cos(angleRad)
+        };
+        const member = db.pcb_component.get(memberId);
+        if (!member) continue;
+        const originalCenter2 = member.center;
+        const transformMatrix2 = compose4(
+          group._computePcbGlobalTransformBeforeLayout(),
+          translate5(center.x + rotatedRel.x, center.y + rotatedRel.y),
+          rotate2(angleRad),
+          translate5(-originalCenter2.x, -originalCenter2.y)
+        );
+        const related = db.toArray().filter(
+          (elm) => "pcb_component_id" in elm && elm.pcb_component_id === memberId
+        );
+        transformPCBElements(related, transformMatrix2);
+      }
+      continue;
+    }
     const pcbComponent = db.pcb_component.get(componentId);
     if (pcbComponent) {
       const currentGroupId = group.source_group_id;
@@ -9862,20 +10060,16 @@ var Group_doInitialPcbLayoutPack = (group) => {
         }
       }
       if ("pcb_component_id" in elm && elm.pcb_component_id) {
-        const pcbComponent2 = db.pcb_component.get(elm.pcb_component_id);
-        if (pcbComponent2?.source_component_id) {
-          const sourceComponent = db.source_component.get(
-            pcbComponent2.source_component_id
+        const pcbComp = db.pcb_component.get(elm.pcb_component_id);
+        if (pcbComp?.source_component_id) {
+          const sourceComp = db.source_component.get(
+            pcbComp.source_component_id
           );
-          if (sourceComponent?.source_group_id) {
-            if (sourceComponent.source_group_id === componentId) {
+          if (sourceComp?.source_group_id) {
+            if (sourceComp.source_group_id === componentId) {
               return true;
             }
-            if (isDescendantGroup(
-              db,
-              sourceComponent.source_group_id,
-              componentId
-            )) {
+            if (isDescendantGroup(db, sourceComp.source_group_id, componentId)) {
               return true;
             }
           }
@@ -9888,6 +10082,56 @@ var Group_doInitialPcbLayoutPack = (group) => {
   }
 };
 
+// lib/components/primitive-components/Group/Group_doInitialPcbLayoutPack/Group_doInitialPcbLayoutPack.ts
+var DEFAULT_MIN_GAP = "1mm";
+var debug6 = Debug7("Group_doInitialPcbLayoutPack");
+var Group_doInitialPcbLayoutPack = (group) => {
+  const { db } = group.root;
+  const { _parsedProps: props } = group;
+  const {
+    packOrderStrategy,
+    packPlacementStrategy,
+    gap: gapProp,
+    pcbGap,
+    // @ts-expect-error remove when props introduces pcbPackGap
+    pcbPackGap
+  } = props;
+  const gap = pcbPackGap ?? pcbGap ?? gapProp;
+  const gapMm = length4.parse(gap ?? DEFAULT_MIN_GAP);
+  const packInput = {
+    ...convertPackOutputToPackInput(
+      convertCircuitJsonToPackOutput(db.toArray(), {
+        source_group_id: group.source_group_id,
+        shouldAddInnerObstacles: true
+      })
+    ),
+    // @ts-expect-error we're missing some pack order strategies
+    orderStrategy: packOrderStrategy ?? "largest_to_smallest",
+    placementStrategy: packPlacementStrategy ?? "minimum_sum_squared_distance_to_network",
+    minGap: gapMm
+  };
+  const clusterMap = applyComponentConstraintClusters(group, packInput);
+  if (debug6.enabled) {
+    group.root?.emit("debug:logOutput", {
+      type: "debug:logOutput",
+      name: `packInput-circuitjson-${group.name}`,
+      content: JSON.stringify(db.toArray())
+    });
+    group.root?.emit("debug:logOutput", {
+      type: "debug:logOutput",
+      name: `packInput-${group.name}`,
+      content: packInput
+    });
+  }
+  const packOutput = pack(packInput);
+  if (debug6.enabled) {
+    const graphics = getGraphicsFromPackOutput(packOutput);
+    graphics.title = `packOutput-${group.name}`;
+    global.debugGraphics?.push(graphics);
+  }
+  applyPackOutput(group, packOutput, clusterMap);
+};
+
 // lib/components/primitive-components/Group/Group_doInitialPcbLayoutFlex.ts
 import { getMinimumFlexContainer as getMinimumFlexContainer2 } from "@tscircuit/circuit-json-util";
 import { RootFlexBox as RootFlexBox2 } from "@tscircuit/miniflex";
@@ -12696,7 +12940,7 @@ var edgeSpecifiers = [
   "bottomedge",
   "center"
 ];
-var Constraint2 = class extends PrimitiveComponent2 {
+var Constraint3 = class extends PrimitiveComponent2 {
   get config() {
     return {
       componentName: "Constraint",
@@ -14379,7 +14623,7 @@ import { identity as identity6 } from "transformation-matrix";
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.706",
+  version: "0.0.707",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -14889,7 +15133,7 @@ export {
   Capacitor,
   Chip,
   Circuit,
-  Constraint2 as Constraint,
+  Constraint3 as Constraint,
   Crystal,
   Cutout,
   Diode,

package/package.json

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