@depup/eslint-plugin-jsdoc 65.3.8-depup.0 → 65.3.12-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) @ 65.3.8 |
-| Processed | 2026-10-16 |
+| Original | [eslint-plugin-jsdoc](https://www.npmjs.com/package/eslint-plugin-jsdoc) @ 65.3.12 |
+| Processed | 2026-10-18 |
 | Smoke test | passed |
 | Deps updated | 2 |
 

package/changes.json

@@ -9,6 +9,6 @@
       "to": "^8.71.2"
     }
   },
-  "timestamp": "2026-10-16T16:10:29.118Z",
+  "timestamp": "2026-10-18T16:08:32.050Z",
   "totalUpdated": 2
 }

package/dist/jsdocUtils.d.ts

@@ -166,6 +166,13 @@ export function getAllTags(jsdoc: import("./iterateJsdoc.js").JsdocBlockWithInli
     line?: number | undefined;
     column?: number | undefined;
 }))[];
+/**
+ * Gets the default types of GCC Generic/Template types, e.g., `T[]` for
+ *   `@template [U=T[]]`
+ * @param {import('comment-parser').Spec} tag
+ * @returns {string[]}
+ */
+export function getClosureTemplateTagDefaults(tag: import("comment-parser").Spec): string[];
 /**
  * @param {import('./iterateJsdoc.js').Context[]} contexts
  * @param {import('./iterateJsdoc.js').CheckJsdoc} checkJsdoc

package/package.json

@@ -168,7 +168,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": "65.3.8-depup.0",
+  "version": "65.3.12-depup.0",
   "depup": {
     "changes": {
       "@es-joy/jsdoccomment": {
@@ -182,8 +182,8 @@
     },
     "depsUpdated": 2,
     "originalPackage": "eslint-plugin-jsdoc",
-    "originalVersion": "65.3.8",
-    "processedAt": "2026-10-16T16:10:53.200Z",
+    "originalVersion": "65.3.12",
+    "processedAt": "2026-10-18T16:09:00.345Z",
     "smokeTest": "passed"
   }
 }

package/src/iterateJsdoc.js

@@ -1891,7 +1891,7 @@ const getUtils = (
   utils.findContext = (contexts, comment) => {
     const foundContext = contexts.find((cntxt) => {
       return typeof cntxt === 'string' ?
-        esquery.matches(
+        cntxt === 'any' || esquery.matches(
           /** @type {Node} */ (node),
           esquery.parse(cntxt),
           undefined,
@@ -2667,7 +2667,9 @@ export default function iterateJsdoc (iterator, ruleConfig) {
           return iterateAllJsdocs(
             iterator,
             ruleConfig,
-            hasObjectAny ? /** @type {ContextObject[]} */ (contexts) : null,
+            hasObjectAny || ruleConfig.matchContext ?
+              /** @type {ContextObject[]} */ (contexts) :
+              null,
             ruleConfig.matchContext,
           ).create(context);
         }

package/src/jsdocUtils.js

@@ -1641,6 +1641,20 @@ const parseClosureTemplateTag = (tag) => {
     });
 };
 
+/**
+ * Gets the default types of GCC Generic/Template types, e.g., `T[]` for
+ *   `@template [U=T[]]`
+ * @param {import('comment-parser').Spec} tag
+ * @returns {string[]}
+ */
+const getClosureTemplateTagDefaults = (tag) => {
+  return splitTopLevelCommas(tag.name)
+    .map((type) => {
+      return type.trim().replace(/^\[?[^=]*(?:=(?<dflt>.*?)\]?)?$/v, '$<dflt>').trim();
+    })
+    .filter(Boolean);
+};
+
 /**
  * @typedef {true|string[]} DefaultContexts
  */
