@crazyhappyone/auto-graph 0.1.3 → 0.1.4

package/dist/cli/index.cjs

@@ -1292,6 +1292,9 @@ function applyLayoutConstraints(input) {
   const nodeById = new Map(input.nodes.map((node) => [node.id, node]));
   applyFixedPositionLocks(input.nodes, boxes, locks, diagnostics);
   applyExactPositions(input.constraints, boxes, locks, diagnostics, nodeById);
+  if (input.distributeContainedChildren) {
+    yieldFixedPositionLocks(input, boxes, locks);
+  }
   applyContainment(input.constraints, boxes, locks, diagnostics, false);
   applyRelative(input.constraints, boxes, locks, diagnostics);
   applyAlign(input.constraints, boxes, locks, diagnostics);
@@ -1305,6 +1308,13 @@ function applyLayoutConstraints(input) {
   );
   applyContainment(input.constraints, boxes, locks, diagnostics, true);
   applyDistributeContained(input, boxes, locks, diagnostics);
+  if (input.distributeContainedChildren) {
+    const diagBefore = diagnostics.length;
+    applyContainment(input.constraints, boxes, locks, diagnostics, true);
+    applyDistributeContained(input, boxes, locks, diagnostics);
+    dedupReplayDiagnostics(diagnostics, diagBefore);
+  }
+  removeResolvedConstraintDiagnostics(input.constraints, boxes, diagnostics);
   reportOverlaps(boxes, diagnostics, containmentOverlapKeys(input.constraints));
   reportIntraContainerOverflow(input, boxes, diagnostics);
   return { boxes, locks, diagnostics };
@@ -1350,6 +1360,62 @@ function applyFixedPositionLocks(nodes, boxes, locks, diagnostics) {
     locks.set(node.id, { nodeId: node.id, source: "fixed-position" });
   }
 }
