@stacksjs/defaults 0.75.361 → 0.75.362

package/ai/skills/stacks-technical-diagrams/renderers/dataflow/joint-label-routing.mjs

@@ -0,0 +1,165 @@
+import {
+  automaticPortRhythmBridge, collectAmbiguousCorridors, collectBorderRuns,
+  collectRouteRhythmIssues, frameBorderSegments, normalizeRoutePoints,
+  properSegmentIntersection, rectsOverlap, routeHonorsEndpointSides,
+  segmentIntersectsRect, segmentRectClearanceWithin,
+} from '../shared/geometry.mjs';
+import { shortestOrthogonalGridRoute } from '../shared/route-quality.mjs';
+
+const segments = points => points.slice(1).map((end, index) => ({ start: points[index], end }));
+const related = (a, b) => [a.from, a.to].some(id => id === b.from || id === b.to);
+const length = points => segments(points).reduce((sum, { start, end }) => sum
+  + Math.abs(start[0] - end[0]) + Math.abs(start[1] - end[1]), 0);
+const distance = (points, rect, limit = 36) => Math.min(...segments(points)
+  .map(segment => segmentRectClearanceWithin(segment, rect, limit)));
+const masks = (points, rect) => distance(points, rect, 4) + 0.0001 < 4;
+const pinned = flow => flow.via || (flow.route && flow.route !== 'auto')
+  || ['fromSide', 'toSide', 'channelX', 'channelY', 'labelAt', 'labelDx', 'labelDy', 'labelSegment']
+    .some(key => flow[key] !== undefined);
+const crossingCount = (a, b) => segments(a).reduce((sum, s) => sum + segments(b)
+  .filter(t => properSegmentIntersection(s.start, s.end, t.start, t.end)).length, 0);
+// One complete label, its own bridge, and the few routes blocking its slot
+// are a single proposal. Nothing is applied until all the geometry clears.
+// Keep all endpoint coordinates and every other label fixed.
+export function repairLabelRoutes({ labels, routes, nodes, titles, frames, viewBox,
+  placementBottom, sideFor, maximumSearches = 32, metrics = {} }) {
+  if (nodes.length + titles.length + labels.length - 1 > 80) {
+    Object.assign(metrics, { searches: 0, maximumSearches, changedLabels: 0, changedRoutes: 0 });
+    return { labels, routes };
+  }
+  let currentLabels = labels, currentRoutes = routes;
+  let searches = 0;
+  const rectangles = [...nodes, ...titles];
+  const borderSegments = frames.flatMap(frameBorderSegments);
+  const clearRect = (rect, index) => rect.x >= 0 && rect.y >= 0
+    && rect.x + rect.width <= viewBox[0] && rect.y + rect.height <= placementBottom
+    && !rectangles.some(node => rectsOverlap(rect, node, 2))
+    && !currentLabels.some((other, i) => i !== index && rectsOverlap(rect, other, 2));
+  const intrudes = (route, points) => nodes.some(node => segments(points).some((segment, index) => (
+    !((node.id === route.relation.from && index === 0)
+      || (node.id === route.relation.to && index === points.length - 2))
+    && segmentIntersectsRect(segment, node, 2)
+  )));
+  const routeClear = (route, points, nextLabels, nextRoutes, bottom) => {
+    const { fromSide, toSide } = sideFor(route.relation);
+    return routeHonorsEndpointSides(points, fromSide, toSide)
+      && points.every(([x, y]) => x >= 0 && y >= 0 && x <= viewBox[0] && y <= bottom)
+      && !intrudes(route, points)
+      && !collectRouteRhythmIssues({ routedRelations: [{ points }] }).length
+      && !collectBorderRuns({ routedRelations: [{ points }], frames }).some(hit => hit.side !== 'bottom')
+      && !nextLabels.some(rect => rect.relationIndex !== route.relationIndex && masks(points, rect))
+      && nextLabels.filter(rect => rect.relationIndex === route.relationIndex).every(rect => distance(points, rect) <= 36)
+      && nextRoutes.every(other => other.relationIndex === route.relationIndex
+        || !pinned(other.relation) || crossingCount(points, other.points) === 0)
+      && nextRoutes.every(other => other.relationIndex === route.relationIndex
+        || !collectAmbiguousCorridors({ routedRelations: [{ ...route, points }, other],
+          includeSharedEndpoints: () => true }).length
+        || collectAmbiguousCorridors({ routedRelations: [route, currentRoutes.find(r => r.relationIndex === other.relationIndex)],
+          includeSharedEndpoints: () => true }).length > 0);
+  };
+  for (const [labelIndex, label] of currentLabels.entries()) {
+    if (searches >= maximumSearches) break;
+    const own = currentRoutes.find(route => route.relationIndex === label.relationIndex);
+    if (!own || pinned(own.relation)
+      || (!currentRoutes.some(route => route !== own && masks(route.points, label))
+        && !nodes.some(node => rectsOverlap(label, node, -2)))) continue;
+    const { fromSide, toSide } = sideFor(own.relation);
+    const ownOptions = new Map([[JSON.stringify(own.points), own.points]]);
+    for (const endpointStubPx of [24, 16]) automaticPortRhythmBridge(own.points[0], own.points.at(-1), fromSide, toSide, {
+      endpointStubPx, accept: points => { ownOptions.set(JSON.stringify(points), points); return false; },
+    });
+    const xs = new Set([label.x]), ys = new Set([label.y]);
+    for (const points of ownOptions.values()) for (const { start, end } of segments(points)) {
+      for (const x of [start[0], end[0], (start[0] + end[0]) / 2]) xs.add(x - label.width / 2);
+      for (const y of [start[1], end[1], (start[1] + end[1]) / 2]) {
+        ys.add(y - label.height - 4); ys.add(y + 4);
+      }
+    }
+    const neighbours = [...rectangles, ...currentLabels.filter((_, index) => index !== labelIndex)];
+    for (const rect of neighbours) {
+      xs.add(rect.x - label.width - 2); xs.add(rect.x + rect.width + 2);
+      ys.add(rect.y - label.height - 2); ys.add(rect.y + rect.height + 2);
+    }
+    for (const route of currentRoutes) for (const { start, end } of segments(route.points)) {
+      if (start[0] === end[0]) { xs.add(start[0] - label.width - 8); xs.add(start[0] + 8); }
+      if (start[1] === end[1]) { ys.add(start[1] - label.height - 8); ys.add(start[1] + 8); }
+    }
+    const xPoints = [...ownOptions.values()].flatMap(points => points.map(point => point[0]));
+    const yPoints = [...ownOptions.values()].flatMap(points => points.map(point => point[1]));
+    const candidates = [];
+    for (const x of xs) {
+      if (x + label.width < Math.min(...xPoints) - 36 || x > Math.max(...xPoints) + 36) continue;
+      for (const y of ys) {
+        if (y + label.height < Math.min(...yPoints) - 36 || y > Math.max(...yPoints) + 36) continue;
+        const rect = { ...label, x, y, lx: x + label.width / 2, ly: y + (label.ly - label.y) };
+        if (!clearRect(rect, labelIndex)) continue;
+        for (const points of ownOptions.values()) {
+          const ownDistance = distance(points, rect);
+          if (ownDistance < 4 || ownDistance > 36) continue;
+          const nextLabels = currentLabels.map((other, index) => index === labelIndex ? rect : other);
+          if (!routeClear(own, points, nextLabels, currentRoutes, placementBottom)) continue;
+          const blocked = currentRoutes.filter(route => route !== own && masks(route.points, rect));
+          if (blocked.length > 4 || blocked.some(route => pinned(route.relation))) continue;
+          const stableDistance = Math.min(...currentRoutes.filter(route => route !== own && !blocked.includes(route))
+            .map(route => distance(route.points, rect)));
+          if (ownDistance > stableDistance + 0.0001) continue;
+          candidates.push({ rect, points, blocked, ownDistance, move: Math.hypot(x - label.x, y - label.y) });
+        }
+      }
+    }
+    candidates.sort((a, b) => a.blocked.length - b.blocked.length || a.ownDistance - b.ownDistance || a.move - b.move);
+    const chosen = [];
+    // Avoid spending every search on virtually identical neighbouring slots.
+    for (const c of candidates) {
+      if (chosen.some(other => Math.hypot(c.rect.x - other.rect.x, c.rect.y - other.rect.y) < 8
+        && JSON.stringify(c.points) === JSON.stringify(other.points))) continue;
+      chosen.push(c); if (chosen.length >= 16) break;
+    }
+    let accepted = null;
+    for (const candidate of chosen) {
+      if (searches >= maximumSearches) break;
+      const nextLabels = currentLabels.map((other, index) => index === labelIndex ? candidate.rect : other);
+      const nextRoutes = currentRoutes.map(route => route === own ? { ...route, points: candidate.points } : route);
+      // Free the longest occupied corridor first. Each subsequent route sees
+      // the accepted proposal; all unchanged routes remain obstacles.
+      const blocked = [...candidate.blocked].sort((a, b) => length(b.points) - length(a.points));
+      let failed = false;
+      for (const old of blocked) {
+        if (searches >= maximumSearches) { failed = true; break; }
+        searches++;
+        const { fromSide, toSide } = sideFor(old.relation);
+        const obstacles = [
+          ...nodes.map(node => [old.relation.from, old.relation.to].includes(node.id) ? node : {
+            ...node, x: node.x - 12, y: node.y - 12, width: node.width + 24, height: node.height + 24,
+          }), ...titles,
+          ...nextLabels.filter(rect => rect.relationIndex !== old.relationIndex).map(rect => ({
+            ...rect, x: rect.x - 2, y: rect.y - 2, width: rect.width + 4, height: rect.height + 4,
+          })),
+        ];
+        const found = shortestOrthogonalGridRoute({ start: old.points[0], end: old.points.at(-1),
+          points: [old.points[0], old.points.at(-1)], fromSide, toSide, obstacles,
+          clearance: 2, maximumObstacleCount: 80, endpointStubPx: 24, maximumGridNodes: 4096,
+          avoidedSegments: nextRoutes.filter(other => other.relationIndex !== old.relationIndex
+            && !related(old.relation, other.relation)).flatMap(other => segments(other.points)),
+          allowAvoidedCrossings: true, minimumAvoidedOverlapPx: 8, routeSeparationPx: 8,
+          minimumSegmentPx: 16, bendPenaltyPx: 48, borderSegments,
+          accept: points => routeClear(old, points, nextLabels, nextRoutes, placementBottom + label.height),
+        });
+        const points = found && normalizeRoutePoints(found.points);
+        if (!points) { failed = true; break; }
+        nextRoutes[nextRoutes.findIndex(route => route.relationIndex === old.relationIndex)] = { ...old, points };
+      }
+      if (failed) continue;
+      const foreignDistance = Math.min(...nextRoutes.filter(route => route.relationIndex !== own.relationIndex)
+        .map(route => distance(route.points, candidate.rect)));
+      // The original label is invalid. A collision-free repair may need a longer
+      // corridor; never rank that invalid geometry above a valid proposal.
+      if (candidate.ownDistance > foreignDistance + 0.0001) continue;
+      accepted = { labels: nextLabels, routes: nextRoutes }; break;
+    }
+    if (accepted) { currentLabels = accepted.labels; currentRoutes = accepted.routes; }
+  }
+  Object.assign(metrics, { searches, maximumSearches, changedLabels: currentLabels.filter((rect, i) => rect !== labels[i]).length,
+    changedRoutes: currentRoutes.filter((route, i) => route !== routes[i]).length });
+  return { labels: currentLabels, routes: currentRoutes };
+}

