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

package/changes.json

@@ -5,6 +5,6 @@
       "to": "^8.71.1"
     }
   },
-  "timestamp": "2026-10-10T08:11:16.880Z",
+  "timestamp": "2026-10-12T11:09:30.803Z",
   "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.4-depup.0",
+  "version": "65.3.1-depup.0",
   "depup": {
     "changes": {
       "@typescript-eslint/utils": {
@@ -178,8 +178,8 @@
     },
     "depsUpdated": 1,
     "originalPackage": "eslint-plugin-jsdoc",
-    "originalVersion": "65.2.4",
-    "processedAt": "2026-10-10T08:11:40.592Z",
+    "originalVersion": "65.3.1",
+    "processedAt": "2026-10-12T11:09:53.209Z",
     "smokeTest": "passed"
   }
 }

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/noUndefinedTypes.js

@@ -59,6 +59,172 @@ const typescriptGlobals = [
   'Lowercase',
   'Capitalize',
   'Uncapitalize',
+
+  // Type-only globals of TypeScript's standard library, grouped by the
+  //   `typescript/lib` file which first declares them
+
+  // lib.es5.d.ts
+  'ArrayBufferConstructor',
+  'ArrayBufferLike',
+  'ArrayBufferTypes',
+  'ArrayBufferView',
+  'ArrayConstructor',
+  'ArrayLike',
+  'BooleanConstructor',
+  'CallableFunction',
+  'ConcatArray',
+  'DataViewConstructor',
+  'DateConstructor',
+  'ErrorConstructor',
+  'EvalErrorConstructor',
+  'Float32ArrayConstructor',
+  'Float64ArrayConstructor',
+  'FunctionConstructor',
+  'IArguments',
+  'ImportAssertions',
+  'ImportAttributes',
+  'ImportCallOptions',
+  'ImportMeta',
+  'Int16ArrayConstructor',
+  'Int32ArrayConstructor',
+  'Int8ArrayConstructor',
+  'NewableFunction',
+  'NoInfer',
+  'NumberConstructor',
+  'ObjectConstructor',
+  'PromiseConstructorLike',
+  'PromiseLike',
+  'PropertyDescriptor',
+  'PropertyDescriptorMap',
+  'PropertyKey',
+  'RangeErrorConstructor',
+  'ReadonlyArray',
+  'ReferenceErrorConstructor',
+  'RegExpConstructor',
+  'RegExpExecArray',
+  'RegExpMatchArray',
+  'StringConstructor',
+  'SyntaxErrorConstructor',
+  'TemplateStringsArray',
+  'TypeErrorConstructor',
+  'TypedPropertyDescriptor',
+  'URIErrorConstructor',
+  'Uint16ArrayConstructor',
+  'Uint32ArrayConstructor',
+  'Uint8ArrayConstructor',
+  'Uint8ClampedArrayConstructor',
+  'WeakKey',
+  'WeakKeyTypes',
+
+  // lib.es2015.collection.d.ts
+  'MapConstructor',
+  'ReadonlyMap',
+  'ReadonlySet',
+  'SetConstructor',
+  'WeakMapConstructor',
+  'WeakSetConstructor',
+
+  // lib.es2015.generator.d.ts
+  'Generator',
+  'GeneratorFunction',
+  'GeneratorFunctionConstructor',
+
+  // lib.es2015.iterable.d.ts
+  'ArrayIterator',
+  'BuiltinIteratorReturn',
+  'IterableIterator',
+  'IteratorResult',
+  'IteratorReturnResult',
+  'IteratorYieldResult',
+  'MapIterator',
+  'PromiseConstructor',
+  'SetIterator',
+  'StringIterator',
+  'SymbolConstructor',
+
+  // lib.es2015.proxy.d.ts
+  'ProxyConstructor',
+  'ProxyHandler',
+
+  // lib.es2017.sharedmemory.d.ts
+  'SharedArrayBufferConstructor',
+
+  // lib.es2018.asyncgenerator.d.ts
+  'AsyncGenerator',
+  'AsyncGeneratorFunction',
+  'AsyncGeneratorFunctionConstructor',
+
+  // lib.es2018.asynciterable.d.ts
+  'AsyncIterable',
+  'AsyncIterableIterator',
+  'AsyncIterator',
+  'AsyncIteratorObject',
+
+  // lib.es2019.array.d.ts
+  'FlatArray',
+
+  // lib.es2020.bigint.d.ts
+  'BigInt64ArrayConstructor',
+  'BigIntConstructor',
+  'BigIntToLocaleStringOptions',
+  'BigUint64ArrayConstructor',
+
+  // lib.es2020.promise.d.ts
+  'PromiseFulfilledResult',
+  'PromiseRejectedResult',
+  'PromiseSettledResult',
+
+  // lib.es2020.symbol.wellknown.d.ts
+  'RegExpStringIterator',
+
+  // lib.es2021.promise.d.ts
+  'AggregateErrorConstructor',
+
+  // lib.es2021.weakref.d.ts
+  'FinalizationRegistryConstructor',
+  'WeakRefConstructor',
+
+  // lib.es2022.error.d.ts
+  'ErrorOptions',
+
+  // lib.es2022.regexp.d.ts
+  'RegExpIndicesArray',
+
+  // lib.es2024.promise.d.ts
+  'PromiseWithResolvers',
+
+  // lib.es2025.collection.d.ts
+  'ReadonlySetLike',
+
+  // lib.es2025.iterator.d.ts
+  'IteratorObjectConstructor',
+
+  // lib.esnext.disposable.d.ts
+  'AsyncDisposable',
+  'AsyncDisposableStackConstructor',
+  'Disposable',
+  'DisposableStackConstructor',
+  'SuppressedErrorConstructor',
+
+  // lib.decorators.d.ts
+  'ClassAccessorDecoratorContext',
+  'ClassAccessorDecoratorResult',
+  'ClassAccessorDecoratorTarget',
+  'ClassDecoratorContext',
+  'ClassFieldDecoratorContext',
+  'ClassGetterDecoratorContext',
+  'ClassMemberDecoratorContext',
+  'ClassMethodDecoratorContext',
+  'ClassSetterDecoratorContext',
+  'DecoratorContext',
+  'DecoratorMetadata',
+  'DecoratorMetadataObject',
+
+  // lib.decorators.legacy.d.ts
+  'ClassDecorator',
+  'MethodDecorator',
+  'ParameterDecorator',
+  'PropertyDecorator',
 ];
 
 /**

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/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,

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`.
            */