eslint-plugin-ts-data-forge 0.10.6 → 0.10.7

package/src/rules/prefer-num-safe-parse-int.test.mts

@@ -28,7 +28,7 @@ describe('prefer-num-safe-parse-int', () => {
         `,
       },
       {
-        name: 'ignores number arguments (autofix would be unsafe)',
+        name: 'ignores number arguments (the rewrite would be unsafe)',
         code: dedent`
           const x = 42;
           const n = parseInt(x, 10);
@@ -50,18 +50,76 @@ describe('prefer-num-safe-parse-int', () => {
       },
     ],
     invalid: [
+      {
+        name: 'offers no suggestion when `Result` is bound to another module',
+        code: dedent`
+          import { Result } from 'other-lib';
+
+          declare const s: string;
+          const n = parseInt(s);
+          export const r = Result;
+        `,
+        errors: [{ messageId: 'useSafeParseInt', suggestions: [] }],
+      },
+      {
+        // The replacement reads these strings differently ('1e3' is 1000, not
+        // 1; '12px' is NaN, not 12), so it is offered, never applied by
+        // --fix
+        name: 'a string the replacement parses differently is a suggestion, not a fix',
+        code: dedent`
+          const a = parseInt('1e3');
+          const b = parseInt('12px', 10);
+        `,
+        errors: [
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  const a = Result.unwrapOkOr(Num.safeParseInt('1e3'), Number.NaN);
+                  const b = parseInt('12px', 10);
+                `,
+              },
+            ],
+          },
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  const a = parseInt('1e3');
+                  const b = Result.unwrapOkOr(Num.safeParseInt('12px'), Number.NaN);
+                `,
+              },
+            ],
+          },
+        ],
+      },
       {
         name: 'replaces parseInt(s, 10) and imports Num + Result',
         code: dedent`
           const s = "123";
           const n = parseInt(s, 10);
         `,
-        output: dedent`
-          import { Num, Result } from 'ts-data-forge';
-          const s = "123";
-          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
-        `,
-        errors: [{ messageId: 'useSafeParseInt' }],
+        errors: [
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  const s = "123";
+                  const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+                `,
+              },
+            ],
+          },
+        ],
       },
       {
         name: 'replaces parseInt(s) without radix',
@@ -69,12 +127,21 @@ describe('prefer-num-safe-parse-int', () => {
           const s = "123";
           const n = parseInt(s);
         `,
-        output: dedent`
-          import { Num, Result } from 'ts-data-forge';
-          const s = "123";
-          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
-        `,
-        errors: [{ messageId: 'useSafeParseInt' }],
+        errors: [
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  const s = "123";
+                  const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+                `,
+              },
+            ],
+          },
+        ],
       },
       {
         name: 'replaces Number.parseInt(s, 10)',
@@ -82,12 +149,21 @@ describe('prefer-num-safe-parse-int', () => {
           const s = "123";
           const n = Number.parseInt(s, 10);
         `,
-        output: dedent`
-          import { Num, Result } from 'ts-data-forge';
-          const s = "123";
-          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
-        `,
-        errors: [{ messageId: 'useSafeParseInt' }],
+        errors: [
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  const s = "123";
+                  const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+                `,
+              },
+            ],
+          },
+        ],
       },
       {
         name: 'adds only the missing Result import when Num is present',
@@ -97,13 +173,22 @@ describe('prefer-num-safe-parse-int', () => {
           const s = "123";
           const n = parseInt(s, 10);
         `,
-        output: dedent`
-          import { Num, Result } from 'ts-data-forge';
+        errors: [
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
 
-          const s = "123";
-          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
-        `,
-        errors: [{ messageId: 'useSafeParseInt' }],
+                  const s = "123";
+                  const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+                `,
+              },
+            ],
+          },
+        ],
       },
       {
         name: 'wraps in parentheses in an operator context',
@@ -111,12 +196,21 @@ describe('prefer-num-safe-parse-int', () => {
           const s = "123";
           const ok = parseInt(s, 10) > 5;
         `,
-        output: dedent`
-          import { Num, Result } from 'ts-data-forge';
-          const s = "123";
-          const ok = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN) > 5;
-        `,
-        errors: [{ messageId: 'useSafeParseInt' }],
+        errors: [
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  const s = "123";
+                  const ok = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN) > 5;
+                `,
+              },
+            ],
+          },
+        ],
       },
       {
         name: 'preserves a complex string argument expression',
@@ -124,12 +218,21 @@ describe('prefer-num-safe-parse-int', () => {
           const get = (k: string): string => k;
           const n = parseInt(get("x").trim(), 10);
         `,
-        output: dedent`
-          import { Num, Result } from 'ts-data-forge';
-          const get = (k: string): string => k;
-          const n = Result.unwrapOkOr(Num.safeParseInt(get("x").trim()), Number.NaN);
-        `,
-        errors: [{ messageId: 'useSafeParseInt' }],
+        errors: [
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  const get = (k: string): string => k;
+                  const n = Result.unwrapOkOr(Num.safeParseInt(get("x").trim()), Number.NaN);
+                `,
+              },
+            ],
+          },
+        ],
       },
     ],
   });
@@ -161,23 +264,35 @@ describe('prefer-num-safe-parse-int through type wrappers', () => {
           const a = parseInt(s, 10 as const);
           const b = Number.parseInt(s!, 10 satisfies number);
         `,
-        output: [
-          dedent`
-            import { Num, Result } from 'ts-data-forge';
-            declare const s: string;
-            const a = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
-            const b = Number.parseInt(s!, 10 satisfies number);
-          `,
-          dedent`
-            import { Num, Result } from 'ts-data-forge';
-            declare const s: string;
-            const a = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
-            const b = Result.unwrapOkOr(Num.safeParseInt(s!), Number.NaN);
-          `,
-        ],
         errors: [
-          { messageId: 'useSafeParseInt' },
-          { messageId: 'useSafeParseInt' },
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  declare const s: string;
+                  const a = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+                  const b = Number.parseInt(s!, 10 satisfies number);
+                `,
+              },
+            ],
+          },
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  declare const s: string;
+                  const a = parseInt(s, 10 as const);
+                  const b = Result.unwrapOkOr(Num.safeParseInt(s!), Number.NaN);
+                `,
+              },
+            ],
+          },
         ],
       },
       {
@@ -187,23 +302,35 @@ describe('prefer-num-safe-parse-int through type wrappers', () => {
           const a = (parseInt as typeof parseInt)(s);
           const b = (Number as NumberConstructor)!.parseInt(s, 10);
         `,
-        output: [
-          dedent`
-            import { Num, Result } from 'ts-data-forge';
-            declare const s: string;
-            const a = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
-            const b = (Number as NumberConstructor)!.parseInt(s, 10);
-          `,
-          dedent`
-            import { Num, Result } from 'ts-data-forge';
-            declare const s: string;
-            const a = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
-            const b = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
-          `,
-        ],
         errors: [
-          { messageId: 'useSafeParseInt' },
-          { messageId: 'useSafeParseInt' },
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  declare const s: string;
+                  const a = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+                  const b = (Number as NumberConstructor)!.parseInt(s, 10);
+                `,
+              },
+            ],
+          },
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  declare const s: string;
+                  const a = (parseInt as typeof parseInt)(s);
+                  const b = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+                `,
+              },
+            ],
+          },
         ],
       },
     ],
@@ -221,13 +348,22 @@ describe('prefer-num-safe-parse-int with parenthesized operands', () => {
           declare const log: () => void;
           const a = parseInt((log(), s), 10);
         `,
-        output: dedent`
-          import { Num, Result } from 'ts-data-forge';
-          declare const s: string;
-          declare const log: () => void;
-          const a = Result.unwrapOkOr(Num.safeParseInt((log(), s)), Number.NaN);
-        `,
-        errors: [{ messageId: 'useSafeParseInt' }],
+        errors: [
+          {
+            messageId: 'useSafeParseInt',
+            suggestions: [
+              {
+                messageId: 'replaceWithSafeParse',
+                output: dedent`
+                  import { Num, Result } from 'ts-data-forge';
+                  declare const s: string;
+                  declare const log: () => void;
+                  const a = Result.unwrapOkOr(Num.safeParseInt((log(), s)), Number.NaN);
+                `,
+              },
+            ],
+          },
+        ],
       },
     ],
   });

