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

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

@@ -3,16 +3,10 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getImportedLocalName,
-  getNamedImports,
-} from 'eslint-rule-forge';
+import { getArgumentText } from 'eslint-rule-forge';
 import { Arr } from 'ts-data-forge';
 import type { ReadonlyRecord } from 'ts-type-forge';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValuesAt } from './import-binding.mjs';
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
@@ -92,13 +86,6 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     const mut_roundTrips: {
       node: TSESTree.CallExpression;
       roundTrip: RoundTrip;
@@ -173,47 +160,42 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
       },
 
       'Program:exit': () => {
-        const namedImports = getNamedImports(tsDataForgeImports);
-
-        const objName =
-          getImportedLocalName(tsDataForgeImports, 'Obj') ?? 'Obj';
+        const objAt = tsDataForgeValuesAt(sourceCode, ['Obj']).at;
 
-        const optionalName =
-          getImportedLocalName(tsDataForgeImports, 'Optional') ?? 'Optional';
+        const objOptionalAt = tsDataForgeValuesAt(sourceCode, [
+          'Obj',
+          'Optional',
+        ]).at;
 
-        const needsOptional = mut_roundTrips.some(
-          ({ roundTrip }) => roundTrip.body.kind === 'optional',
-        );
+        // Every fix brings the names it writes into scope itself, so that one
+        // applied alone (an editor's quick fix) is complete.
+        for (const { node, roundTrip } of mut_roundTrips) {
+          const binding = (
+            roundTrip.body.kind === 'optional' ? objOptionalAt : objAt
+          )(node);
 
-        const missingImports = (['Obj', 'Optional'] as const).filter(
-          (name) =>
-            (name !== 'Optional' || needsOptional) &&
-            !namedImports.includes(name),
-        );
+          const [objName, optionalName = 'Optional'] =
+            binding?.localNames ?? [];
 
-        // Note: the import is added by the first fix only, so that several
-        // fixes in one file do not each insert it at the same position.
-        for (const [index, { node, roundTrip }] of mut_roundTrips.entries()) {
           context.report({
             node,
             messageId: MESSAGE_ID_OF[roundTrip.method],
-            fix: (fixer) => {
-              const recordText = getArgumentText(sourceCode, roundTrip.record);
-
-              const replacement = `${objName}.${roundTrip.method}(${recordText}, ${buildParams(roundTrip)} => ${buildCallbackBody(roundTrip, optionalName)})`;
-
-              const importFixes =
-                index === 0 && missingImports.length > 0
-                  ? buildNamedImportFix(
-                      fixer,
-                      program,
-                      TS_DATA_FORGE_MODULE,
-                      missingImports,
-                    )
-                  : [];
-
-              return [...importFixes, fixer.replaceText(node, replacement)];
-            },
+            fix:
+              binding === undefined || objName === undefined
+                ? null
+                : (fixer) => {
+                    const recordText = getArgumentText(
+                      sourceCode,
+                      roundTrip.record,
+                    );
+
+                    const replacement = `${objName}.${roundTrip.method}(${recordText}, ${buildParams(roundTrip)} => ${buildCallbackBody(roundTrip, optionalName)})`;
+
+                    return [
+                      ...binding.edits(fixer),
+                      fixer.replaceText(node, replacement),
+                    ];
+                  },
           });
         }
       },
@@ -221,6 +203,127 @@ export const preferObjOverEntriesRoundTrip: TSESLint.RuleModule<
   },
 } as const;
 
