eslint-plugin-ts-data-forge 0.10.3 → 0.10.5

package/src/rules/prefer-arr-is-bounded-length-array.mts

@@ -32,6 +32,7 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
       useIsBoundedLengthArray:
         'Replace `{{original}}` with `Arr.isBoundedLengthArray({{arrayName}}, {{min}}, {{max}})` from ts-data-forge.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -141,5 +142,4 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
       },
     };
   },
-  defaultOptions: [],
 } as const;

package/src/rules/prefer-arr-is-fixed-length-array.mts

@@ -33,6 +33,7 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
       useIsFixedLengthArray:
         'Replace `{{original}}` with `Arr.isFixedLengthArray({{arrayName}}, {{length}})` from ts-data-forge.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -139,5 +140,4 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
       },
     };
   },
-  defaultOptions: [],
 } as const;

package/src/rules/prefer-arr-is-max-length-array.mts

@@ -34,6 +34,7 @@ export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
       useIsMaxLengthArray:
         'Replace `{{original}}` with `Arr.isMaxLengthArray({{arrayName}}, {{length}})` from ts-data-forge.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -142,5 +143,4 @@ export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
       },
     };
   },
-  defaultOptions: [],
 } as const;

package/src/rules/prefer-arr-is-min-length-array.mts

@@ -34,6 +34,7 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
       useIsMinLengthArray:
         'Replace `{{original}}` with `Arr.isMinLengthArray({{arrayName}}, {{length}})` from ts-data-forge.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -142,5 +143,4 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
       },
     };
   },
-  defaultOptions: [],
 } as const;

package/src/rules/prefer-arr-is-non-empty.mts

@@ -30,6 +30,7 @@ export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
       useIsNonEmpty:
         'Replace `{{original}}` with `Arr.isNonEmpty({{arrayName}})` from ts-data-forge.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -125,5 +126,4 @@ export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
       },
     };
   },
-  defaultOptions: [],
 } as const;

package/src/rules/prefer-arr-scan.mts

@@ -21,7 +21,10 @@ type Options = readonly [];
 type MessageIds = 'preferArrScanPrefix' | 'preferArrScanAccumulate';
 
 /** Array methods that cut a prefix or a suffix out of the array they are called on. */
-const SLICING_METHODS: ReadonlySet<string> = new Set(['slice', 'subarray']);
+const SLICING_METHODS: ReadonlySet<string> = new Set<string>([
+  'slice',
+  'subarray',
+]);
 
 /** A `map` call whose callback ignores the element it is handed. */
 type PrefixCandidate = Readonly<{
@@ -171,6 +174,7 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
       preferArrScanAccumulate:
         'Rebuilding the accumulator array on every step copies it each time. `Arr.scan` from ts-data-forge accumulates in one pass and returns the initial value followed by every intermediate one.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -553,7 +557,6 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
       },
     };
   },
-  defaultOptions: [],
 } as const;
 
 /**

package/src/rules/prefer-arr-sum.mts

@@ -33,6 +33,7 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
       useArrSumBy:
         'Replace with `Arr.sumBy({{arrayName}}, {{mapper}})` from ts-data-forge.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -306,5 +307,4 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
       },
     };
   },
-  defaultOptions: [],
 } as const;

package/src/rules/prefer-arr-uniq.mts

@@ -45,6 +45,7 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
       suggestArrUniq:
         'Replace with `Arr.uniq({{arrayName}})` from ts-data-forge (the result becomes a readonly array).',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -213,7 +214,6 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
       },
     };
   },
-  defaultOptions: [],
 } as const;
 
 /**

package/src/rules/prefer-as-int.mts

@@ -30,6 +30,7 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
       useBrandedNumberCastFunction:
         'Replace `as {{typeName}}` with `{{functionName}}()` from ts-data-forge.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -112,7 +113,6 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
       },
     };
   },
-  defaultOptions: [],
 } as const;
 
 const getBrandedNumberTypeInfo = (

package/src/rules/prefer-canonical-array-slicing.mts

@@ -113,7 +113,7 @@ const rootIdentifierName = (wrapped: TSESTree.Node): string | undefined => {
 
 type ComparisonOperator = '!==' | '<' | '<=' | '>' | '>=';
 
-const COMPARISON_OPERATORS: ReadonlySet<string> = new Set([
+const COMPARISON_OPERATORS: ReadonlySet<string> = new Set<string>([
   '!==',
   '<',
   '<=',
@@ -192,6 +192,7 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
       preferCanonicalArraySlicing:
         'Replace with `{{replacement}}` from ts-data-forge.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -877,5 +878,4 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
       },
     };
   },
-  defaultOptions: [],
 } as const;

package/src/rules/prefer-canonical-length-cast.mts

@@ -141,6 +141,7 @@ export const preferCanonicalLengthCast: TSESLint.RuleModule<
       useCanonicalCast:
         'Use `{{arrName}}.{{replacement}}(...)` instead of `{{arrName}}.{{cast}}({{boundsText}})`: with these bounds the result type is the same (or stricter), and `{{replacement}}` names the constraint directly.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -197,7 +198,6 @@ export const preferCanonicalLengthCast: TSESLint.RuleModule<
       },
     };
   },
-  defaultOptions: [],
 } as const;
 
 /** The `Arr.<cast>` method name of `node`, or `undefined` for other calls. */

