eslint-plugin-jsdoc 64.3.5 → 64.3.7

package/package.json

@@ -5,7 +5,7 @@
     "url": "http://gajus.com"
   },
   "dependencies": {
-    "@es-joy/jsdoccomment": "~0.96.0",
+    "@es-joy/jsdoccomment": "~0.97.0",
     "@es-joy/resolve.exports": "1.2.0",
     "@typescript-eslint/utils": "^8.69.0",
     "are-docs-informative": "^0.1.1",
@@ -51,7 +51,7 @@
     "camelcase": "^9.0.0",
     "chai": "^6.2.2",
     "decamelize": "^6.0.1",
-    "eslint": "10.9.1",
+    "eslint": "10.10.0",
     "eslint-config-canonical": "^47.4.2",
     "gitdown": "^4.1.1",
     "glob": "^13.0.6",
@@ -60,10 +60,10 @@
     "jsdoc-type-pratt-parser": "^9.2.1",
     "json-schema": "^0.4.0",
     "json-schema-to-typescript": "^16.0.0",
-    "lint-staged": "^17.4.1",
+    "lint-staged": "^17.5.0",
     "mocha": "^12.0.0",
     "open-editor": "^6.0.0",
-    "playwright": "^1.62.1",
+    "playwright": "^1.63.0",
     "replace": "^1.2.2",
     "rimraf": "^6.1.3",
     "semantic-release": "^25.0.9",
@@ -157,5 +157,5 @@
     "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.5"
+  "version": "64.3.7"
 }

package/src/rules/noUndefinedTypes.js

@@ -482,8 +482,10 @@ export default iterateJsdoc(({
     .concat(tsModuleVariables)
     .concat(/** @type {string[]} */ (definedPreferredTypes))
     .concat((() => {
-      // Other methods are not in scope, but we need them, and we grab them here
-      if (node?.type === 'MethodDefinition') {
+      // 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
+      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

package/src/rules/noUnnecessaryTypeAssertion.js

@@ -363,6 +363,51 @@ export default iterateJsdoc(({
       checker.isTupleType(assertedType);
   };
 
+  /**
+   * An array-literal annotation whose element type is a literal (or union of
+   * literals) — `type {ViewType[]}` on `['single-panel', 'user']` —
+   * narrows the element type that the bare literal would widen (`string[]` ->
+   * `ViewType[]`). Like the tuple idiom, the literal takes that element type
+   * only *from* the annotation, so the contextually-typed initializer echoes
+   * the asserted array straight back and the genuine narrowing looks redundant.
+   * @param {any} assertedType `ts.Type`
+   * @param {import('@typescript-eslint/utils').TSESTree.Node | null | undefined} operand
+   * @returns {boolean}
+   */
+  const narrowsArrayLiteralElement = (assertedType, operand) => {
+    if (operand?.type !== 'ArrayExpression' || !checker.isArrayType(assertedType)) {
+      return false;
+    }
+
+    const [
+      elementType,
+    ] = checker.getTypeArguments(assertedType);
+    return isLiteralType(elementType);
+  };
+
+  /**
+   * Whether `operand` is an object literal carrying a method or function-valued
+   * property. Under a surrounding `@type` object annotation such a function is
+   * contextually typed by the annotation — its otherwise-implicit-`any`
+   * parameters (and hence its signature) come straight from it — so
+   * `getTypeAtLocation` echoes the asserted object shape back and a genuine
+   * typing looks redundant. As elsewhere in this rule the uncontaminated type
+   * cannot be recovered here, so such literals are left alone (at the cost of
+   * missing the rare object annotation that only restates a fully
+   * self-evident method signature).
+   * @param {import('@typescript-eslint/utils').TSESTree.Node | null | undefined} operand
+   * @returns {boolean}
+   */
+  const hasContextuallyTypedFunctionMember = (operand) => {
+    return operand?.type === 'ObjectExpression' &&
+      operand.properties.some((property) => {
+        return property.type === 'Property' && (
+          property.value.type === 'FunctionExpression' ||
+          property.value.type === 'ArrowFunctionExpression'
+        );
+      });
+  };
+
   /**
    * Whether every element of `tupleType` is a literal type, so a `const`
    * assertion would reproduce the same element types (`['foo', 1]` but not
@@ -445,6 +490,13 @@ export default iterateJsdoc(({
       return;
     }
 
+    if (
+      narrowsArrayLiteralElement(declAssertedType, decl.init) ||
+      hasContextuallyTypedFunctionMember(decl.init)
+    ) {
+      return;
+    }
+
     if (isRedundantAssertion(declInferredType, declAssertedType)) {
       utils.reportJSDoc(message, types[0], fixer, true, {
         type: assertedTypeStr,
@@ -522,6 +574,13 @@ export default iterateJsdoc(({
     return;
   }
 
+  if (
+    narrowsArrayLiteralElement(castAssertedType, node) ||
+    hasContextuallyTypedFunctionMember(node)
+  ) {
+    return;
+  }
+
   if (!isRedundantAssertion(castInferredType, castAssertedType)) {
     return;
   }

package/src/rules/requireJsdoc.js

@@ -34,7 +34,6 @@ import {
 /** @type {import('json-schema').JSONSchema4} */
 const OPTIONS_SCHEMA = {
   additionalProperties: false,
-  description: 'Has the following optional keys.\n',
   properties: {
     checkAllFunctionExpressions: {
       default: false,