fix(componentUtil): fix ESLint 10 getJSDocComment fallback semantics

The previous fallback used getCommentsBefore(classNode) directly, which
broke in two ways identified by reviewer haimuhaimu:

1. Node remapping: ESLint 9's SourceCode#getJSDocComment redirects
   exported class declarations to their export parent and class
   expressions to parent.parent. The fallback was calling getCommentsBefore
   on the class node itself, returning [] for those patterns.

2. Adjacency & intervening comments: getCommentsBefore does not enforce
   the 'at most one blank line' constraint. It also skips over line
   comments (// ...) to pick an earlier JSDoc, incorrectly returning a
   match where ESLint 9 would return null.

Fix mirrors ESLint's own ast-utils.js logic:
- isExportDeclaration(): detects export parent nodes for remapping
- findJSDocComment(): uses getTokenBefore(node, { includeComments: true })
  with the line-adjacency check (gap <= 1)
- getFunctionExpressionJSDocTarget(): extracted helper for the
  ArrowFunctionExpression/FunctionExpression parent-walk (also reduces
  getJSDocComment cognitive complexity from 21 to ~9)

ESLint 5-9 users are unaffected: the getJSDocComment native path is
taken whenever typeof sourceCode.getJSDocComment === 'function'.

Tests: 14 contract validation cases covering plain ClassDeclaration,
exported declarations (Named + Default), ClassExpression via parent.parent
remapping, blank-line separation, intervening line comments, and the
ESLint 9 native path (available / null / throws).

Author: plthomasva

lib/util/componentUtil.js

@@ -56,8 +56,80 @@ function isES5Component(node, context) {
   return false;
 }
 
+/**
+ * Checks whether a node represents an ES6 export declaration.
+ * Mirrors ESLint's own `isExportDeclaration` in ast-utils.
+ * @param {ASTNode} node
+ * @returns {boolean}
+ */
+function isExportDeclaration(node) {
+  return (
+    node.type === 'ExportDefaultDeclaration'
+    || node.type === 'ExportNamedDeclaration'
+    || node.type === 'ExportAllDeclaration'
+  );
+}
+
+/**
+ * Checks that `tokenBefore` is a JSDoc block comment immediately preceding
+ * `node` (at most one blank line between them). Mirrors ESLint's own
+ * `findJSDocComment` in ast-utils.
+ * @param {ASTNode} node The target AST node
+ * @param {any} sourceCode The ESLint source code object
+ * @returns {ASTNode | null}
+ */
+function findJSDocComment(node, sourceCode) {
+  // NOSONAR - Optional chaining requires Node 14+, but this plugin supports Node >=6. Remove when dropping Node < 14.
+  const tokenBefore = sourceCode.getTokenBefore(node, { includeComments: true });
+  if (
+    tokenBefore // NOSONAR
+    && tokenBefore.type === 'Block'
+    && tokenBefore.value.charAt(0) === '*'
+    && node.loc.start.line - tokenBefore.loc.end.line <= 1
+  ) {
+    return tokenBefore;
+  }
+  return null;
+}
+
+/**
+ * Walks up the parent chain from a function expression's immediate parent to
+ * find the appropriate ancestor node for a JSDoc look-up. Mirrors ESLint 9's
+ * internal walk in `SourceCode#getJSDocComment`.
+ * Returns the ancestor to search, or `null` to fall back to the function node.
+ * @param {ASTNode} parent The immediate parent of the function expression
+ * @param {any} sourceCode
+ * @returns {ASTNode | null}
+ */
+function getFunctionExpressionJSDocTarget(parent, sourceCode) {
+  if (!parent || parent.type === 'CallExpression' || parent.type === 'NewExpression') {
+    return null;
+  }
+  let target = parent;
+  while (
+    target
+    && !sourceCode.getCommentsBefore(target).length
+    && !/Function/u.test(target.type)
+    && target.type !== 'MethodDefinition'
+    && target.type !== 'Property'
+  ) {
+    target = target.parent;
+  }
+  if (target && target.type !== 'FunctionDeclaration' && target.type !== 'Program') {
+    return target;
+  }
+  return null;
+}
+
 /**
  * Retrieves the JSDoc comment for a given node.
+ *
+ * When `sourceCode.getJSDocComment` is available (ESLint ≤ 9) it is used
+ * directly. Otherwise (ESLint 10+, where the method was removed) this
+ * fallback mirrors the exact node-remapping and adjacency logic from
+ * ESLint's internal `getJSDocComment` / `findJSDocComment` in ast-utils.js
+ * so that the semantics remain identical across ESLint versions.
+ *
  * @param {any} sourceCode The ESLint source code object
  * @param {ASTNode} node The AST node
  * @returns {ASTNode | null} The JSDoc comment node or null
@@ -66,22 +138,44 @@ function getJSDocComment(sourceCode, node) {
   if (typeof sourceCode.getJSDocComment === 'function') {
     // Sometimes the passed node may not have been parsed yet by eslint, and this function call crashes.
     // Can be removed when eslint sets "parent" property for all nodes on initial AST traversal: https://github.com/eslint/eslint-scope/issues/27
-    // eslint-disable-next-line no-warning-comments
-    // FIXME: Remove try/catch when dropping support for ESLint < 8. // NOSONAR
+    // eslint-disable-next-line no-warning-comments -- ESLint <8 is still in peerDeps (^5||^6||^7); remove when those are dropped. // NOSONAR
+    // FIXME: Remove try/catch when dropping support for ESLint < 8.
     try {
       return sourceCode.getJSDocComment(node);
     } catch (e) { // NOSONAR
       return null;
     }
   }
-  const comments = sourceCode.getCommentsBefore(node);
-  for (let i = comments.length - 1; i >= 0; i--) {
-    const comment = comments[i];
-    if (comment.type === 'Block' && comment.value.startsWith('*')) {
-      return comment;
+
+  // ESLint 10+ fallback: replicate the node-remapping logic from ESLint 9's
+  // SourceCode#getJSDocComment so that exported declarations and class
+  // expressions are resolved to the correct parent node before the adjacency
+  // check is performed.
+  const parent = node.parent;
+  switch (node.type) {
+    case 'ClassDeclaration':
+    case 'FunctionDeclaration':
+      return findJSDocComment(
+        parent && isExportDeclaration(parent) ? parent : node,
+        sourceCode,
+      );
+
+    case 'ClassExpression': {
+      // class expression: `const Foo = class {}` → look at VariableDeclaration
+      // NOSONAR - Optional chaining requires Node 14+, but this plugin supports Node >=6. Remove when dropping Node < 14.
+      const classExprTarget = parent && parent.parent ? parent.parent : node; // NOSONAR
+      return findJSDocComment(classExprTarget, sourceCode);
+    }
+
+    case 'ArrowFunctionExpression':
+    case 'FunctionExpression': {
+      const fnTarget = getFunctionExpressionJSDocTarget(parent, sourceCode);
+      return findJSDocComment(fnTarget || node, sourceCode);
     }
+
+    default:
+      return null;
   }
-  return null;
 }
 
 /**