@depup/eslint-plugin-jsdoc 65.2.2-depup.0 → 65.3.0-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.2.2 |
-| Processed | 2026-10-09 |
+| Original | [eslint-plugin-jsdoc](https://www.npmjs.com/package/eslint-plugin-jsdoc) @ 65.3.0 |
+| Processed | 2026-10-12 |
 | Smoke test | passed |
 | Deps updated | 1 |
 

package/changes.json

@@ -5,6 +5,6 @@
       "to": "^8.71.1"
     }
   },
-  "timestamp": "2026-10-09T16:14:01.740Z",
+  "timestamp": "2026-10-12T00:39:11.741Z",
   "totalUpdated": 1
 }

package/dist/rules.d.ts

@@ -1348,6 +1348,10 @@ export interface Rules {
            * Whether to enable the fixer that removes the redundant `@type` tag (and the JSDoc block if it becomes empty). Defaults to `true`.
            */
           enableFixer?: boolean;
+          /**
+           * Whether the fixer may also remove a redundant assertion that is broader than the inferred type, which changes the declared, exported or returned type (e.g. `/** @type {unknown} * /` on a `string`). When `false`, such an assertion is still reported but not fixed. Only matters when `enableFixer` is `true`. Defaults to `true`.
+           */
+          fixTypeChangingCasts?: boolean;
           /**
            * Whether to report a non-`const` literal-tuple assertion on an array literal (e.g. `/** @type {['foo']} * / (['foo'])`) and fix it to the equivalent, more concise `/** @type {const} * /` assertion. Defaults to `false`.
            */

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.2.2-depup.0",
+  "version": "65.3.0-depup.0",
   "depup": {
     "changes": {
       "@typescript-eslint/utils": {
@@ -178,8 +178,8 @@
     },
     "depsUpdated": 1,
     "originalPackage": "eslint-plugin-jsdoc",
-    "originalVersion": "65.2.2",
-    "processedAt": "2026-10-09T16:14:20.835Z",
+    "originalVersion": "65.3.0",
+    "processedAt": "2026-10-12T00:39:34.382Z",
     "smokeTest": "passed"
   }
 }

package/src/iterateJsdoc.js

@@ -1418,6 +1418,7 @@ const getUtils = (
           source: '',
           tokens: seedTokens({
             delimiter: '*',
+            lineEnd: newLineEnd,
             start: indent + ' ',
           }),
         };

package/src/rules/convertToJsdocComments.js

@@ -64,7 +64,7 @@ export default {
      * @param {string} messageId
      * @param {import('estree').Comment|Token} comment
      * @param {import('eslint').Rule.Node} node
-     * @param {import('eslint').Rule.ReportFixer} fixer
+     * @param {import('eslint').Rule.ReportFixer|null} fixer
      */
     const report = (messageId, comment, node, fixer) => {
       const loc = {
@@ -167,9 +167,21 @@ export default {
      * @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.
+     * @param {Token[]} [commentGroup] The comments which the fixer would
+     *   convert. Defaults to just `comment`.
      */
-    const reportings = (comment, node, addComment, ctxts, locComment) => {
-      const fixer = getFixer(node, comment, addComment, ctxts);
+    const reportings = (comment, node, addComment, ctxts, locComment, commentGroup = [
+      /** @type {Token} */ (comment),
+    ]) => {
+      // A `*/` inside a comment's text would end the generated JSDoc block
+      // early, so leave such comments for the user to convert
+      const fixer = commentGroup.some(({
+        value,
+      }) => {
+        return value.includes('*/');
+      }) ?
+        null :
+        getFixer(node, comment, addComment, ctxts);
 
       if (comment.type === 'Block') {
         if (lineOrBlockStyle === 'line') {
@@ -310,7 +322,7 @@ export default {
         );
       };
 
-      reportings(comment, node, addComment, contexts, commentGroup[0]);
+      reportings(comment, node, addComment, contexts, commentGroup[0], commentGroup);
     };
 
     /**

package/src/rules/multilineBlocks.js

@@ -229,6 +229,7 @@ export default iterateJsdoc(({
           ...tokens,
         };
         utils.emptyTokens(tokens);
+        tokens.lineEnd = utils.newLineEnd;
         const {
           tokens: {
             delimiter,
@@ -294,6 +295,7 @@ export default iterateJsdoc(({
           ...line,
           delimiter,
           end: '',
+          lineEnd: utils.newLineEnd,
         });
       };
 

package/src/rules/noUnnecessaryTypeAssertion.js

@@ -95,6 +95,7 @@ export default iterateJsdoc(({
     // https://typescript-eslint.io/rules/no-unnecessary-type-assertion/
     checkLiteralConstAssertions = false,
     enableFixer = true,
+    fixTypeChangingCasts = true,
     preferConstToLiteralTuples = false,
     treatAnyAsRedundant = false,
     typesToIgnore = [],
@@ -354,6 +355,32 @@ export default iterateJsdoc(({
       checker.isTypeAssignableTo(assertedBaseType, inferredBaseType);
   };
 
+  /**
+   * Whether the fixer may remove a redundant assertion. With
+   * `fixTypeChangingCasts` (the default) every redundant assertion may be
+   * removed. Without it, a broader assertion (e.g. `unknown` on a `string`, or
+   * `'x' | 'y'` on `'x'`) is only reported, since dropping it would change the
+   * declared or returned type; it is removed only when the asserted type is
+   * also assignable back to the inferred one. A plain widening of a literal
+   * (`string` on `'hello'`) is the type TypeScript gives a mutable binding
+   * anyway, so it is kept removable.
+   * @param {any} rawInferredType `ts.Type`
+   * @param {any} rawAssertedType `ts.Type`
+   * @returns {boolean}
+   */
+  const mayRemove = (rawInferredType, rawAssertedType) => {
+    if (
+      fixTypeChangingCasts || assertedTypeStr === 'const' ||
+      checker.isTypeAssignableTo(rawAssertedType, rawInferredType)
+    ) {
+      return true;
+    }
+
+    const inferredBaseType = checker.getBaseTypeOfLiteralType(rawInferredType);
+    return checker.isTypeAssignableTo(inferredBaseType, rawAssertedType) &&
+      checker.isTypeAssignableTo(rawAssertedType, inferredBaseType);
+  };
+
   /**
    * A non-`const` tuple type annotation on an array literal (asserting `['foo']`
    * onto `['foo']`) turns the literal's inferred `T[]` into a tuple; since the
@@ -506,9 +533,15 @@ export default iterateJsdoc(({
     }
 
     if (isRedundantAssertion(declInferredType, declAssertedType)) {
-      utils.reportJSDoc(message, types[0], fixer, true, {
-        type: assertedTypeStr,
-      });
+      utils.reportJSDoc(
+        message,
+        types[0],
+        mayRemove(declInferredType, declAssertedType) ? fixer : null,
+        true,
+        {
+          type: assertedTypeStr,
+        },
+      );
     }
 
     return;
@@ -593,7 +626,7 @@ export default iterateJsdoc(({
     return;
   }
 
-  const canUnwrap = enableFixer && (
+  const canUnwrap = enableFixer && mayRemove(castInferredType, castAssertedType) && (
     unwrappableParentTypes.has(parent.type) ||
     (parent.type === 'ConditionalExpression' && parent.test !== node) ||
     ((parent.type === 'CallExpression' || parent.type === 'NewExpression') &&
@@ -651,6 +684,10 @@ export default iterateJsdoc(({
             description: 'Whether to enable the fixer that removes the redundant `@type` tag (and the JSDoc block if it becomes empty). Defaults to `true`.',
             type: 'boolean',
           },
+          fixTypeChangingCasts: {
+            description: 'Whether the fixer may also remove a redundant assertion that is broader than the inferred type, which changes the declared, exported or returned type (e.g. `/** @type {unknown} */` on a `string`). When `false`, such an assertion is still reported but not fixed. Only matters when `enableFixer` is `true`. Defaults to `true`.',
+            type: 'boolean',
+          },
           preferConstToLiteralTuples: {
             description: 'Whether to report a non-`const` literal-tuple assertion on an array literal (e.g. `/** @type {[\'foo\']} */ ([\'foo\'])`) and fix it to the equivalent, more concise `/** @type {const} */` assertion. Defaults to `false`.',
             type: 'boolean',

package/src/rules/requireJsdoc.js

@@ -715,10 +715,12 @@ export default {
             } = contxt;
             return ctxt === node.type;
           })) || {};
+        // Use the line break of the source for the generated block
+        const lineBreak = sourceCode.text.includes('\r\n') ? '\r\n' : '\n';
         const insertion = (inlineCommentBlock ?
           `/** ${fixerMessage}` :
-          `/**\n${indent}*${fixerMessage}\n${indent}`) +
-            `*/${'\n'.repeat(lines)}${indent.slice(0, -1)}`;
+          `/**${lineBreak}${indent}*${fixerMessage}${lineBreak}${indent}`) +
+            `*/${lineBreak.repeat(lines)}${indent.slice(0, -1)}`;
 
         return fixer.insertTextBefore(
           /** @type {import('eslint').Rule.Node} */

package/src/rules/requireParam.js

@@ -441,7 +441,7 @@ export default iterateJsdoc(({
           delimiter: '*',
           description: '',
           end: '',
-          lineEnd: '',
+          lineEnd: utils.newLineEnd,
           name: functionParameterName,
           newAdd: true,
           postDelimiter: ' ',

package/src/rules/tagLines.js

@@ -38,13 +38,16 @@ const checkMaxBlockLines = ({
       },
       () => {
         utils.setBlockDescription((info, seedTokens, descLines, postDelims) => {
+          // The run of newlines starts at the end of the preceding text line,
+          //   so the blank lines to drop begin after that line.
+          const excessStart = descLines[excessIndexLine] ? excessIndexLine + 1 : excessIndexLine;
           const newPostDelims = [
-            ...postDelims.slice(0, excessIndexLine),
-            ...postDelims.slice(excessIndexLine + excessBlockLines - 1 - maxBlockLines),
+            ...postDelims.slice(0, excessStart),
+            ...postDelims.slice(excessStart + excessBlockLines - 1 - maxBlockLines),
           ];
           return [
-            ...descLines.slice(0, excessIndexLine),
-            ...descLines.slice(excessIndexLine + excessBlockLines - 1 - maxBlockLines),
+            ...descLines.slice(0, excessStart),
+            ...descLines.slice(excessStart + excessBlockLines - 1 - maxBlockLines),
           ].map((desc, idx) => {
             return {
               number: 0,
@@ -52,6 +55,7 @@ const checkMaxBlockLines = ({
               tokens: seedTokens({
                 ...info,
                 description: desc,
+                lineEnd: utils.newLineEnd,
                 postDelimiter: newPostDelims[idx],
               }),
             };
@@ -327,6 +331,7 @@ export default iterateJsdoc(({
                 tokens: seedTokens({
                   ...info,
                   description: desc,
+                  lineEnd: utils.newLineEnd,
                   postDelimiter: postDelims[idx],
                 }),
               };
@@ -356,6 +361,7 @@ export default iterateJsdoc(({
                 tokens: seedTokens({
                   ...info,
                   description: desc,
+                  lineEnd: utils.newLineEnd,
                   postDelimiter: desc.trim() ? postDelims[idx] : '',
                 }),
               };

package/src/rules.d.ts

@@ -1348,6 +1348,10 @@ export interface Rules {
            * Whether to enable the fixer that removes the redundant `@type` tag (and the JSDoc block if it becomes empty). Defaults to `true`.
            */
           enableFixer?: boolean;
+          /**
+           * Whether the fixer may also remove a redundant assertion that is broader than the inferred type, which changes the declared, exported or returned type (e.g. `/** @type {unknown} * /` on a `string`). When `false`, such an assertion is still reported but not fixed. Only matters when `enableFixer` is `true`. Defaults to `true`.
+           */
+          fixTypeChangingCasts?: boolean;
           /**
            * Whether to report a non-`const` literal-tuple assertion on an array literal (e.g. `/** @type {['foo']} * / (['foo'])`) and fix it to the equivalent, more concise `/** @type {const} * /` assertion. Defaults to `false`.
            */