package/src/rules/prefer-canonical-length-guard.mts

@@ -116,6 +116,7 @@ export const preferCanonicalLengthGuard: TSESLint.RuleModule<
     fixable: 'code',
     schema: [],
     messages: MESSAGES,
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -180,7 +181,6 @@ export const preferCanonicalLengthGuard: TSESLint.RuleModule<
       },
     ]);
   },
-  defaultOptions: [],
 } as const;
 
 /**

package/src/rules/prefer-comparison-over-nullish-guard.mts

@@ -36,7 +36,7 @@ const COMPARISON_GUARDS: ReadonlyRecord<string, ComparisonSpec> = {
  * intended, but are parenthesized so that the type or the grouping is not read
  * as part of the comparison.
  */
-const ARG_NEEDS_PARENS: ReadonlySet<string> = new Set([
+const ARG_NEEDS_PARENS: ReadonlySet<string> = new Set<string>([
   AST_NODE_TYPES.LogicalExpression,
   AST_NODE_TYPES.ConditionalExpression,
   AST_NODE_TYPES.AssignmentExpression,
@@ -48,7 +48,7 @@ const ARG_NEEDS_PARENS: ReadonlySet<string> = new Set([
 ]);
 
 /** Binary operators that bind no tighter than `===` / `!==`. */
-const LOOSE_BINARY_OPERATORS: ReadonlySet<string> = new Set([
+const LOOSE_BINARY_OPERATORS: ReadonlySet<string> = new Set<string>([
   '|',
   '^',
   '&',
@@ -116,6 +116,7 @@ export const preferComparisonOverNullishGuard: TSESLint.RuleModule<
       preferComparison:
         'Prefer `{{comparison}}` over calling `{{name}}` with an explicit argument.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -171,5 +172,4 @@ export const preferComparisonOverNullishGuard: TSESLint.RuleModule<
       },
     };
   },
-  defaultOptions: [],
 } as const;

package/src/rules/prefer-is-non-null-object.test.mts

@@ -60,24 +60,6 @@ describe('prefer-is-non-null-object', () => {
           `,
           errors: [{ messageId: 'useIsNonNullObject' }],
         },
-        {
-          name: 'replaces multiple typeof object checks with isNonNullObject imports',
-          code: dedent`
-            const u = {};
-            const ok = typeof u === "object" && u !== null;
-            const ok2 = typeof u === "object" && u !== null;
-          `,
-          output: dedent`
-            import { isNonNullObject } from 'ts-data-forge';
-            const u = {};
-            const ok = isNonNullObject(u);
-            const ok2 = isNonNullObject(u);
-          `,
-          errors: [
-            { messageId: 'useIsNonNullObject' },
-            { messageId: 'useIsNonNullObject' },
-          ],
-        },
       ] as const),
 
       ...([
@@ -124,8 +106,7 @@ describe('prefer-is-non-null-object', () => {
             const ok = typeof u === "object" && u !== null;
           `,
           output: dedent`
-            import { isNonNullObject } from 'ts-data-forge';
-            import { asInt } from 'ts-data-forge';
+            import { asInt, isNonNullObject } from 'ts-data-forge';
 
             const ok = isNonNullObject(u);
           `,
@@ -141,9 +122,8 @@ describe('prefer-is-non-null-object', () => {
             noop(typeof u === "object" && u !== null);
           `,
           output: dedent`
-            import { isNonNullObject } from 'ts-data-forge';
             import { noop } from './noop.mjs';
-            import { asInt } from 'ts-data-forge';
+            import { asInt, isNonNullObject } from 'ts-data-forge';
 
             const u = {};
             noop(isNonNullObject(u));
@@ -151,6 +131,32 @@ describe('prefer-is-non-null-object', () => {
           errors: [{ messageId: 'useIsNonNullObject' }],
         },
       ] as const),
+      {
+        name: 'replaces multiple typeof object checks with isNonNullObject imports',
+        code: dedent`
+          const u = {};
+          const ok = typeof u === "object" && u !== null;
+          const ok2 = typeof u === "object" && u !== null;
+        `,
+        output: [
+          dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+            const u = {};
+            const ok = isNonNullObject(u);
+            const ok2 = typeof u === "object" && u !== null;
+          `,
+          dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+            const u = {};
+            const ok = isNonNullObject(u);
+            const ok2 = isNonNullObject(u);
+          `,
+        ],
+        errors: [
+          { messageId: 'useIsNonNullObject' },
+          { messageId: 'useIsNonNullObject' },
+        ],
+      },
     ],
   });
 }, 20000);
@@ -298,15 +304,26 @@ describe('prefer-is-non-null-object in other forms', () => {
           const y = a && typeof u === 'object' && u !== null;
           const z = a && u !== null && (typeof u === 'object') && b;
         `,
-        output: dedent`
-          import { isNonNullObject } from 'ts-data-forge';
-          declare const u: unknown;
-          declare const a: boolean;
-          declare const b: boolean;
-          const x = isNonNullObject(u) && 'k' in u;
-          const y = a && isNonNullObject(u);
-          const z = a && isNonNullObject(u) && b;
-        `,
+        output: [
+          dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+            declare const u: unknown;
+            declare const a: boolean;
+            declare const b: boolean;
+            const x = isNonNullObject(u) && 'k' in u;
+            const y = a && typeof u === 'object' && u !== null;
+            const z = a && u !== null && (typeof u === 'object') && b;
+          `,
+          dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+            declare const u: unknown;
+            declare const a: boolean;
+            declare const b: boolean;
+            const x = isNonNullObject(u) && 'k' in u;
+            const y = a && isNonNullObject(u);
+            const z = a && isNonNullObject(u) && b;
+          `,
+        ],
         errors: [
           { messageId: 'useIsNonNullObject' },
           { messageId: 'useIsNonNullObject' },
@@ -320,12 +337,20 @@ describe('prefer-is-non-null-object in other forms', () => {
           declare const v: unknown;
           const ok = typeof u === 'object' && u !== null && v !== null && typeof v === 'object';
         `,
-        output: dedent`
-          import { isNonNullObject } from 'ts-data-forge';
-          declare const u: unknown;
-          declare const v: unknown;
-          const ok = isNonNullObject(u) && isNonNullObject(v);
-        `,
+        output: [
+          dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+            declare const u: unknown;
+            declare const v: unknown;
+            const ok = isNonNullObject(u) && v !== null && typeof v === 'object';
+          `,
+          dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+            declare const u: unknown;
+            declare const v: unknown;
+            const ok = isNonNullObject(u) && isNonNullObject(v);
+          `,
+        ],
         errors: [
           { messageId: 'useIsNonNullObject' },
           { messageId: 'useIsNonNullObject' },

package/src/rules/prefer-is-record-and-has-key.test.mts

@@ -85,13 +85,22 @@ describe('prefer-is-record-and-has-key', () => {
           const a = Object.hasOwn(rec, 'a');
           const b = Object.hasOwn(unk, 'b');
         `,
-        output: dedent`
-          import { isRecord, hasKey } from 'ts-data-forge';
-          declare const rec: Record<string, unknown>;
-          declare const unk: unknown;
-          const a = hasKey(rec, 'a');
-          const b = (isRecord(unk) && hasKey(unk, 'b'));
-        `,
+        output: [
+          dedent`
+            import { hasKey } from 'ts-data-forge';
+            declare const rec: Record<string, unknown>;
+            declare const unk: unknown;
+            const a = hasKey(rec, 'a');
+            const b = Object.hasOwn(unk, 'b');
+          `,
+          dedent`
+            import { hasKey, isRecord } from 'ts-data-forge';
+            declare const rec: Record<string, unknown>;
+            declare const unk: unknown;
+            const a = hasKey(rec, 'a');
+            const b = (isRecord(unk) && hasKey(unk, 'b'));
+          `,
+        ],
         errors: [
           { messageId: 'useHasKey' },
           { messageId: 'useIsRecordAndHasKey' },
@@ -162,8 +171,7 @@ describe('prefer-is-record-and-has-key', () => {
           const ok = Object.hasOwn(obj, 'a');
         `,
         output: dedent`
-          import { hasKey } from 'ts-data-forge';
-          import { isRecord } from 'ts-data-forge';
+          import { isRecord, hasKey } from 'ts-data-forge';
 
           const obj = { a: 1 };
           const ok = (isRecord(obj) && hasKey(obj, 'a'));
@@ -179,8 +187,7 @@ describe('prefer-is-record-and-has-key', () => {
           const ok = 'a' in obj;
         `,
         output: dedent`
-          import { isRecord } from 'ts-data-forge';
-          import { hasKey } from 'ts-data-forge';
+          import { hasKey, isRecord } from 'ts-data-forge';
 
           const obj = { a: 1 };
           const ok = (isRecord(obj) && hasKey(obj, 'a'));
@@ -210,12 +217,20 @@ describe('prefer-is-record-and-has-key', () => {
           const ok1 = Object.hasOwn(obj, 'a');
           const ok2 = 'b' in obj;
         `,
-        output: dedent`
-          import { isRecord, hasKey } from 'ts-data-forge';
-          const obj = { a: 1 };
-          const ok1 = (isRecord(obj) && hasKey(obj, 'a'));
-          const ok2 = (isRecord(obj) && hasKey(obj, 'b'));
-        `,
+        output: [
+          dedent`
+            import { isRecord, hasKey } from 'ts-data-forge';
+            const obj = { a: 1 };
+            const ok1 = (isRecord(obj) && hasKey(obj, 'a'));
+            const ok2 = 'b' in obj;
+          `,
+          dedent`
+            import { isRecord, hasKey } from 'ts-data-forge';
+            const obj = { a: 1 };
+            const ok1 = (isRecord(obj) && hasKey(obj, 'a'));
+            const ok2 = (isRecord(obj) && hasKey(obj, 'b'));
+          `,
+        ],
         errors: [
           { messageId: 'useIsRecordAndHasKey' },
           { messageId: 'useIsRecordAndHasKey' },

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

@@ -105,8 +105,7 @@ describe('prefer-num-safe-parse-float', () => {
           const n = parseFloat(s);
         `,
         output: dedent`
-          import { Result } from 'ts-data-forge';
-          import { Num } from 'ts-data-forge';
+          import { Num, Result } from 'ts-data-forge';
 
           const s = "3.14";
           const n = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
@@ -145,13 +144,22 @@ describe('prefer-num-safe-parse-float', () => {
           const b = Number.parseFloat(s);
           const c = Number(s);
         `,
-        output: dedent`
-          import { Num, Result } from 'ts-data-forge';
-          const s = "1.5";
-          const a = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
-          const b = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
-          const c = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
-        `,
+        output: [
+          dedent`
+            import { Num, Result } from 'ts-data-forge';
+            const s = "1.5";
+            const a = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+            const b = Number.parseFloat(s);
+            const c = Number(s);
+          `,
+          dedent`
+            import { Num, Result } from 'ts-data-forge';
+            const s = "1.5";
+            const a = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+            const b = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+            const c = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+          `,
+        ],
         errors: [
           { messageId: 'useSafeParseFloat' },
           { messageId: 'useSafeParseFloat' },
@@ -203,12 +211,20 @@ describe('prefer-num-safe-parse-float through type wrappers', () => {
           const a = Number(s!);
           const b = parseFloat(s satisfies string);
         `,
-        output: dedent`
-          import { Num, Result } from 'ts-data-forge';
-          declare const s: string;
-          const a = Result.unwrapOkOr(Num.safeParseFloat(s!), Number.NaN);
-          const b = Result.unwrapOkOr(Num.safeParseFloat(s satisfies string), Number.NaN);
-        `,
+        output: [
+          dedent`
+            import { Num, Result } from 'ts-data-forge';
+            declare const s: string;
+            const a = Result.unwrapOkOr(Num.safeParseFloat(s!), Number.NaN);
+            const b = parseFloat(s satisfies string);
+          `,
+          dedent`
+            import { Num, Result } from 'ts-data-forge';
+            declare const s: string;
+            const a = Result.unwrapOkOr(Num.safeParseFloat(s!), Number.NaN);
+            const b = Result.unwrapOkOr(Num.safeParseFloat(s satisfies string), Number.NaN);
+          `,
+        ],
         errors: [
           { messageId: 'useSafeParseFloat' },
           { messageId: 'useSafeParseFloat' },
@@ -221,12 +237,20 @@ describe('prefer-num-safe-parse-float through type wrappers', () => {
           const a = (Number as NumberConstructor)(s);
           const b = Number!.parseFloat(s);
         `,
-        output: dedent`
-          import { Num, Result } from 'ts-data-forge';
-          declare const s: string;
-          const a = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
-          const b = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
-        `,
+        output: [
+          dedent`
+            import { Num, Result } from 'ts-data-forge';
+            declare const s: string;
+            const a = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+            const b = Number!.parseFloat(s);
+          `,
+          dedent`
+            import { Num, Result } from 'ts-data-forge';
+            declare const s: string;
+            const a = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+            const b = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+          `,
+        ],
         errors: [
           { messageId: 'useSafeParseFloat' },
           { messageId: 'useSafeParseFloat' },

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

@@ -98,8 +98,7 @@ describe('prefer-num-safe-parse-int', () => {
           const n = parseInt(s, 10);
         `,
         output: dedent`
-          import { Result } from 'ts-data-forge';
-          import { Num } from 'ts-data-forge';
+          import { Num, Result } from 'ts-data-forge';
 
           const s = "123";
           const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
@@ -162,12 +161,20 @@ 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 = Result.unwrapOkOr(Num.safeParseInt(s!), Number.NaN);
-        `,
+        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' },
@@ -180,12 +187,20 @@ 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 = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
-        `,
+        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' },

package/src/rules/prefer-obj-over-entries-round-trip.mts

@@ -86,6 +86,7 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
       useObjFilterMap:
         'Replace this `Object.fromEntries(Object.entries(…).flatMap(…))` round trip with `Obj.filterMap` from ts-data-forge, which keeps the key types of the record in the result type.',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -218,7 +219,6 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
       },
     };
   },
-  defaultOptions: [],
 } as const;
 
 /**

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

@@ -53,6 +53,7 @@ export const preferPipeMapNullable: TSESLint.RuleModule<MessageIds, Options> = {
       suggestMapNullable:
         'Replace `.map({{mapNullableName}}(…))` with `.mapNullable(…)` (the inferred type may be widened, or a comment or type assertion dropped).',
     },
+    defaultOptions: [],
   },
 
   create: (context) => {
@@ -283,7 +284,6 @@ export const preferPipeMapNullable: TSESLint.RuleModule<MessageIds, Options> = {
       },
     };
   },
-  defaultOptions: [],
 } as const;
 
 /**
@@ -294,7 +294,7 @@ export const preferPipeMapNullable: TSESLint.RuleModule<MessageIds, Options> = {
 const PIPE_MODULES = [TS_DATA_FORGE_MODULE, 'ts-std-forge'] as const;
 
 /** The methods of a `Pipe` that return another `Pipe`. */
-const PIPE_CHAIN_METHODS: ReadonlySet<string> = new Set([
+const PIPE_CHAIN_METHODS: ReadonlySet<string> = new Set<string>([
   'map',
   'mapNullable',
   'mapOptional',