@crazyhappyone/auto-graph 0.2.2 → 0.2.4

package/dist/index.cjs

@@ -4054,6 +4054,45 @@ function indentLines(values) {
   return values.map(indent);
 }
 
+// src/solver/pipeline/pipeline.ts
+var LayoutPipeline = class {
+  phases = [];
+  addPhase(phase) {
+    this.phases.push(phase);
+    return this;
+  }
+  addBefore(refName, phase) {
+    const idx = this.phases.findIndex((p) => p.name === refName);
+    if (idx === -1) throw new Error(`Phase "${refName}" not found`);
+    this.phases.splice(idx, 0, phase);
+    return this;
+  }
+  addAfter(refName, phase) {
+    const idx = this.phases.findIndex((p) => p.name === refName);
+    if (idx === -1) throw new Error(`Phase "${refName}" not found`);
+    this.phases.splice(idx + 1, 0, phase);
+    return this;
+  }
+  replacePhase(name, phase) {
+    const idx = this.phases.findIndex((p) => p.name === name);
+    if (idx === -1) throw new Error(`Phase "${name}" not found`);
+    this.phases[idx] = phase;
+    return this;
+  }
+  run(state) {
+    for (const phase of this.phases) {
+      const before = state.diagnostics.length;
+      const start = performance.now();
+      phase.run(state);
+      state.phaseTrace.push({
+        phase: phase.name,
+        durationMs: performance.now() - start,
+        diagnosticsAdded: state.diagnostics.length - before
+      });
+    }
+  }
+};
+
 // src/ir/diagnostics.ts
 var DELIVERABILITY_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
   "constraints.locked-target-not-moved",
@@ -5439,6 +5478,217 @@ function areCollinear2(a, b, c) {
   return a.x === b.x && b.x === c.x || a.y === b.y && b.y === c.y;
 }
 
