refactor(cricket-surface): tighten degraded-host and row-repair helpers

Author: thomasasen

CHANGELOG.md

@@ -36,6 +36,9 @@ direkt zu einer versionierten Release-Sektion.
 - Nutzerwirkung: Keine beabsichtigte sichtbare Verhaltensänderung; die Cricket-Surface bleibt bei gemergten Reihen, Label-Markern und aktiver Spielerperspektive fachlich gleich, ist intern aber robuster gegen Sonar-bedingte Parser- und Row-Recovery-Bereinigungen abgesichert.
   Technik: `mark-parser`, `row-repair` und angrenzende `pipeline`-Helfer wurden lokal in kleinere Hilfsfunktionen zerlegt, nutzen `dataset` für Mark-/Spielerindex-Felder, entfernen einen fehlerhaften Extra-Argument-Aufruf im Grid-Row-Building und glätten einige eng benachbarte Pipeline-Klarheitsstellen; zusätzliche Parser-, Row-Repair- und Cricket-Render-State-Regressionen sichern Mark-Parsing, Shortfall-Recovery, explizite Spielerindizes und die Cricket-Board-Perspektive gegen Drift ab.
 
+- Nutzerwirkung: Keine beabsichtigte sichtbare Verhaltensänderung; die Cricket-Surface behandelt Match-Routen, degradierte Host-Erkennung und Row-Recovery weiterhin fachlich gleich, ist in diesen Pfaden aber enger gegen Sonar-bedingte Strukturbereinigungen und benachbarte DOM-Sonderfälle abgesichert.
+  Technik: `pipeline` und `row-repair` wurden in kleine Helper für Match-Route-Normalisierung, Degraded-Host-Pane-Auswahl, Active-Throw-Suppression und explizite Spaltenplanung zerlegt; ergänzende Runtime-Regressionen sichern dabei Query-/Hash-bereinigte Match-IDs, degradierte Hosts mit zusätzlichem Nebenknoten und Shortfall-ausgerichtete Cricket-Reihen ohne riskanten Snapshot-Breitumbau gegen Drift ab.
+
 ## [2.1.28] - 2026-04-18
 
 ### Added

dist/autodarts-xconfig.user.js

