@depup/eslint-plugin-jsdoc 64.3.8-depup.0 → 64.3.10-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/eslint-plugin-jsdoc
 
 | Field | Value |
 |-------|-------|
-| Original | [eslint-plugin-jsdoc](https://www.npmjs.com/package/eslint-plugin-jsdoc) @ 64.3.8 |
-| Processed | 2026-09-09 |
+| Original | [eslint-plugin-jsdoc](https://www.npmjs.com/package/eslint-plugin-jsdoc) @ 64.3.10 |
+| Processed | 2026-09-12 |
 | Smoke test | passed |
 | Deps updated | 2 |
 

package/changes.json

@@ -9,6 +9,6 @@
       "to": "^1.4.9"
     }
   },
-  "timestamp": "2026-09-09T16:10:08.502Z",
+  "timestamp": "2026-09-12T16:08:52.008Z",
   "totalUpdated": 2
 }

package/package.json

@@ -162,7 +162,7 @@
     "test-cov": "TIMING=1 c8 --reporter text pnpm run test-no-cov",
     "test-index": "pnpm run test-no-cov test/rules/index.js"
   },
-  "version": "64.3.8-depup.0",
+  "version": "64.3.10-depup.0",
   "depup": {
     "changes": {
       "@typescript-eslint/utils": {
@@ -176,8 +176,8 @@
     },
     "depsUpdated": 2,
     "originalPackage": "eslint-plugin-jsdoc",
-    "originalVersion": "64.3.8",
-    "processedAt": "2026-09-09T16:10:35.569Z",
+    "originalVersion": "64.3.10",
+    "processedAt": "2026-09-12T16:09:18.335Z",
     "smokeTest": "passed"
   }
 }

package/src/rules/convertToJsdocComments.js

