@timber-js/app 0.2.0-alpha.21 → 0.2.0-alpha.211

package/src/routing/interception-overlap.ts

@@ -0,0 +1,141 @@
+/**
+ * Pattern intersection for intercepted URL patterns.
+ *
+ * Checks whether two intercepted URL patterns can both match the same concrete
+ * URL. Used by the cross-mode claim check (TIM-1319) to detect when a
+ * children-path interceptor and a slot interceptor from the same owner overlap.
+ *
+ * This is not the order-dependence oracle (`findOrderDependentCollision`) the
+ * within-mode collision checks use. `findInterceptionMatch` picks the mode by
+ * first-match on `pathnameMatchesPattern`, which has no priority tiers, so a
+ * static `/feed/foo` and a dynamic `/feed/[id]` both match `/feed/foo` even
+ * though `matchUrlParts` would resolve the static deterministically. The
+ * intersection test catches that: it walks both patterns segment by segment and
+ * asks whether any value satisfies both.
+ *
+ * This is not a model of `matchNode` precedence — that decides *which*
+ * candidate wins when several match one URL. This decides the prior question:
+ * *do* they both match one URL at all? The two questions are independent, and
+ * conflating them is what caused TIM-1308's five-round drift.
+ */
+
+import { classifyUrlSegment } from './segment-classify.ts';
+
+/**
+ * Check whether two intercepted URL patterns can both match the same concrete
+ * URL. Returns a display string for the overlapping URL, or null.
+ *
+ * Walks both patterns segment by segment:
+ * - Two statics: must be identical.
+ * - Static + dynamic: static must satisfy the dynamic's affix constraints.
+ * - Two dynamics: affix constraints must be compatible.
+ * - A catch-all at either side: compatible with everything remaining.
+ *
+ * If the patterns differ in length, they can only overlap if the longer one's
+ * extra part is an optional catch-all (which also matches zero segments).
+ */
+export function interceptedPatternsOverlap(p1: string, p2: string): string | null {
+  if (p1 === p2) return p1;
+
+  const parts1 = p1 === '/' ? [] : p1.slice(1).split('/');
+  const parts2 = p2 === '/' ? [] : p2.slice(1).split('/');
+  const display: string[] = [];
+  let i = 0;
+
+  while (i < parts1.length && i < parts2.length) {
+    const seg1 = classifyUrlSegment(parts1[i]);
+    const seg2 = classifyUrlSegment(parts2[i]);
+
+    if (
+      seg1.kind === 'catch-all' ||
+      seg1.kind === 'optional-catch-all' ||
+      seg2.kind === 'catch-all' ||
+      seg2.kind === 'optional-catch-all'
+    ) {
+      display.push('<any>');
+      return '/' + display.join('/');
+    }
+
+    const part = segmentsOverlap(seg1, seg2);
+    if (part === null) return null;
+    display.push(part);
+    i++;
+  }
+
+  const remaining = i < parts1.length ? parts1 : i < parts2.length ? parts2 : null;
+  if (remaining) {
+    const next = classifyUrlSegment(remaining[i]);
+    if (next.kind !== 'optional-catch-all') return null;
+  }
+
+  return display.length === 0 ? '/' : '/' + display.join('/');
+}
+
+/**
+ * Can some concrete value satisfy both classified URL segments?
+ *
+ * An affixed dynamic (`a-[id].png`) constrains both the prefix and suffix of
+ * the value, so a static segment must satisfy those constraints and two
+ * dynamics must have compatible affixes — prefixes where one extends the other,
+ * and likewise for suffixes. Without this check, `/feed/photo.jpg` beside
+ * `/feed/asset-[id].png` would be falsely rejected.
+ */
+function segmentsOverlap(
+  seg1: ReturnType<typeof classifyUrlSegment>,
+  seg2: ReturnType<typeof classifyUrlSegment>
+): string | null {
+  if (seg1.kind === 'static' && seg2.kind === 'static') {
+    return seg1.value === seg2.value ? seg1.value : null;
+  }
+
+  if (seg1.kind === 'static' && seg2.kind === 'dynamic') {
+    return staticMatchesAffix(seg1.value, seg2) ? seg1.value : null;
+  }
+  if (seg2.kind === 'static' && seg1.kind === 'dynamic') {
+    return staticMatchesAffix(seg2.value, seg1) ? seg2.value : null;
+  }
+
+  if (seg1.kind === 'dynamic' && seg2.kind === 'dynamic') {
+    return dynamicAffixesCompatible(seg1, seg2) ? '<any>' : null;
+  }
+
+  return '<any>';
+}
+
+/**
+ * Does a static value satisfy an affixed dynamic's prefix, suffix, and
+ * non-empty capture constraints?
+ *
+ * Mirrors the check `pathnameMatchesPattern` applies: the value must start with
+ * the prefix, end with the suffix, and be strictly longer than their combined
+ * length (a capture of zero characters is not a match).
+ */
+function staticMatchesAffix(value: string, dynamic: { prefix?: string; suffix?: string }): boolean {
+  const prefix = dynamic.prefix ?? '';
+  const suffix = dynamic.suffix ?? '';
+  if (!prefix && !suffix) return true;
+  if (prefix && !value.startsWith(prefix)) return false;
+  if (suffix && !value.endsWith(suffix)) return false;
+  return value.length > prefix.length + suffix.length;
+}
+
+/**
+ * Can some value simultaneously satisfy two affixed dynamics?
+ *
+ * Two prefix constraints are compatible when one extends the other (a value
+ * starting with the longer one also starts with the shorter). Suffixes are
+ * analogous. Without affixes on either side, every value works.
+ */
+function dynamicAffixesCompatible(
+  d1: { prefix?: string; suffix?: string },
+  d2: { prefix?: string; suffix?: string }
+): boolean {
+  const p1 = d1.prefix ?? '',
+    s1 = d1.suffix ?? '';
+  const p2 = d2.prefix ?? '',
+    s2 = d2.suffix ?? '';
+
+  if (p1 && p2 && !p1.startsWith(p2) && !p2.startsWith(p1)) return false;
+  if (s1 && s2 && !s1.endsWith(s2) && !s2.endsWith(s1)) return false;
+  return true;
+}