@@ -2200,6 +2214,7 @@ export {
   flattenRoots,
   forEachPreferredTag,
   getAllTags,
+  getClosureTemplateTagDefaults,
   getContextObject,
   getDocumentNamepathDefiningTags,
   getFunctionParameterNames,

package/src/rules/checkTemplateNames.js

@@ -2,6 +2,7 @@ import iterateJsdoc, {
   parseComment,
 } from '../iterateJsdoc.js';
 import {
+  getClosureTemplateTagDefaults,
   getTags,
 } from '../jsdocUtils.js';
 import {
@@ -46,13 +47,21 @@ export default iterateJsdoc(({
       return;
     }
 
-    traverse(parsedType, (nde) => {
+    traverse(parsedType, (nde, parentNode) => {
       const {
         type,
         value,
       } = /** @type {import('jsdoc-type-pratt-parser').NameResult} */ (nde);
       if (type === 'JsdocTypeName') {
         usedNames.add(value);
+      // An unquoted index of an indexed access type, e.g., `K` in `T[K]`
+      } else if (
+        type === 'JsdocTypeProperty' &&
+        parentNode?.type === 'JsdocTypeNamePath' &&
+        parentNode.pathType === 'property-brackets' &&
+        !(/** @type {import('jsdoc-type-pratt-parser').PropertyResult} */ (nde).meta.quote)
+      ) {
+        usedNames.add(value);
       }
     });
   };
@@ -76,6 +85,16 @@ export default iterateJsdoc(({
   };
 
   const checkTemplateTags = () => {
+    // A template name may be used only within the constraint or default of
+    //   another template, e.g., `T` in `@template {keyof T} K` or
+    //   `@template [U=T[]]`
+    for (const tag of templateTags) {
+      checkForUsedTypes(tag.type);
+      for (const defaultType of getClosureTemplateTagDefaults(tag)) {
+        checkForUsedTypes(defaultType);
+      }
+    }
+
     for (const tag of templateTags) {
       const names = utils.parseClosureTemplateTag(tag);
       for (const nme of names) {

package/src/rules/noMissingSyntax.js

@@ -65,7 +65,7 @@ export default iterateJsdoc(({
 
   setDefaults(state);
 
-  incrementSelector(state, contextStr, String(comment));
+  incrementSelector(state, contextStr, comment ?? '');
 }, {
   contextSelected: true,
   exit ({

package/src/rules/noUndefinedTypes.js

@@ -914,13 +914,24 @@ export default iterateJsdoc(({
             return;
           }
 
-          if (parent?.type === 'JsdocTypeFunction' &&
-            /** @type {import('jsdoc-type-pratt-parser').FunctionResult} */
-            (parent)?.typeParameters?.some((typeParam) => {
+          // Type parameters of a function type or signature (e.g.,
+          //   `<T>(x: T) => T` or `{<T>(x: T): T}`) are in scope anywhere
+          //   within that function type
+          /**
+           * @type {import('jsdoc-type-pratt-parser').NonRootResult & {
+           *   _parent?: import('jsdoc-type-pratt-parser').NonRootResult,
+           *   typeParameters?: import('jsdoc-type-pratt-parser').TypeParameterResult[]
+           * }|undefined}
+           */
+          let ancestor = parent;
+          while (ancestor) {
+            if (ancestor.typeParameters?.some((typeParam) => {
               return value === typeParam.name.value;
-            })
-          ) {
-            return;
+            })) {
+              return;
+            }
+
+            ancestor = ancestor._parent;
           }
 
           if (parent?.type === 'JsdocTypeInfer' && value === parent.element.value) {

package/src/rules/noUnnecessaryTypeAssertion.js

@@ -77,11 +77,10 @@ export default iterateJsdoc(({
 
       // eslint-disable-next-line no-console -- Warning user
       console.warn('⚠️ typescript is not installed. `jsdoc/no-unnecessary-type-assertion` will not work. To disable this warning, you must disable the rule.');
+      return;
     } finally {
       tsAttempted = true;
     }
-
-    return;
   }
 
   const types = utils.getTags('type');