package/ai/skills/stacks-technical-diagrams/renderers/dataflow/label-capacity.mjs

@@ -0,0 +1,81 @@
+import { textUnits } from '../shared/utils.mjs';
+import { rectsOverlap, segmentRectClearanceWithin } from '../shared/geometry.mjs';
+
+export const FLOW_LABEL_HEIGHT = 16;
+export function flowLabelSize(flow, lines = [flow.label]) {
+  const longestLine = Math.max(...lines.map(textUnits), textUnits(flow.classification || ''));
+  return {
+    width: Math.round(Math.max(34, longestLine * 4.9 + 12) * 10) / 10,
+    height: FLOW_LABEL_HEIGHT + 11 * (lines.length - 1 + Number(Boolean(flow.classification))),
+  };
+}
+
+// A last capacity repair after routing: two complete text rows can fit beside
+// a short arrow where one wide row cannot. Never move a route or a valid label.
+export function wrapBlockedFlowLabels({ labels, routes, components, titles, viewBox, placementBottom }) {
+  const placed = [...labels];
+  const segments = routes.flatMap(route => route.points.slice(1).map((end, index) => ({
+    relationIndex: route.relationIndex, start: route.points[index], end,
+  })));
+  const inside = rect => rect.x >= 0 && rect.y >= 0
+    && rect.x + rect.width <= viewBox[0] && rect.y + rect.height <= placementBottom;
+  const masks = (segment, rect) => segmentRectClearanceWithin(segment, rect, 4) + 0.0001 < 4;
+  const obstacles = [...components, ...titles];
+  let wordSegmenter;
+  for (const [index, label] of placed.entries()) {
+    if (['labelAt', 'labelDx', 'labelDy', 'labelSegment'].some(key => label.relation[key] !== undefined)) continue;
+    if (inside(label) && !components.some(rect => rectsOverlap(label, rect, -2))
+      && !titles.some(rect => rectsOverlap(label, rect))
+      && !placed.some((rect, i) => i !== index && rectsOverlap(label, rect))
+      && !segments.some(segment => segment.relationIndex !== label.relationIndex && masks(segment, label))) continue;
+    const text = label.label;
+    wordSegmenter ||= new Intl.Segmenter(undefined, { granularity: 'word' });
+    const shapes = [...wordSegmenter.segment(text)].slice(1).map(({ index: split }) => {
+      const lines = [text.slice(0, split), text.slice(split)];
+      return { lines, ...flowLabelSize(label.relation, lines) };
+    }).filter(shape => shape.lines.every(line => line.trim()) && shape.width < label.width)
+      .sort((a, b) => a.width - b.width).slice(0, 8);
+    const blockers = [
+      ...obstacles.map(rect => ({ rect, gap: 2 })),
+      ...placed.filter((_, i) => i !== index).map(rect => ({ rect, gap: 2 })),
+      ...segments.map(segment => ({ rect: {
+        x: Math.min(segment.start[0], segment.end[0]), y: Math.min(segment.start[1], segment.end[1]),
+        width: Math.abs(segment.end[0] - segment.start[0]), height: Math.abs(segment.end[1] - segment.start[1]),
+      }, gap: 4 })),
+    ];
+    let probes = 0;
+    const seen = new Set();
+    search: for (const shape of shapes) {
+      for (const segment of segments.filter(segment => segment.relationIndex === label.relationIndex)) {
+        const [a, b] = [segment.start, segment.end];
+        if (Math.abs(a[1] - b[1]) > 0.0001) continue;
+        const low = Math.min(a[0], b[0]) + 8, high = Math.max(a[0], b[0]) - shape.width - 8;
+        if (high < low) continue;
+        const ys = [a[1] - shape.height - 4, a[1] + 4];
+        if (label.y > a[1]) ys.reverse();
+        for (const y of ys) {
+          const positions = [Math.max(low, Math.min(high, label.lx - shape.width / 2)), low, high];
+          for (const { rect, gap } of blockers) {
+            if (y + shape.height + gap <= rect.y || rect.y + rect.height + gap <= y) continue;
+            positions.push(rect.x - gap - shape.width, rect.x + rect.width + gap);
+          }
+          const xs = [...new Set(positions)].filter(x => x >= low && x <= high)
+            .sort((a, b) => Math.abs(a + shape.width / 2 - label.lx) - Math.abs(b + shape.width / 2 - label.lx));
+          for (const x of xs) {
+            const key = `${x},${y},${shape.width},${shape.height}`;
+            if (seen.has(key)) continue;
+            seen.add(key);
+            if (probes++ >= 64) break search;
+            const rect = { ...label, ...shape, x, y, lx: x + shape.width / 2, ly: y + 11 };
+            if (!inside(rect) || obstacles.some(other => rectsOverlap(rect, other, 2))
+              || placed.some((other, i) => i !== index && rectsOverlap(rect, other, 2))
+              || segments.some(segment => masks(segment, rect))) continue;
+            placed[index] = rect;
+            break search;
+          }
+        }
+      }
+    }
+  }
+  return placed;
+}