@@ -163,8 +163,11 @@ export default {
      * @param {import('eslint').Rule.Node} node
      * @param {AddComment} addComment
      * @param {import('../iterateJsdoc.js').Context[]} ctxts
+     * @param {Token} [locComment] Comment to anchor the report location to,
+     *   e.g., the first comment of a stacked group of line comments, so the
+     *   report does not read as though only the last line were at fault.
      */
-    const reportings = (comment, node, addComment, ctxts) => {
+    const reportings = (comment, node, addComment, ctxts, locComment) => {
       const fixer = getFixer(node, comment, addComment, ctxts);
 
       if (comment.type === 'Block') {
@@ -181,33 +184,89 @@ export default {
           return;
         }
 
-        report('lineCommentsJsdocStyle', comment, node, fixer);
+        report('lineCommentsJsdocStyle', locComment ?? comment, node, fixer);
       }
     };
 
+    /**
+     * Walks backward from a `//` comment which immediately precedes a node,
+     * collecting any directly adjacent (no intervening blank line) `//`
+     * comments stacked above it, so that the fixer can convert the whole
+     * run into a single JSDoc block instead of leaving all but the last
+     * line behind.
+     * @param {Token} comment
+     * @returns {Token[]}
+     */
+    const getPrecedingLineCommentGroup = (comment) => {
+      const group = [
+        comment,
+      ];
+      let current = comment;
+
+      for (;;) {
+        const prev = /** @type {Token|null} */ (
+          sourceCode.getTokenBefore(
+            /** @type {import('eslint').AST.Token} */ (current),
+            {
+              includeComments: true,
+            },
+          )
+        );
+
+        if (
+          !prev ||
+          prev.type !== 'Line' ||
+          // @ts-expect-error Ok
+          prev.loc.end.line !== current.loc.start.line - 1 ||
+          /** @type {string[]} */
+          (allowedPrefixes).some((prefix) => {
+            return prev.value.trimStart().startsWith(prefix);
+          })
+        ) {
+          break;
+        }
+
+        group.unshift(prev);
+        current = prev;
+      }
+
+      return group;
+    };
+
     /**
      * Builds the opening portion of the JSDoc comment, i.e. everything before
-     * the closing delimiter.
+     * the closing delimiter. When more than one comment is supplied (e.g., a
+     * stacked group of `//` lines), each is rendered on its own JSDoc line.
      * @param {string} indent
-     * @param {Token} comment
+     * @param {Token[]} comments
      * @param {boolean|undefined} inlineCommentBlock
      * @returns {string}
      */
-    const getCommentOpening = (indent, comment, inlineCommentBlock) => {
+    const getCommentOpening = (indent, comments, inlineCommentBlock) => {
       if (inlineCommentBlock || enforceJsdocLineStyle === 'single') {
-        return `/** ${comment.value.trim()} `;
+        return `/** ${comments.map((comment) => {
+          return comment.value.trim();
+        }).join(' ')} `;
       }
 
-      const body = comment.value.trimEnd();
+      if (comments.length === 1) {
+        const body = comments[0].value.trimEnd();
+
+        // When the comment's text already begins on its own line (e.g. a
+        // multi-line block comment), there is no need for the fixer to add a
+        // leading blank `*` line.
+        if ((/^[ \t]*\n/v).test(body)) {
+          return `/**${body.replace(/^[ \t]+/v, '')}\n${indent}`;
+        }
 
-      // When the comment's text already begins on its own line (e.g. a
-      // multi-line block comment), there is no need for the fixer to add a
-      // leading blank `*` line.
-      if ((/^[ \t]*\n/v).test(body)) {
-        return `/**${body.replace(/^[ \t]+/v, '')}\n${indent}`;
+        return `/**\n${indent}*${body}\n${indent}`;
       }
 
-      return `/**\n${indent}*${body}\n${indent}`;
+      const inner = comments.map((comment) => {
+        return `${indent}*${comment.value.trimEnd()}`;
+      }).join('\n');
+
+      return `/**\n${inner}\n${indent}`;
     };
 
     /**
@@ -228,19 +287,29 @@ export default {
 
       reportingNonJsdoc = true;
 
+      const commentGroup = comment.type === 'Line' ?
+        getPrecedingLineCommentGroup(/** @type {Token} */ (comment)) :
+        [
+          /** @type {Token} */ (comment),
+        ];
+
       /** @type {AddComment} */
       const addComment = (inlineCommentBlock, commentToAdd, indent, lines, fixer) => {
-        const insertion = getCommentOpening(indent, commentToAdd, inlineCommentBlock) +
+        const insertion = getCommentOpening(indent, commentGroup, inlineCommentBlock) +
             `*/${'\n'.repeat((lines || 1) - 1)}`;
 
-        return fixer.replaceText(
-          /** @type {import('eslint').AST.Token} */
-          (commentToAdd),
+        return fixer.replaceTextRange(
+          [
+            /* c8 ignore next -- Guard */
+            commentGroup[0].range?.[0] ?? 0,
+            /* c8 ignore next -- Guard */
+            commentToAdd.range?.[1] ?? 0,
+          ],
           insertion,
         );
       };
 
-      reportings(comment, node, addComment, contexts);
+      reportings(comment, node, addComment, contexts, commentGroup[0]);
     };
 
     /**
@@ -263,7 +332,9 @@ export default {
 
       /** @type {AddComment} */
       const addComment = (inlineCommentBlock, commentToAdd, indent, lines, fixer) => {
-        const insertion = getCommentOpening(indent, commentToAdd, inlineCommentBlock) +
+        const insertion = getCommentOpening(indent, [
+          /** @type {Token} */ (commentToAdd),
+        ], inlineCommentBlock) +
             `*/${'\n'.repeat((lines || 1) - 1)}${lines ? `\n${indent.slice(1)}` : ' '}`;
 
         return [

package/src/rules/noUndefinedTypes.js

@@ -483,32 +483,34 @@ export default iterateJsdoc(({
     .concat(/** @type {string[]} */ (definedPreferredTypes))
     .concat((() => {
       // Other class members are not in scope, but we need them (e.g., for a
-      //   sibling property or method referenced by `{@link}`), and we grab
-      //   them here
+      //   sibling property or method referenced by `{@link}`, or a member
+      //   referenced by `{@link}` from the class's own JSDoc block), and we
+      //   grab them here
+      /** @type {import('estree').ClassBody|undefined} */
+      let classBody;
+      /** @type {string|undefined} */
+      let className;
       if (node?.type === 'MethodDefinition' || node?.type === 'PropertyDefinition') {
-        return /** @type {import('estree').ClassBody} */ (node.parent).body.flatMap((methodOrProp) => {
-          if (methodOrProp.type === 'MethodDefinition') {
-            // eslint-disable-next-line unicorn/no-lonely-if -- Pattern
-            if (methodOrProp.key.type === 'Identifier') {
-              return [
-                methodOrProp.key.name,
-                `${/** @type {import('estree').ClassDeclaration} */ (
-                  node.parent?.parent
-                )?.id?.name}.${methodOrProp.key.name}`,
-              ];
-            }
-          }
+        classBody = /** @type {import('estree').ClassBody} */ (node.parent);
+        className = /** @type {import('estree').ClassDeclaration} */ (
+          node.parent?.parent
+        )?.id?.name;
+      } else if (node?.type === 'ClassDeclaration' || node?.type === 'ClassExpression') {
+        classBody = node.body;
+        className = node.id?.name;
+      }
 
-          if (methodOrProp.type === 'PropertyDefinition') {
-            // eslint-disable-next-line unicorn/no-lonely-if -- Pattern
-            if (methodOrProp.key.type === 'Identifier') {
-              return [
-                methodOrProp.key.name,
-                `${/** @type {import('estree').ClassDeclaration} */ (
-                  node.parent?.parent
-                )?.id?.name}.${methodOrProp.key.name}`,
-              ];
-            }
+      if (classBody) {
+        return classBody.body.flatMap((methodOrProp) => {
+          if (
+            (methodOrProp.type === 'MethodDefinition' ||
+            methodOrProp.type === 'PropertyDefinition') &&
+            methodOrProp.key.type === 'Identifier'
+          ) {
+            return [
+              methodOrProp.key.name,
+              `${className}.${methodOrProp.key.name}`,
+            ];
           }
           /* c8 ignore next 2 -- Not yet built */