astro-archify 0.3.4 → 0.3.6

package/vendor/archify/renderers/shared/geometry.mjs

@@ -344,7 +344,6 @@ export function cleanFlowProblems({
   diagramType,
   relationCollection,
   obstacleKind,
-  profile,
   clearance = 2,
   routeHint = 'adjust fromSide/toSide, set route/via or channel coordinates, or move the obstacle'
 }) {
@@ -399,6 +398,85 @@ export function cleanFlowProblems({
   return problems;
 }
 
+// Build a read-only analysis copy of a polyline with straight-through
+// waypoints removed. A waypoint on a forward-collinear run is not a visual
+// endpoint, so treating it as one would hide a proper X that lands exactly on
+// that waypoint. Reversals and real bends stay split: their shared point can
+// still be an authored touch rather than a crossing. The source points are
+// retained on every merged segment so diagnostics can name the authored
+// segment that contains a hit without changing rendered/receipt geometry.
+export function forwardCollinearAnalysisSegments(points) {
+  const segments = [];
+  for (let segmentIndex = 0; segmentIndex < asArray(points).length - 1; segmentIndex += 1) {
+    const authoredStart = points[segmentIndex];
+    const authoredEnd = points[segmentIndex + 1];
+    const start = Array.isArray(authoredStart) ? [...authoredStart] : authoredStart;
+    const end = Array.isArray(authoredEnd) ? [...authoredEnd] : authoredEnd;
+    const sourceSegment = { start, end, segmentIndex };
+    const previous = segments.at(-1);
+    if (previous && segmentsContinueForward(previous.start, previous.end, start, end)) {
+      previous.end = end;
+      previous.sourceSegments.push(sourceSegment);
+      continue;
+    }
+    segments.push({
+      start,
+      end,
+      segmentIndex,
+      sourceSegments: [sourceSegment],
+    });
+  }
+  return segments;
+}
+
+export function sourceSegmentIndexAtPoint(segment, point) {
+  const source = asArray(segment?.sourceSegments).find(({ start, end }) => (
+    pointLiesOnSegment(point, start, end)
+  ));
+  return source?.segmentIndex ?? segment?.segmentIndex ?? 0;
+}
+
+function authoredAnalysisSegments(points) {
+  return asArray(points).slice(0, -1).map((start, segmentIndex) => ({
+    start,
+    end: points[segmentIndex + 1],
+    segmentIndex,
+    sourceSegments: [{ start, end: points[segmentIndex + 1], segmentIndex }],
+  }));
+}
+
+function segmentsContinueForward(firstStart, firstEnd, secondStart, secondEnd) {
+  if (![firstStart, firstEnd, secondStart, secondEnd].every((point) => (
+    Array.isArray(point) && point.length === 2 && isFinitePoint(...point)
+  ))) return false;
+  const epsilon = 0.0001;
+  if (Math.abs(firstEnd[0] - secondStart[0]) > epsilon
+    || Math.abs(firstEnd[1] - secondStart[1]) > epsilon) return false;
+  const firstVector = [firstEnd[0] - firstStart[0], firstEnd[1] - firstStart[1]];
+  const secondVector = [secondEnd[0] - secondStart[0], secondEnd[1] - secondStart[1]];
+  const firstLength = Math.hypot(...firstVector);
+  const secondLength = Math.hypot(...secondVector);
+  if (firstLength <= epsilon || secondLength <= epsilon) return false;
+  const cross = firstVector[0] * secondVector[1] - firstVector[1] * secondVector[0];
+  if (Math.abs(cross) > epsilon) return false;
+  const dot = firstVector[0] * secondVector[0] + firstVector[1] * secondVector[1];
+  return dot > epsilon;
+}
+
+function pointLiesOnSegment(point, start, end) {
+  if (![point, start, end].every((candidate) => (
+    Array.isArray(candidate) && candidate.length === 2 && isFinitePoint(...candidate)
+  ))) return false;
+  const epsilon = 0.0001;
+  const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+  if (length <= epsilon) return Math.hypot(point[0] - start[0], point[1] - start[1]) <= epsilon;
+  if (Math.abs(crossProduct(start, end, point)) > epsilon * length) return false;
+  return point[0] >= Math.min(start[0], end[0]) - epsilon
+    && point[0] <= Math.max(start[0], end[0]) + epsilon
+    && point[1] >= Math.min(start[1], end[1]) - epsilon
+    && point[1] <= Math.max(start[1], end[1]) + epsilon;
+}
+
 // Reject only a proper interior X between relationships that share no semantic
 // endpoint. Endpoint touches, branch/merge ports, and collinear shared
 // corridors are intentionally outside this contract because geometry alone
@@ -410,17 +488,24 @@ export function cleanCrossingProblems({
   diagramType,
   relationCollection,
   profile = 'standard',
+  profileIsAuthoritative = false,
+  mergeForwardCollinearWaypoints = false,
   routeHint = 'adjust route/via or channel coordinates so the relationships use separate corridors'
 }) {
-  const requestedProfile = process.env.ARCHIFY_QUALITY_PROFILE || profile;
-  const activeProfile = requestedProfile === 'showcase' ? 'showcase' : 'standard';
-  if (activeProfile !== 'showcase') return [];
+  if (qualityProfileForGate(profile, profileIsAuthoritative) !== 'showcase') return [];
   const routed = asArray(relations).map((relation, index) => {
     if (!relation || !endpointIds.has(relation.from) || !endpointIds.has(relation.to)) return null;
     const points = pathFor(relation)?.points;
     if (!Array.isArray(points) || points.length < 2) return null;
     if (!points.every((point) => Array.isArray(point) && point.length === 2 && isFinitePoint(...point))) return null;
-    return { relation, index, points };
+    return {
+      relation,
+      index,
+      points,
+      analysisSegments: mergeForwardCollinearWaypoints
+        ? forwardCollinearAnalysisSegments(points)
+        : authoredAnalysisSegments(points),
+    };
   }).filter(Boolean);
   const problems = [];
 
@@ -431,16 +516,21 @@ export function cleanCrossingProblems({
       if ([left.relation.from, left.relation.to].some((id) => id === right.relation.from || id === right.relation.to)) continue;
 
       let hit = null;
-      for (let leftSegment = 0; leftSegment < left.points.length - 1 && !hit; leftSegment += 1) {
-        for (let rightSegment = 0; rightSegment < right.points.length - 1; rightSegment += 1) {
+      for (const leftSegment of left.analysisSegments) {
+        if (hit) break;
+        for (const rightSegment of right.analysisSegments) {
           const point = properSegmentIntersection(
-            left.points[leftSegment],
-            left.points[leftSegment + 1],
-            right.points[rightSegment],
-            right.points[rightSegment + 1]
+            leftSegment.start,
+            leftSegment.end,
+            rightSegment.start,
+            rightSegment.end
           );
           if (point) {
-            hit = { point, leftSegment, rightSegment };
+            hit = {
+              point,
+              leftSegment: sourceSegmentIndexAtPoint(leftSegment, point),
+              rightSegment: sourceSegmentIndexAtPoint(rightSegment, point),
+            };
             break;
           }
         }
@@ -536,16 +626,12 @@ export function cleanAmbiguousCorridorProblems({
   diagramType,
   relationCollection,
   profile = 'standard',
+  profileIsAuthoritative = false,
   routeHint = 'adjust route/via or channel coordinates so the relationships use separate corridors',
   minOverlapPx = 8,
 }) {
-  const requestedProfile = process.env.ARCHIFY_QUALITY_PROFILE || profile;
-  if (requestedProfile !== 'showcase') return [];
-  const routedRelations = asArray(relations).map((relation, relationIndex) => {
-    if (!relation || typeof relation.from !== 'string' || typeof relation.to !== 'string') return null;
-    if (endpointIds && (!endpointIds.has(relation.from) || !endpointIds.has(relation.to))) return null;
-    return { relation, relationIndex, points: pathFor(relation)?.points };
-  }).filter(Boolean);
+  if (qualityProfileForGate(profile, profileIsAuthoritative) !== 'showcase') return [];
+  const routedRelations = collectEligibleRoutedRelations({ relations, endpointIds, pathFor });
 
   return collectAmbiguousCorridors({ routedRelations, minOverlapPx }).map((hit) => {
     const describe = ({ relation, relationIndex }) => {
@@ -634,14 +720,11 @@ export function cleanBorderRunProblems({
   diagramType,
   relationCollection,
   profile,
+  profileIsAuthoritative = false,
   routeHint = 'adjust route/via or channel coordinates so the relationship crosses the frame perpendicularly through a clear opening'
 }) {
-  if (!process.env.ARCHIFY_QUALITY_PROFILE && !profile) return [];
-  const routedRelations = asArray(relations).map((relation, relationIndex) => {
-    if (!relation || typeof relation.from !== 'string' || typeof relation.to !== 'string') return null;
-    if (endpointIds && (!endpointIds.has(relation.from) || !endpointIds.has(relation.to))) return null;
-    return { relation, relationIndex, points: pathFor(relation)?.points };
-  }).filter(Boolean);
+  if (!qualityProfileForGate(profile, profileIsAuthoritative)) return [];
+  const routedRelations = collectEligibleRoutedRelations({ relations, endpointIds, pathFor });
   return collectBorderRuns({ routedRelations, frames }).map((hit) => {
     const relation = hit.relation || {};
     const relationId = relation.id ? ` id "${relation.id}"` : '';
@@ -779,17 +862,13 @@ export function cleanRouteRhythmProblems({
   diagramType,
   relationCollection,
   profile,
+  profileIsAuthoritative = false,
   routeHint = 'move the channel/via point to remove the cramped turn or give the route more corridor space',
   interiorSegmentPx = 16,
   microSegmentPx = 8,
 }) {
-  const requestedProfile = process.env.ARCHIFY_QUALITY_PROFILE || profile;
-  if (requestedProfile !== 'showcase') return [];
-  const routedRelations = asArray(relations).map((relation, relationIndex) => {
-    if (!relation || typeof relation.from !== 'string' || typeof relation.to !== 'string') return null;
-    if (endpointIds && (!endpointIds.has(relation.from) || !endpointIds.has(relation.to))) return null;
-    return { relation, relationIndex, points: pathFor(relation)?.points };
-  }).filter(Boolean);
+  if (qualityProfileForGate(profile, profileIsAuthoritative) !== 'showcase') return [];
+  const routedRelations = collectEligibleRoutedRelations({ relations, endpointIds, pathFor });
   return collectRouteRhythmIssues({ routedRelations, interiorSegmentPx, microSegmentPx }).map((hit) => {
     const relation = hit.relation || {};
     const relationId = relation.id ? ` id "${relation.id}"` : '';
@@ -827,16 +906,12 @@ export function cleanLabelRouteClearanceProblems({
   diagramType,
   relationCollection,
   profile,
+  profileIsAuthoritative = false,
   threshold = 4,
   routeHint = 'adjust labelAt, labelDx, labelDy, or labelSegment; otherwise adjust the other relationship route/via/channel',
 }) {
-  const requestedProfile = process.env.ARCHIFY_QUALITY_PROFILE || profile;
-  if (requestedProfile !== 'showcase') return [];
-  const routedRelations = asArray(relations).map((relation, relationIndex) => {
-    if (!relation || typeof relation.from !== 'string' || typeof relation.to !== 'string') return null;
-    if (endpointIds && (!endpointIds.has(relation.from) || !endpointIds.has(relation.to))) return null;
-    return { relation, relationIndex, points: pathFor(relation)?.points };
-  }).filter(Boolean);
+  if (qualityProfileForGate(profile, profileIsAuthoritative) !== 'showcase') return [];
+  const routedRelations = collectEligibleRoutedRelations({ relations, endpointIds, pathFor });
   return collectLabelRouteClearance({ labels, routedRelations, threshold }).map((hit) => {
     const describe = (relation, relationIndex) => {
       const relationId = relation?.id ? ` id "${relation.id}"` : '';
@@ -868,6 +943,20 @@ export function cleanLabelRouteClearanceProblems({
   });
 }
 
+function qualityProfileForGate(profile, profileIsAuthoritative) {
+  return profileIsAuthoritative
+    ? profile
+    : process.env.ARCHIFY_QUALITY_PROFILE || profile;
+}
+
+function collectEligibleRoutedRelations({ relations, endpointIds, pathFor }) {
+  return asArray(relations).map((relation, relationIndex) => {
+    if (!relation || typeof relation.from !== 'string' || typeof relation.to !== 'string') return null;
+    if (endpointIds && (!endpointIds.has(relation.from) || !endpointIds.has(relation.to))) return null;
+    return { relation, relationIndex, points: pathFor(relation)?.points };
+  }).filter(Boolean);
+}
+
 function segmentPosition(index, segmentCount) {
   if (index === 0) return 'source-stub';
   if (index === segmentCount - 1) return 'target-stub';
@@ -1319,7 +1408,7 @@ export function suggestLabelObstacleFix(labelRect, lx, ly, obstacle, obstacleKin
 export function suggestLabelPairFix(a, b) {
   return [
     `  "${a.label}" ${formatRect(a)}; "${b.label}" ${formatRect(b)}`,
-    '  Suggested fix: add labelDy +24 on one edge, adjust labelDx, or remove one label',
+    '  Suggested fix: adjust labelDx/labelDy/labelSegment, or route one relationship through a separate corridor',
   ].join('\n');
 }