+const isElidedOrIdentifier = (
+  element: TSESTree.DestructuringPattern | null | undefined,
+): element is TSESTree.Identifier | null | undefined =>
+  element === null ||
+  element === undefined ||
+  element.type === AST_NODE_TYPES.Identifier;
+
+/**
+ * Reads the `[key, value]` destructuring the entry callback binds. Anything
+ * beyond a plain binding — a default, a rest element, a nested pattern — is
+ * rejected, because the rewritten callback receives the value and the key
+ * directly rather than an entry tuple.
+ */
+const parseEntryPattern = (
+  pattern: TSESTree.ArrayPattern,
+): EntryParams | undefined => {
+  if (pattern.elements.length > 2) {
+    return undefined;
+  }
+
+  const [keyElement, valueElement] = pattern.elements;
+
+  return isElidedOrIdentifier(keyElement) && isElidedOrIdentifier(valueElement)
+    ? {
+        keyParam: keyElement ?? undefined,
+        valueParam: valueElement ?? undefined,
+      }
+    : undefined;
+};
+
+const isConstAssertion = (node: TSESTree.TSAsExpression): boolean =>
+  node.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference &&
+  node.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier &&
+  node.typeAnnotation.typeName.name === 'const';
+
+/**
+ * Looks through the `as const` / `satisfies` an entry tuple usually carries.
+ * Any other assertion is left in place, so that a tuple asserted to a wider
+ * type than the callback returns is not reported: `Obj` would infer the
+ * narrower one and the rewrite would not type-check.
+ */
+const stripTypeWrappers = (node: TSESTree.Expression): TSESTree.Expression =>
+  node.type === AST_NODE_TYPES.TSSatisfiesExpression ||
+  (node.type === AST_NODE_TYPES.TSAsExpression && isConstAssertion(node))
+    ? stripTypeWrappers(node.expression)
+    : node;
+
+/**
+ * Matches `[k, value]` — an entry rebuilt under the very key it came from,
+ * which is the only shape `Obj.map` / `Obj.filterMap` can express. An entry
+ * built under a different key is left alone.
+ */
+const parseKeptEntry = (
+  node: TSESTree.Expression,
+  keyParam: TSESTree.Identifier | undefined,
+): KeptEntry | undefined => {
+  if (keyParam === undefined) {
+    return undefined;
+  }
+
+  const tuple = stripTypeWrappers(node);
+
+  if (
+    tuple.type !== AST_NODE_TYPES.ArrayExpression ||
+    !Arr.isFixedLengthTuple(2, tuple.elements)
+  ) {
+    return undefined;
+  }
+
+  const [key, value] = tuple.elements;
+
+  return key !== null &&
+    value !== null &&
+    key.type === AST_NODE_TYPES.Identifier &&
+    value.type !== AST_NODE_TYPES.SpreadElement &&
+    key.name === keyParam.name
+    ? { key, value }
+    : undefined;
+};
+
+/** Matches `[[k, value]]` — the `flatMap` branch that keeps an entry. */
+const parseSingletonEntry = (
+  node: TSESTree.Expression,
+  keyParam: TSESTree.Identifier | undefined,
+): KeptEntry | undefined => {
+  const array = stripTypeWrappers(node);
+
+  if (
+    array.type !== AST_NODE_TYPES.ArrayExpression ||
+    !Arr.isFixedLengthTuple(1, array.elements)
+  ) {
+    return undefined;
+  }
+
+  const [entry] = array.elements;
+
+  return entry === null || entry.type === AST_NODE_TYPES.SpreadElement
+    ? undefined
+    : parseKeptEntry(entry, keyParam);
+};
+
+/** Matches `[]` — the `flatMap` branch that drops an entry. */
+const isEmptyArray = (node: TSESTree.Expression): boolean => {
+  const array = stripTypeWrappers(node);
+
+  return (
+    array.type === AST_NODE_TYPES.ArrayExpression && array.elements.length === 0
+  );
+};
+
+const isObjectStaticCall = (
+  node: TSESTree.CallExpression,
+  name: 'entries' | 'fromEntries',
+): boolean =>
+  node.callee.type === AST_NODE_TYPES.MemberExpression &&
+  !node.callee.computed &&
+  node.callee.object.type === AST_NODE_TYPES.Identifier &&
+  node.callee.object.name === 'Object' &&
+  node.callee.property.type === AST_NODE_TYPES.Identifier &&
+  node.callee.property.name === name;
+
 /**
  * Matches `Object.fromEntries(Object.entries(record).map|filter|flatMap(cb))`
  * and reports which `Obj` function replaces it, or `undefined` when the call is
@@ -377,133 +480,12 @@ type EntryParams = Readonly<{
   valueParam: TSESTree.Identifier | undefined;
 }>;
 
-/**
- * Reads the `[key, value]` destructuring the entry callback binds. Anything
- * beyond a plain binding — a default, a rest element, a nested pattern — is
- * rejected, because the rewritten callback receives the value and the key
- * directly rather than an entry tuple.
- */
-const parseEntryPattern = (
-  pattern: TSESTree.ArrayPattern,
-): EntryParams | undefined => {
-  if (pattern.elements.length > 2) {
-    return undefined;
-  }
-
-  const [keyElement, valueElement] = pattern.elements;
-
-  return isElidedOrIdentifier(keyElement) && isElidedOrIdentifier(valueElement)
-    ? {
-        keyParam: keyElement ?? undefined,
-        valueParam: valueElement ?? undefined,
-      }
-    : undefined;
-};
-
-const isElidedOrIdentifier = (
-  element: TSESTree.DestructuringPattern | null | undefined,
-): element is TSESTree.Identifier | null | undefined =>
-  element === null ||
-  element === undefined ||
-  element.type === AST_NODE_TYPES.Identifier;
-
 type KeptEntry = Readonly<{
   /** The key identifier that only rebuilds the entry, dropped by the rewrite. */
   key: TSESTree.Identifier;
   value: TSESTree.Expression;
 }>;
 