+function dedupReplayDiagnostics(diagnostics, keepUpTo) {
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < keepUpTo && i < diagnostics.length; i += 1) {
+    const d = diagnostics[i];
+    if (d === void 0) continue;
+    seen.add(diagnosticFingerprint(d));
+  }
+  for (let i = diagnostics.length - 1; i >= keepUpTo; i -= 1) {
+    const d = diagnostics[i];
+    if (d === void 0) continue;
+    const fp = diagnosticFingerprint(d);
+    if (seen.has(fp)) {
+      diagnostics.splice(i, 1);
+    } else {
+      seen.add(fp);
+    }
+  }
+}
+function diagnosticFingerprint(d) {
+  const nodeId = typeof d.detail?.nodeId === "string" ? d.detail.nodeId : "";
+  const containerId = typeof d.detail?.containerId === "string" ? d.detail.containerId : "";
+  return `${d.code}|${nodeId}|${containerId}`;
+}
+function yieldFixedPositionLocks(input, boxes, locks) {
+  for (const c of input.constraints) {
+    if (c.kind !== "containment") continue;
+    const container = boxes.get(c.containerId);
+    if (container === void 0) continue;
+    const content = contentBox(container, c.padding);
+    const mainAxis = input.direction === "LR" || input.direction === "RL" ? "width" : "height";
+    const crossAxis = mainAxis === "width" ? "height" : "width";
+    let eligible = 0;
+    for (const childId of c.childIds) {
+      const box = boxes.get(childId);
+      if (box === void 0) continue;
+      const lock = locks.get(childId);
+      if (lock?.source === "exact-position") continue;
+      const fits = box[mainAxis] <= content[mainAxis] && box[crossAxis] <= content[crossAxis];
+      if (fits) {
+        eligible += 1;
+      }
+    }
+    if (eligible < 2) continue;
+    for (const childId of c.childIds) {
+      const lock = locks.get(childId);
+      if (lock?.source === "fixed-position") {
+        const box = boxes.get(childId);
+        if (box === void 0) continue;
+        const fits = box[mainAxis] <= content[mainAxis] && box[crossAxis] <= content[crossAxis];
+        if (fits) {
+          locks.delete(childId);
+        }
+      }
+    }
+  }
+}
 function applyExactPositions(constraints, boxes, locks, diagnostics, nodeById) {
   for (const constraint of constraints) {
     if (constraint.kind !== "exact-position") {
@@ -1422,7 +1488,7 @@ function applyContainment(constraints, boxes, locks, diagnostics, reportOverflow
             code: "constraints.locked-target-not-moved",
             message: `Locked child ${childId} was not moved into containment.`,
             path: ["constraints", constraint.id ?? constraint.containerId],
-            detail: { nodeId: childId }
+            detail: { nodeId: childId, containerId: constraint.containerId }
           });
           if (!isInside(child, content)) {
             diagnostics.push({
@@ -1574,6 +1640,60 @@ function repairOverlaps(input, boxes, locks, diagnostics, siblingPairs) {
   }
   reportOverlaps(boxes, diagnostics, ignoredPairs);
 }
+function removeResolvedConstraintDiagnostics(constraints, boxes, diagnostics) {
+  for (let i = diagnostics.length - 1; i >= 0; i -= 1) {
+    const d = diagnostics[i];
+    if (d === void 0) continue;
+    if (d.code === "constraints.overlap.unresolved") {
+      const aId = d.detail?.firstId;
+      const bId = d.detail?.secondId;
+      if (typeof aId !== "string" || typeof bId !== "string") continue;
+      const a = boxes.get(aId);
+      const b = boxes.get(bId);
+      if (a !== void 0 && b !== void 0 && !intersectsAabb(a, b)) {
+        diagnostics.splice(i, 1);
+      }
+      continue;
+    }
+    if (d.code === "constraints.containment.impossible" || d.code === "constraints.locked-target-not-moved" && typeof d.message === "string" && d.message.includes("not moved into containment")) {
+      const nodeId = d.detail?.nodeId;
+      if (typeof nodeId !== "string") continue;
+      const child = boxes.get(nodeId);
+      if (child === void 0) continue;
+      const diagContainerId = typeof d.detail?.containerId === "string" ? d.detail.containerId : void 0;
+      let resolved = false;
+      for (const c of constraints) {
+        if (c.kind !== "containment") continue;
+        if (!c.childIds.includes(nodeId)) continue;
+        if (diagContainerId !== void 0 && c.containerId !== diagContainerId) {
+          continue;
+        }
+        const container = boxes.get(c.containerId);
+        if (container === void 0) continue;
+        const content = contentBox(container, c.padding);
+        if (isInside(child, content)) {
+          diagnostics.splice(i, 1);
+          resolved = true;
+        }
+        break;
+      }
+      if (!resolved && diagContainerId !== void 0) {
+        for (const c of constraints) {
+          if (c.kind !== "containment") continue;
+          if (c.containerId !== diagContainerId) continue;
+          if (!c.childIds.includes(nodeId)) continue;
+          const container = boxes.get(c.containerId);
+          if (container === void 0) continue;
+          const content = contentBox(container, c.padding);
+          if (isInside(child, content)) {
+            diagnostics.splice(i, 1);
+          }
+          break;
+        }
+      }
+    }
+  }
+}
 function reportOverlaps(boxes, diagnostics, ignoredPairs = /* @__PURE__ */ new Set()) {
   const ids = [...boxes.keys()].sort();
   const reported = new Set(
@@ -1881,6 +2001,12 @@ function applyDistributeContained(input, boxes, locks, diagnostics) {
         continue;
       }
       if (locks.has(childId)) {
+        const lock = locks.get(childId);
+        if (lock?.source === "fixed-position") {
+          unlocked.push({ id: childId, box });
+          locks.delete(childId);
+          continue;
+        }
         diagnostics.push({
           severity: "warning",
           code: "constraints.locked-target-not-moved",
@@ -1939,6 +2065,7 @@ function applyDistributeContained(input, boxes, locks, diagnostics) {
         });
       }
       boxes.set(child.id, clamped);
+      locks.delete(child.id);
       pos = clamped[axis] + clamped[mainSize] + minGap;
     }
     diagnostics.push({
@@ -3388,7 +3515,7 @@ function routeEdge(input) {
       const rerouted = greedyRerouteAroundObstacles(
         bestPoints2,
         allObstacles,
-        Math.min(maxAttempts, 3)
+        maxAttempts
       );
       const reroutedAvoidsEndpointInteriors = !routeIntersectsEndpointInteriors(
         rerouted,
@@ -4150,9 +4277,7 @@ function solveDiagram(diagram, options = {}) {
     options?.overlapSpacing ?? 40,
     Math.max(0, options?.minLaneGutter ?? 0)
   );
-  if (swimlaneContracts.layouts.size > 0) {
-    removeResolvedOverlapDiagnostics(diagnostics, constrained.boxes);
-  }
+  removeResolvedOverlapDiagnostics(diagnostics, constrained.boxes);
   diagnostics.push(...swimlaneContracts.diagnostics);
   const coordinatedNodes = coordinateNodes(
     styledNodes,
@@ -6095,7 +6220,8 @@ function coordinateEdges(edges, nodes, coordinatedNodes, obstacles, softObstacle
         ...softObstacles,
         ...routeTextObstacles
       ],
-      hardObstacles
+      hardObstacles,
+      ...options.maxRoutingAttempts === void 0 ? {} : { maxRoutingAttempts: options.maxRoutingAttempts }
     });
     diagnostics.push(
       ...route.diagnostics.map((diagnostic) => ({
@@ -6578,7 +6704,8 @@ function edgeLabelAnchor(edge, layout2, edges, obstacleBoxes, placedLabelBoxes,
   for (const candidate of edgeLabelAnchorCandidates(
     edge.points,
     placement,
-    layout2
+    layout2,
+    baseOffset
   )) {
     const labelBox = {
       x: candidate.x - layout2.box.width / 2,
@@ -6610,8 +6737,8 @@ function edgeLabelAnchor(edge, layout2, edges, obstacleBoxes, placedLabelBoxes,
   }
   return placement;
 }
-function edgeLabelAnchorCandidates(points, placement, layout2) {
-  const segment = labelSegmentOnPolyline(points);
+function edgeLabelAnchorCandidates(points, placement, layout2, baseOffset = 10) {
+  const segment = labelSegmentOnPolyline(points, baseOffset);
   if (segment === void 0) {
     return [placement];
   }
@@ -6661,7 +6788,7 @@ function edgeLabelAnchorCandidates(points, placement, layout2) {
   }, 0);
   if (totalLen > 200) {
     for (const ratio of [0.25, 0.75]) {
-      const qp = labelPlacementAtRatio(points, ratio, totalLen);
+      const qp = labelPlacementAtRatio(points, ratio, totalLen, baseOffset);
       if (qp !== void 0) {
         candidates.push(qp);
         const qTargetDist = totalLen * ratio;
@@ -6747,7 +6874,7 @@ function labelSegmentOnPolyline(points, baseOffset = 10) {
   if (last === void 0) {
     return void 0;
   }
-  const offset = labelOffset2(last);
+  const offset = labelOffset2(last, baseOffset);
   return {
     start: last.start,
     end: last.end,
@@ -6769,7 +6896,7 @@ function nonZeroSegments2(points) {
   }
   return segments;
 }
-function labelPlacementAtRatio(points, ratio, totalLength) {
+function labelPlacementAtRatio(points, ratio, totalLength, baseOffset = 10) {
   if (points.length < 2 || ratio < 0 || ratio > 1) {
     return void 0;
   }
@@ -6787,7 +6914,10 @@ function labelPlacementAtRatio(points, ratio, totalLength) {
     }
     if (travelled + segLen >= targetDist) {
       const t = (targetDist - travelled) / segLen;
-      const offset = labelOffset2({ start: prev, end: curr, length: segLen });
+      const offset = labelOffset2(
+        { start: prev, end: curr, length: segLen },
+        baseOffset
+      );
       return {
         x: prev.x + (curr.x - prev.x) * t + offset.x,
         y: prev.y + (curr.y - prev.y) * t + offset.y