@@ -125,7 +125,7 @@ function normalizeHashValue(hashValue) {
 export function extractMatchRouteId(windowRef, documentRef) {
   const locationRef = windowRef?.location || documentRef?.defaultView?.location || null;
   const routePath = normalizeRoutePath(locationRef?.pathname || "");
-  const match = routePath.match(MATCH_ROUTE_PATTERN);
+  const match = MATCH_ROUTE_PATTERN.exec(routePath);
   return match?.[1] || "";
 }
 
@@ -272,6 +272,51 @@ function hasDegradedControlPaneText(node) {
   return /(20|19|18|17|16|15|bull)/i.test(compactText) || /\d{6,}/.test(compactText);
 }
 
+function selectDegradedHostPanePair(hostRect, childEntries) {
+  if (!hostRect || childEntries.length < 2) {
+    return null;
+  }
+
+  const dominantChildren = childEntries
+    .filter((entry) => entry.rect.height >= hostRect.height * DEGRADED_HOST_MIN_PANE_HEIGHT_RATIO)
+    .sort((left, right) => {
+      const leftArea = left.rect.width * left.rect.height;
+      const rightArea = right.rect.width * right.rect.height;
+      return rightArea - leftArea;
+    })
+    .slice(0, 2)
+    .sort((left, right) => left.rect.left - right.rect.left);
+
+  return dominantChildren.length === 2 ? dominantChildren : null;
+}
+
+function buildDegradedHostCandidate(current, gridRoot, hostRect, panePair) {
+  if (!Array.isArray(panePair) || panePair.length !== 2) {
+    return null;
+  }
+
+  const [leftPane, rightPane] = panePair;
+  const paneSpan = leftPane.rect.width + rightPane.rect.width;
+  const leftWidthRatio = hostRect.width > 0 ? leftPane.rect.width / hostRect.width : 0;
+  const rightWidthRatio = hostRect.width > 0 ? rightPane.rect.width / hostRect.width : 0;
+  if (
+    !containsNode(leftPane.node, gridRoot) ||
+    paneSpan < hostRect.width * DEGRADED_HOST_MIN_PANE_SPAN_RATIO ||
+    leftWidthRatio < DEGRADED_HOST_MIN_LEFT_PANE_WIDTH_RATIO ||
+    rightWidthRatio < DEGRADED_HOST_MIN_RIGHT_PANE_WIDTH_RATIO ||
+    !hasDegradedControlPaneText(rightPane.node)
+  ) {
+    return null;
+  }
+
+  return {
+    hostNode: current,
+    leftPaneNode: leftPane.node,
+    rightPaneNode: rightPane.node,
+    rightPaneText: readCompactNodeText(rightPane.node),
+  };
+}
+
 function findDegradedHostCandidate(extracted, options = {}) {
   const gridRoot = extracted?.gridSnapshot?.root || null;
   const documentRef = options.documentRef || extracted?.documentRef || null;
@@ -293,37 +338,10 @@ function findDegradedHostCandidate(extracted, options = {}) {
   while (current && current !== documentRef.body && current !== documentRef.documentElement) {
     const hostRect = readNodeRect(current);
     const childEntries = readVisibleChildEntries(current);
-    if (hostRect && childEntries.length >= 2) {
-      const dominantChildren = childEntries
-        .filter((entry) => entry.rect.height >= hostRect.height * DEGRADED_HOST_MIN_PANE_HEIGHT_RATIO)
-        .sort((left, right) => {
-          const leftArea = left.rect.width * left.rect.height;
-          const rightArea = right.rect.width * right.rect.height;
-          return rightArea - leftArea;
-        })
-        .slice(0, 2)
-        .sort((left, right) => left.rect.left - right.rect.left);
-
-      if (dominantChildren.length === 2) {
-        const [leftPane, rightPane] = dominantChildren;
-        const paneSpan = leftPane.rect.width + rightPane.rect.width;
-        const leftWidthRatio = hostRect.width > 0 ? leftPane.rect.width / hostRect.width : 0;
-        const rightWidthRatio = hostRect.width > 0 ? rightPane.rect.width / hostRect.width : 0;
-        if (
-          containsNode(leftPane.node, gridRoot) &&
-          paneSpan >= hostRect.width * DEGRADED_HOST_MIN_PANE_SPAN_RATIO &&
-          leftWidthRatio >= DEGRADED_HOST_MIN_LEFT_PANE_WIDTH_RATIO &&
-          rightWidthRatio >= DEGRADED_HOST_MIN_RIGHT_PANE_WIDTH_RATIO &&
-          hasDegradedControlPaneText(rightPane.node)
-        ) {
-          return {
-            hostNode: current,
-            leftPaneNode: leftPane.node,
-            rightPaneNode: rightPane.node,
-            rightPaneText: readCompactNodeText(rightPane.node),
-          };
-        }
-      }
+    const panePair = selectDegradedHostPanePair(hostRect, childEntries);
+    const candidate = buildDegradedHostCandidate(current, gridRoot, hostRect, panePair);
+    if (candidate) {
+      return candidate;
     }
 
     current = current.parentElement || null;
@@ -631,7 +649,7 @@ function hasOwnMarkValue(node, options = {}) {
   }
   const cricketRules = options.cricketRules;
   const allowTextMarkValue = options.allowTextMarkValue !== false;
-  if (typeof node.getAttribute === "function" && node.getAttribute("data-marks") !== null) {
+  if (Object.hasOwn(node?.dataset || {}, "marks")) {
     return true;
   }
   if (typeof node.querySelectorAll === "function") {
@@ -963,17 +981,8 @@ function haveEquivalentThrowSignatures(leftThrows, rightThrows, cricketRules, ta
   return left.every((entry, index) => entry === right[index]);
 }
 
-function shouldApplyActiveThrowPreview(options = {}) {
-  const gameState = options.gameState;
-  const cricketRules = options.cricketRules;
-  const targetOrder = options.targetOrder;
-  const activeThrows = Array.isArray(options.activeThrows) ? options.activeThrows : [];
-  const activePlayerIndex = Number.isFinite(Number(options.activePlayerIndex))
-    ? Math.max(0, Math.round(Number(options.activePlayerIndex)))
-    : 0;
-  const snapshotMatch = options.snapshotMatch || null;
-
-  const debug = {
+function createActiveThrowPreviewDebug(activeThrows, cricketRules, targetOrder) {
+  return {
     throwCount: activeThrows.length,
     applied: false,
     suppressionReason: "",
@@ -982,66 +991,120 @@ function shouldApplyActiveThrowPreview(options = {}) {
     activeThrowsSignature: toThrowSignatureParts(activeThrows, cricketRules, targetOrder).join(","),
     activeTurnSignature: "",
   };
+}
 
-  if (!activeThrows.length) {
-    debug.suppressionReason = "no-active-throws";
-    return debug;
-  }
-
+function readActiveTurnPreviewState(gameState, cricketRules, targetOrder) {
   const activeTurn =
     gameState && typeof gameState.getActiveTurn === "function"
       ? gameState.getActiveTurn()
       : null;
+  if (!activeTurn || typeof activeTurn !== "object") {
+    return {
+      finished: false,
+      signature: "",
+    };
+  }
 
-  if (activeTurn && typeof activeTurn === "object") {
-    debug.activeTurnSignature = toThrowSignatureParts(
+  return {
+    finished: Boolean(String(activeTurn.finishedAt || "").trim()),
+    signature: toThrowSignatureParts(
       Array.isArray(activeTurn.throws) ? activeTurn.throws : [],
       cricketRules,
       targetOrder
-    ).join(",");
-    debug.activeTurnFinished = Boolean(String(activeTurn.finishedAt || "").trim());
+    ).join(","),
+  };
+}
+
+function listSnapshotTurns(snapshotMatch) {
+  return Array.isArray(snapshotMatch?.turns)
+    ? snapshotMatch.turns.filter((turn) => turn && typeof turn === "object")
+    : [];
+}
+
+function isTurnOwnedByPlayer(turn, playerId) {
+  return String(turn?.playerId || "").trim() === playerId;
+}
+
+function isFinishedTurnWithThrows(turn) {
+  return Boolean(String(turn?.finishedAt || "").trim()) &&
+    Array.isArray(turn?.throws) &&
+    turn.throws.length > 0;
+}
+
+function shouldSuppressPreviewForFinishedSnapshotTurn(
+  snapshotMatch,
+  activePlayerIndex,
+  activeThrows,
+  cricketRules,
+  targetOrder
+) {
+  const activePlayerId = getPlayerIdByIndex(snapshotMatch, activePlayerIndex);
+  if (!activePlayerId) {
+    return false;
+  }
+
+  const turns = listSnapshotTurns(snapshotMatch);
+  const unfinishedTurnsForActivePlayer = turns.filter((turn) => {
+    return isTurnOwnedByPlayer(turn, activePlayerId) && !String(turn.finishedAt || "").trim();
+  });
+  if (unfinishedTurnsForActivePlayer.length > 0) {
+    return false;
+  }
+
+  const newestFinishedTurn = selectNewestTurnCandidate(
+    turns.filter((turn) => {
+      return isTurnOwnedByPlayer(turn, activePlayerId) && isFinishedTurnWithThrows(turn);
+    })
+  );
+  return Boolean(
+    newestFinishedTurn &&
+      haveEquivalentThrowSignatures(
+        newestFinishedTurn.throws,
+        activeThrows,
+        cricketRules,
+        targetOrder
+      )
+  );
+}
+
+function shouldApplyActiveThrowPreview(options = {}) {
+  const gameState = options.gameState;
+  const cricketRules = options.cricketRules;
+  const targetOrder = options.targetOrder;
+  const activeThrows = Array.isArray(options.activeThrows) ? options.activeThrows : [];
+  const activePlayerIndex = Number.isFinite(Number(options.activePlayerIndex))
+    ? Math.max(0, Math.round(Number(options.activePlayerIndex)))
+    : 0;
+  const snapshotMatch = options.snapshotMatch || null;
+
+  const debug = createActiveThrowPreviewDebug(activeThrows, cricketRules, targetOrder);
+
+  if (!activeThrows.length) {
+    debug.suppressionReason = "no-active-throws";
+    return debug;
   }
 
+  const activeTurnState = readActiveTurnPreviewState(gameState, cricketRules, targetOrder);
+  debug.activeTurnSignature = activeTurnState.signature;
+  debug.activeTurnFinished = activeTurnState.finished;
+
   if (debug.activeTurnFinished) {
     debug.suppressionReason = "active-turn-finished";
     return debug;
   }
 
-  if (snapshotMatch && Array.isArray(snapshotMatch.turns)) {
-    const activePlayerId = getPlayerIdByIndex(snapshotMatch, activePlayerIndex);
-    const turns = snapshotMatch.turns.filter((turn) => turn && typeof turn === "object");
-    const unfinishedTurnsForActivePlayer = turns.filter((turn) => {
-      return (
-        String(turn.playerId || "").trim() === activePlayerId &&
-        !String(turn.finishedAt || "").trim()
-      );
-    });
-
-    if (activePlayerId && unfinishedTurnsForActivePlayer.length === 0) {
-      const finishedTurnsForActivePlayer = turns.filter((turn) => {
-        return (
-          String(turn.playerId || "").trim() === activePlayerId &&
-          String(turn.finishedAt || "").trim() &&
-          Array.isArray(turn.throws) &&
-          turn.throws.length > 0
-        );
-      });
-
-      const newestFinishedTurn = selectNewestTurnCandidate(finishedTurnsForActivePlayer);
-      if (
-        newestFinishedTurn &&
-        haveEquivalentThrowSignatures(
-          newestFinishedTurn.throws,
-          activeThrows,
-          cricketRules,
-          targetOrder
-        )
-      ) {
-        debug.matchedFinishedTurn = true;
-        debug.suppressionReason = "matches-last-finished-turn";
-        return debug;
-      }
-    }
+  if (
+    shouldSuppressPreviewForFinishedSnapshotTurn(
+      snapshotMatch,
+      activePlayerIndex,
+      activeThrows,
+      cricketRules,
+      targetOrder
+    )
+  ) {
+    debug.matchedFinishedTurn = true;
+    debug.suppressionReason = "matches-last-finished-turn";
+    return debug;
   }
 
   debug.applied = true;