Fix SonarQube issues in S2310 implementation

Reduce cognitive complexity (S3776) and nesting depth (S134) in the
checkCounter function by extracting the skip-ahead detection logic into
a standalone isIntentionalSkipAhead helper function. This moves the
UpdateExpression and compound assignment checks out of deeply nested
control flow, lowering checkCounter's cognitive complexity from 17 to ~8
(allowed: 15) and eliminating nesting beyond 3 levels. No behavioral
changes; all existing tests pass.

Author: Vibe Bot

package-lock.json

@@ -0,0 +1,38 @@
+[
+  {
+    "rule": "typescript:S3776",
+    "component": "org.sonarsource.javascript:javascript:packages/jsts/src/rules/S2310/rule.ts",
+    "line": 47,
+    "message": "Refactor this function to reduce its Cognitive Complexity from 17 to the 15 allowed.",
+    "textRange": {
+      "startLine": 47,
+      "endLine": 47,
+      "startOffset": 13,
+      "endOffset": 25
+    }
+  },
+  {
+    "rule": "typescript:S134",
+    "component": "org.sonarsource.javascript:javascript:packages/jsts/src/rules/S2310/rule.ts",
+    "line": 59,
+    "message": "Refactor this code to not nest more than 3 if/for/while/switch/try statements.",
+    "textRange": {
+      "startLine": 59,
+      "endLine": 59,
+      "startOffset": 12,
+      "endOffset": 14
+    }
+  },
+  {
+    "rule": "typescript:S134",
+    "component": "org.sonarsource.javascript:javascript:packages/jsts/src/rules/S2310/rule.ts",
+    "line": 62,
+    "message": "Refactor this code to not nest more than 3 if/for/while/switch/try statements.",
+    "textRange": {
+      "startLine": 62,
+      "endLine": 62,
+      "startOffset": 12,
+      "endOffset": 14
+    }
+  }
+]

packages/.sonar-analysis/external-issues.json

@@ -51,17 +51,8 @@ export const rule: Rule.RuleModule = {
       }
       for (const ref of variable.references) {
         if (ref.isWrite() && isUsedInsideBody(ref.identifier, block)) {
-          // Allow UpdateExpression (i++, i--, ++i, --i) and compound assignments (i+=n, i-=n, etc.)
-          // Only report simple assignments (i = value) which indicate early-exit patterns
-          // Exception: modifications in nested for-loop update clauses should still be reported
-          const parent = getNodeParent(ref.identifier);
-          if (!isInNestedForLoopUpdate(ref.identifier, block)) {
-            if (parent?.type === 'UpdateExpression') {
-              continue;
-            }
-            if (parent?.type === 'AssignmentExpression' && parent.operator !== '=') {
-              continue;
-            }
+          if (isIntentionalSkipAhead(ref.identifier, block)) {
+            continue;
           }
           report(
             context,
@@ -108,6 +99,25 @@ function collectCountersFor(updateExpression: estree.Expression, counters: estre
   }
 }
 
+/**
+ * Checks if a loop counter modification is an intentional skip-ahead pattern
+ * (UpdateExpression or compound assignment) rather than a simple assignment.
+ * Modifications in nested for-loop update clauses are not considered skip-ahead.
+ */
+function isIntentionalSkipAhead(id: estree.Identifier, outerLoopBody: estree.Node): boolean {
+  if (isInNestedForLoopUpdate(id, outerLoopBody)) {
+    return false;
+  }
+  const parent = getNodeParent(id);
+  if (parent?.type === 'UpdateExpression') {
+    return true;
+  }
+  if (parent?.type === 'AssignmentExpression' && parent.operator !== '=') {
+    return true;
+  }
+  return false;
+}
+
 function isUsedInsideBody(id: estree.Identifier, loopBody: estree.Node) {
   const bodyRange = loopBody.range;
   return id.range && bodyRange && id.range[0] > bodyRange[0] && id.range[1] < bodyRange[1];