package/src/rules/prefer-pipe-map-nullable.mts

@@ -34,8 +34,8 @@ type MessageIds = 'useMapNullable' | 'suggestMapNullable';
  * first infers `'a'` and the second `string`, and `(v) => [v, 1]` becomes
  * `number[]` instead of `readonly [number, 1]`. The fix is therefore applied
  * automatically only when the function's return type is not inferred, or is
- * inferred with nothing such a widening could change; otherwise, and whenever
- * a comment or a type wrapper around `mapNullable` would be dropped, it is
+ * inferred with nothing such a widening could change; otherwise, and whenever a
+ * comment or a type wrapper around `mapNullable` would be dropped, it is
  * offered as a suggestion.
  */
 export const preferPipeMapNullable: TSESLint.RuleModule<MessageIds, Options> = {
@@ -81,8 +81,8 @@ export const preferPipeMapNullable: TSESLint.RuleModule<MessageIds, Options> = {
     const esTreeNodeToTSNodeMap = services?.esTreeNodeToTSNodeMap;
 
     /**
-     * Whether `callee` calls the export `name` of the module `resolve`
-     * reads, rather than a local binding that shadows the import.
+     * Whether `callee` calls the export `name` of the module `resolve` reads,
+     * rather than a local binding that shadows the import.
      */
     const calls = (
       resolve: ReturnType<typeof buildCalleeResolver>,
@@ -170,9 +170,9 @@ export const preferPipeMapNullable: TSESLint.RuleModule<MessageIds, Options> = {
       }
 
       // The `B | undefined` that `mapNullable(fn)` returns, with `B` as the
-      // `const` type parameter inferred it. The function's own return type
-      // is no guide: for `(v) => ({ kind: 'n', v })` it is already widened
-      // to `{ kind: string; v: number }`, while `B` keeps `'n'`.
+      // `const` type parameter inferred it. The function's own return type is
+      // no guide: for `(v) => ({ kind: 'n', v })` it is already widened to
+      // `{ kind: string; v: number }`, while `B` keeps `'n'`.
       const signatures = checker
         .getTypeAtLocation(esTreeNodeToTSNodeMap.get(mapNullableCall))
         .getCallSignatures();
@@ -313,11 +313,11 @@ const MAX_DEPTH = 4;
 
 /**
  * Whether `type`, inferred for a `const` type parameter, has a part a plain
- * type parameter would infer differently: a literal (`'a'` against `string`)
- * or a tuple (`readonly [number, 1]` against `number[]`), at the top level or
+ * type parameter would infer differently: a literal (`'a'` against `string`) or
+ * a tuple (`readonly [number, 1]` against `number[]`), at the top level or
  * inside an array, a generic type's arguments or an object literal's
- * properties. Conservative: a declared literal type, which neither widens,
- * also counts.
+ * properties. Conservative: a declared literal type, which neither widens, also
+ * counts.
  */
 const hasConstInferredPart = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types

package/src/rules/prefer-range-for-loop.mts

@@ -33,8 +33,8 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
 
     /**
      * Whether `node` is the same value on every iteration: a literal, or a
-     * variable that is never reassigned anywhere (not only in the loop, since
-     * a function the loop calls could reassign it). The loop reads its end and
+     * variable that is never reassigned anywhere (not only in the loop, since a
+     * function the loop calls could reassign it). The loop reads its end and
      * its step on every iteration, and `range` reads them once.
      */
     const isStableBound = (
@@ -103,8 +103,8 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
           return;
         }
 
-        // Check test: i < end. The loop variable and the step are read
-        // through type wrappers: `(i satisfies number) < n` tests `i`, and
+        // Check test: i < end. The loop variable and the step are read through
+        // type wrappers: `(i satisfies number) < n` tests `i`, and
         // `i += 0 as number` still steps by 0.
         if (
           node.test?.type !== AST_NODE_TYPES.BinaryExpression ||
@@ -166,8 +166,8 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
             }
           } else if (isNegatedLiteral(stepValue)) {
             // `i += -1` under `i < end` never gets there, and `range` with a
-            // negative step yields nothing: no fix that type-checks would
-            // keep that.
+            // negative step yields nothing: no fix that type-checks would keep
+            // that.
             return;
           } else {
             // Variable step like i += step. Its type is left to the type

package/src/rules/prefer-range-for-loop.test.mts

@@ -309,8 +309,8 @@ describe('prefer-range-for-loop where the rewrite would change behavior', () =>
         errors: [{ messageId: 'useRangeForLoop' }],
       },
       {
-        // The type checker judges it: a `number` step makes the fixed call
-        // fail to type-check.
+        // The type checker judges it: a `number` step makes the fixed call fail
+        // to type-check.
         name: 'a variable step is fixed without asking its type',
         code: dedent`
           declare const n: number;