+// src/solver/pipeline/quality.ts
+function scoreLayoutQuality(nodes, edges) {
+  const diagnostics = [];
+  const metrics = [];
+  const overlapCount = countNodeOverlaps(nodes);
+  const overlapScore = Math.max(0, 20 - overlapCount * 5);
+  metrics.push({
+    kind: "node-overlap",
+    value: overlapCount,
+    label: `${overlapCount} overlaps`
+  });
+  if (overlapCount > 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "quality.node_overlap",
+      message: `${overlapCount} node pair(s) overlap.`,
+      detail: { overlapCount }
+    });
+  }
+  const crossingCount = countEdgeCrossings(edges);
+  const crossingScore = Math.max(0, 20 - crossingCount * 2);
+  metrics.push({
+    kind: "edge-crossing",
+    value: crossingCount,
+    label: `${crossingCount} crossings`
+  });
+  if (crossingCount > 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "quality.edge_crossing",
+      message: `${crossingCount} edge segment pair(s) cross.`,
+      detail: { crossingCount }
+    });
+  }
+  const totalBends = countTotalBends(edges);
+  const bendScore = Math.max(0, 20 - totalBends * 0.5);
+  metrics.push({
+    kind: "bend-count",
+    value: totalBends,
+    label: `${totalBends} bends`
+  });
+  const backtrackCount = countBacktrackingEdges(edges);
+  const backtrackScore = Math.max(0, 20 - backtrackCount * 5);
+  metrics.push({
+    kind: "route-backtrack",
+    value: backtrackCount,
+    label: `${backtrackCount} backtracking`
+  });
+  if (backtrackCount > 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "quality.route_backtrack",
+      message: `${backtrackCount} edge(s) are excessively long (>3\xD7 direct).`,
+      detail: { backtrackCount }
+    });
+  }
+  const labelCollisions = countLabelCollisions(nodes, edges);
+  const labelScore = Math.max(0, 20 - labelCollisions * 3);
+  metrics.push({
+    kind: "label-collision",
+    value: labelCollisions,
+    label: `${labelCollisions} label collisions`
+  });
+  const score = Math.max(
+    0,
+    Math.min(
+      100,
+      overlapScore + crossingScore + bendScore + backtrackScore + labelScore
+    )
+  );
+  return { metrics, score, diagnostics };
+}
+function countNodeOverlaps(nodes) {
+  let count = 0;
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      if (intersectsAabb(nodes[i].box, nodes[j].box)) {
+        count++;
+      }
+    }
+  }
+  return count;
+}
+function countEdgeCrossings(edges) {
+  let count = 0;
+  for (let i = 0; i < edges.length; i++) {
+    const aPts = edges[i].points;
+    for (let j = i + 1; j < edges.length; j++) {
+      const bPts = edges[j].points;
+      for (let ai = 0; ai < aPts.length - 1; ai++) {
+        for (let bi = 0; bi < bPts.length - 1; bi++) {
+          if (segmentsIntersect(
+            aPts[ai],
+            aPts[ai + 1],
+            bPts[bi],
+            bPts[bi + 1]
+          )) {
+            count++;
+          }
+        }
+      }
+    }
+  }
+  return count;
+}
+function segmentsIntersect(a, b, c, d) {
+  const d1 = cross(c, d, a);
+  const d2 = cross(c, d, b);
+  const d3 = cross(a, b, c);
+  const d4 = cross(a, b, d);
+  return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
+}
+function cross(o, a, b) {
+  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+}
+function countTotalBends(edges) {
+  const sign = (n) => n > 0 ? 1 : n < 0 ? -1 : 0;
+  let bends = 0;
+  for (const e of edges) {
+    if (e.points.length < 3) continue;
+    for (let i = 1; i < e.points.length - 1; i++) {
+      const prev = e.points[i - 1];
+      const curr = e.points[i];
+      const next = e.points[i + 1];
+      const dx1 = curr.x - prev.x;
+      const dy1 = curr.y - prev.y;
+      const dx2 = next.x - curr.x;
+      const dy2 = next.y - curr.y;
+      if (sign(dx1) !== sign(dx2) || sign(dy1) !== sign(dy2)) {
+        bends++;
+      }
+    }
+  }
+  return bends;
+}
+function countBacktrackingEdges(edges) {
+  let count = 0;
+  for (const e of edges) {
+    if (e.points.length < 2) continue;
+    const first = e.points[0];
+    const last = e.points[e.points.length - 1];
+    const direct = Math.hypot(last.x - first.x, last.y - first.y);
+    if (direct <= 0) continue;
+    let routeLen = 0;
+    for (let i = 0; i < e.points.length - 1; i++) {
+      routeLen += Math.hypot(
+        e.points[i + 1].x - e.points[i].x,
+        e.points[i + 1].y - e.points[i].y
+      );
+    }
+    if (routeLen > direct * 3) count++;
+  }
+  return count;
+}
+function countLabelCollisions(nodes, edges) {
+  let count = 0;
+  const nodeBoxes = /* @__PURE__ */ new Map();
+  for (const n of nodes) {
+    nodeBoxes.set(n.id, n.box);
+    if (n.label?.text !== void 0) {
+      const lw = n.label.text.length * 8;
+      const labelBox = {
+        x: n.box.x + n.box.width / 2 - lw / 2,
+        y: n.box.y - 8,
+        width: lw,
+        height: 14
+      };
+      for (const [id, box] of nodeBoxes) {
+        if (id === n.id) continue;
+        if (intersectsAabb(labelBox, box)) count++;
+      }
+      for (const e of edges) {
+        for (let i = 0; i < e.points.length - 1; i++) {
+          if (segmentIntersectsBox2(e.points[i], e.points[i + 1], labelBox)) {
+            count++;
+            break;
+          }
+        }
+      }
+    }
+  }
+  return count;
+}
+function segmentIntersectsBox2(start, end, box) {
+  const left = box.x;
+  const right = box.x + box.width;
+  const top = box.y;
+  const bottom = box.y + box.height;
+  if (start.x > left && start.x < right && start.y > top && start.y < bottom || end.x > left && end.x < right && end.y > top && end.y < bottom)
+    return true;
+  if (start.x === end.x) {
+    return start.x > left && start.x < right && rangesOverlap3(start.y, end.y, top, bottom);
+  }
+  if (start.y === end.y) {
+    return start.y > top && start.y < bottom && rangesOverlap3(start.x, end.x, left, right);
+  }
+  return edgeIntersect(start, end, left, top, right, top) || edgeIntersect(start, end, right, top, right, bottom) || edgeIntersect(start, end, right, bottom, left, bottom) || edgeIntersect(start, end, left, bottom, left, top);
+}
+function rangesOverlap3(a, b, min, max) {
+  const lo = Math.min(a, b);
+  const hi = Math.max(a, b);
+  return hi > min && lo < max;
+}
+function edgeIntersect(start, end, x1, y1, x2, y2) {
+  const denom = (end.x - start.x) * (y2 - y1) - (end.y - start.y) * (x2 - x1);
+  if (denom === 0) return false;
+  const t = ((start.x - x1) * (y2 - y1) - (start.y - y1) * (x2 - x1)) / denom;
+  const u = ((start.x - x1) * (end.y - start.y) - (start.y - y1) * (end.x - start.x)) / denom;
+  return t > 0 && t < 1 && u > 0 && u < 1;
+}
+
 // src/solver/solve.ts
 var DEFAULT_MATRIX_CELL_SIZE2 = { width: 120, height: 36 };
 var DEFAULT_TABLE_CELL_SIZE2 = { width: 128, height: 34 };