-/**
- * Matches `[k, value]` — an entry rebuilt under the very key it came from,
- * which is the only shape `Obj.map` / `Obj.filterMap` can express. An entry
- * built under a different key is left alone.
- */
-const parseKeptEntry = (
-  node: TSESTree.Expression,
-  keyParam: TSESTree.Identifier | undefined,
-): KeptEntry | undefined => {
-  if (keyParam === undefined) {
-    return undefined;
-  }
-
-  const tuple = stripTypeWrappers(node);
-
-  if (
-    tuple.type !== AST_NODE_TYPES.ArrayExpression ||
-    !Arr.isFixedLengthTuple(2, tuple.elements)
-  ) {
-    return undefined;
-  }
-
-  const [key, value] = tuple.elements;
-
-  return key !== null &&
-    value !== null &&
-    key.type === AST_NODE_TYPES.Identifier &&
-    value.type !== AST_NODE_TYPES.SpreadElement &&
-    key.name === keyParam.name
-    ? { key, value }
-    : undefined;
-};
-
-/** Matches `[[k, value]]` — the `flatMap` branch that keeps an entry. */
-const parseSingletonEntry = (
-  node: TSESTree.Expression,
-  keyParam: TSESTree.Identifier | undefined,
-): KeptEntry | undefined => {
-  const array = stripTypeWrappers(node);
-
-  if (
-    array.type !== AST_NODE_TYPES.ArrayExpression ||
-    !Arr.isFixedLengthTuple(1, array.elements)
-  ) {
-    return undefined;
-  }
-
-  const [entry] = array.elements;
-
-  return entry === null || entry.type === AST_NODE_TYPES.SpreadElement
-    ? undefined
-    : parseKeptEntry(entry, keyParam);
-};
-
-/** Matches `[]` — the `flatMap` branch that drops an entry. */
-const isEmptyArray = (node: TSESTree.Expression): boolean => {
-  const array = stripTypeWrappers(node);
-
-  return (
-    array.type === AST_NODE_TYPES.ArrayExpression && array.elements.length === 0
-  );
-};
-
-/**
- * Looks through the `as const` / `satisfies` an entry tuple usually carries.
- * Any other assertion is left in place, so that a tuple asserted to a wider
- * type than the callback returns is not reported: `Obj` would infer the
- * narrower one and the rewrite would not type-check.
- */
-const stripTypeWrappers = (node: TSESTree.Expression): TSESTree.Expression =>
-  node.type === AST_NODE_TYPES.TSSatisfiesExpression ||
-  (node.type === AST_NODE_TYPES.TSAsExpression && isConstAssertion(node))
-    ? stripTypeWrappers(node.expression)
-    : node;
-
-const isConstAssertion = (node: TSESTree.TSAsExpression): boolean =>
-  node.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference &&
-  node.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier &&
-  node.typeAnnotation.typeName.name === 'const';
-
-const isObjectStaticCall = (
-  node: TSESTree.CallExpression,
-  name: 'entries' | 'fromEntries',
-): boolean =>
-  node.callee.type === AST_NODE_TYPES.MemberExpression &&
-  !node.callee.computed &&
-  node.callee.object.type === AST_NODE_TYPES.Identifier &&
-  node.callee.object.name === 'Object' &&
-  node.callee.property.type === AST_NODE_TYPES.Identifier &&
-  node.callee.property.name === name;
-
 /**
  * `true` when the parameter is still referenced once the identifiers in
  * `dropped` — the ones that only rebuilt the entry key — are discounted.

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

@@ -308,6 +308,38 @@ describe('prefer-obj-over-entries-round-trip', () => {
           `,
           errors: [{ messageId: 'useObjFilterMap' }],
         },
+        {
+          name: 'adds Obj and Optional to one existing import',
+          code: dedent`
+            import { asInt } from 'ts-data-forge';
+            const scores = { alice: 1, bob: 2 };
+            const scaled = Object.fromEntries(
+              Object.entries(scores).flatMap(([k, v]) =>
+                v > 1 ? [[k, v * 10]] : [],
+              ),
+            );
+          `,
+          output: dedent`
+            import { asInt, Obj, Optional } from 'ts-data-forge';
+            const scores = { alice: 1, bob: 2 };
+            const scaled = Obj.filterMap(scores, (v) => v > 1 ? Optional.some(v * 10) : Optional.none);
+          `,
+          errors: [{ messageId: 'useObjFilterMap' }],
+        },
+        {
+          name: 'no fix when an import type binds Optional',
+          code: dedent`
+            import type { Optional } from 'ts-data-forge';
+            const scores = { alice: 1, bob: 2 };
+            const scaled = Object.fromEntries(
+              Object.entries(scores).flatMap(([k, v]) =>
+                v > 1 ? [[k, v * 10]] : [],
+              ),
+            );
+          `,
+          output: null,
+          errors: [{ messageId: 'useObjFilterMap' }],
+        },
         {
           name: 'handles a flatMap whose branches are the other way round',
           code: dedent`
@@ -368,12 +400,22 @@ describe('prefer-obj-over-entries-round-trip', () => {
               Object.entries(scores).filter(([, v]) => v > 1),
             );
           `,
-          output: dedent`
-            import { Obj } from 'ts-data-forge';
-            const scores = { alice: 1, bob: 2 };
-            const doubled = Obj.map(scores, (v) => v * 2);
-            const passing = Obj.filter(scores, (v) => v > 1);
-          `,
+          output: [
+            dedent`
+              import { Obj } from 'ts-data-forge';
+              const scores = { alice: 1, bob: 2 };
+              const doubled = Obj.map(scores, (v) => v * 2);
+              const passing = Object.fromEntries(
+                Object.entries(scores).filter(([, v]) => v > 1),
+              );
+            `,
+            dedent`
+              import { Obj } from 'ts-data-forge';
+              const scores = { alice: 1, bob: 2 };
+              const doubled = Obj.map(scores, (v) => v * 2);
+              const passing = Obj.filter(scores, (v) => v > 1);
+            `,
+          ],
           errors: [{ messageId: 'useObjMap' }, { messageId: 'useObjFilter' }],
         },
         {

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

@@ -7,6 +7,7 @@ import {
   buildCalleeResolver,
   getArgumentText,
   getImportDeclarations,
+  hasCommentWithin,
   hasForeignBinding,
   isTypeWrapper,
   skipTypeWrappers,
@@ -238,14 +239,11 @@ export const preferPipeMapNullable: TSESLint.RuleModule<MessageIds, Options> = {
           [mapFn.range[1], mapNullableCall.range[1]],
         ] as const;
 
-        const dropsComment = sourceCode
-          .getCommentsInside(mapNullableCall)
-          .some((comment) =>
-            droppedRanges.some(
-              ([start, end]) =>
-                start <= comment.range[0] && comment.range[1] <= end,
-            ),
-          );
+        const dropsComment = hasCommentWithin(
+          sourceCode,
+          mapNullableCall,
+          droppedRanges,
+        );
 
         const autofixable =
           !dropsComment &&