@@ -8126,13 +8376,13 @@ function routeIntersectsTextBox(points, box) {
     if (start === void 0 || end === void 0) {
       continue;
     }
-    if (segmentIntersectsBox2(start, end, box)) {
+    if (segmentIntersectsBox3(start, end, box)) {
       return true;
     }
   }
   return false;
 }
-function segmentIntersectsBox2(start, end, box) {
+function segmentIntersectsBox3(start, end, box) {
   const left = box.x;
   const right = box.x + box.width;
   const top = box.y;
@@ -8141,17 +8391,17 @@ function segmentIntersectsBox2(start, end, box) {
     return true;
   }
   if (start.x === end.x) {
-    return start.x > left && start.x < right && rangesOverlap3(start.y, end.y, top, bottom);
+    return start.x > left && start.x < right && rangesOverlap4(start.y, end.y, top, bottom);
   }
   if (start.y === end.y) {
-    return start.y > top && start.y < bottom && rangesOverlap3(start.x, end.x, left, right);
+    return start.y > top && start.y < bottom && rangesOverlap4(start.x, end.x, left, right);
   }
   return segmentIntersectsBoxEdge2(start, end, left, top, right, top) || segmentIntersectsBoxEdge2(start, end, right, top, right, bottom) || segmentIntersectsBoxEdge2(start, end, right, bottom, left, bottom) || segmentIntersectsBoxEdge2(start, end, left, bottom, left, top);
 }
 function pointInsideBox2(point2, box) {
   return point2.x > box.x && point2.x < box.x + box.width && point2.y > box.y && point2.y < box.y + box.height;
 }
-function rangesOverlap3(a, b, min, max) {
+function rangesOverlap4(a, b, min, max) {
   const low = Math.min(a, b);
   const high = Math.max(a, b);
   return high > min && low < max;
@@ -8514,6 +8764,30 @@ function groupReferenceMissing(groupId, referenceKind, id) {
     detail: id === void 0 ? { groupId } : { groupId, id }
   };
 }
+function createDefaultPipeline() {
+  return new LayoutPipeline().addPhase({
+    name: "solve-diagram",
+    run(state) {
+      const result = solveDiagram(state.diagram, state.options);
+      state.diagnostics.push(...result.diagnostics);
+      state.bounds = result.bounds;
+      state.degraded = result.degraded ?? false;
+      state.coordinatedNodes = result.nodes;
+      state.coordinatedEdges = result.edges;
+    }
+  }).addPhase({
+    name: "quality-score",
+    run(state) {
+      if (!state.options.qualityScore) return;
+      const report = scoreLayoutQuality(
+        state.coordinatedNodes,
+        state.coordinatedEdges
+      );
+      state.qualityReport = report;
+      state.diagnostics.push(...report.diagnostics);
+    }
+  });
+}
 
 // src/dsl/render.ts
 function resolveOutputFormat(cliFormat, dslFormat) {
@@ -8756,6 +9030,7 @@ exports.DEFAULT_DSL_MAX_BYTES = DEFAULT_DSL_MAX_BYTES;
 exports.DELIVERABILITY_DIAGNOSTIC_CODES = DELIVERABILITY_DIAGNOSTIC_CODES;
 exports.DeterministicTextMeasurer = DeterministicTextMeasurer;
 exports.LabelFitter = LabelFitter;
+exports.LayoutPipeline = LayoutPipeline;
 exports.PretextTextMeasurer = PretextTextMeasurer;
 exports.applyLayoutConstraints = applyLayoutConstraints;
 exports.assertFiniteNonNegative = assertFiniteNonNegative;
@@ -8766,6 +9041,7 @@ exports.computeArrowhead = computeArrowhead;
 exports.computeContainerGeometry = computeContainerGeometry;
 exports.computeShapeGeometry = computeShapeGeometry;
 exports.createBoxSpatialIndex = createBoxSpatialIndex;
+exports.createDefaultPipeline = createDefaultPipeline;
 exports.createDefaultTextMeasurer = createDefaultTextMeasurer;
 exports.expandBox = expandBox;
 exports.expandBoxForQuery = expandBoxForQuery;