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

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

@@ -158,13 +158,22 @@ describe('prefer-arr-is-fixed-length-array', () => {
           const ok1 = xs.length === 3;
           const ok2 = ys.length === 2;
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          const xs = [1, 2, 3];
-          const ys = [4, 5];
-          const ok1 = Arr.isFixedLengthArray(3, xs);
-          const ok2 = Arr.isFixedLengthArray(2, ys);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3];
+            const ys = [4, 5];
+            const ok1 = Arr.isFixedLengthArray(3, xs);
+            const ok2 = ys.length === 2;
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3];
+            const ys = [4, 5];
+            const ok1 = Arr.isFixedLengthArray(3, xs);
+            const ok2 = Arr.isFixedLengthArray(2, ys);
+          `,
+        ],
         errors: [
           { messageId: 'useIsFixedLengthArray' },
           { messageId: 'useIsFixedLengthArray' },

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

@@ -1,18 +1,12 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
-  skipTypeWrappers,
-} from 'eslint-rule-forge';
+import { getArgumentText, skipTypeWrappers } from 'eslint-rule-forge';
 import {
   asLengthAccess,
   isArrayOrTupleExpression,
   isIntegerLiteralOrConstant,
   isPartOfBoundedLengthCheck,
 } from './ast-utils.mjs';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 
 type Options = readonly [];
 
@@ -40,13 +34,6 @@ export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     const services = context.sourceCode.parserServices;
 
     const mut_nodesToFix: {
@@ -104,20 +91,21 @@ export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
         });
       },
       'Program:exit': () => {
-        const namedImports = getNamedImports(tsDataForgeImports);
+        const arrAt = tsDataForgeValueAt(sourceCode, 'Arr');
 
-        const hasArrImport = namedImports.includes('Arr');
-
-        for (const [
-          index,
-          { node, arrayExpression, lengthExpression },
-        ] of mut_nodesToFix.entries()) {
+        for (const {
+          node,
+          arrayExpression,
+          lengthExpression,
+        } of mut_nodesToFix) {
           const arrayText = getArgumentText(sourceCode, arrayExpression);
 
           const lengthText = sourceCode.getText(lengthExpression);
 
           const originalText = sourceCode.getText(node);
 
+          const arr = arrAt(node);
+
           context.report({
             node,
             messageId: 'useIsMaxLengthArray',
@@ -126,18 +114,17 @@ export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
               arrayName: arrayText,
               length: lengthText,
             },
-            fix: (fixer) => {
-              const replacement = `Arr.isMaxLengthArray(${lengthText}, ${arrayText})`;
-
-              const importFixes =
-                index === 0 && !hasArrImport
-                  ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
-                      'Arr',
-                    ])
-                  : [];
-
-              return [...importFixes, fixer.replaceText(node, replacement)];
-            },
+            fix:
+              arr === undefined
+                ? null
+                : (fixer) => {
+                    const replacement = `${arr.localName}.isMaxLengthArray(${lengthText}, ${arrayText})`;
+
+                    return [
+                      ...arr.edits(fixer),
+                      fixer.replaceText(node, replacement),
+                    ];
+                  },
           });
         }
       },

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

@@ -171,13 +171,22 @@ describe('prefer-arr-is-max-length-array', () => {
           const ok1 = xs.length <= 2;
           const ok2 = ys.length <= 1;
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          const xs = [1, 2, 3];
-          const ys = [4, 5];
-          const ok1 = Arr.isMaxLengthArray(2, xs);
-          const ok2 = Arr.isMaxLengthArray(1, ys);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3];
+            const ys = [4, 5];
+            const ok1 = Arr.isMaxLengthArray(2, xs);
+            const ok2 = ys.length <= 1;
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3];
+            const ys = [4, 5];
+            const ok1 = Arr.isMaxLengthArray(2, xs);
+            const ok2 = Arr.isMaxLengthArray(1, ys);
+          `,
+        ],
         errors: [
           { messageId: 'useIsMaxLengthArray' },
           { messageId: 'useIsMaxLengthArray' },

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

@@ -1,18 +1,12 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
-  skipTypeWrappers,
-} from 'eslint-rule-forge';
+import { getArgumentText, skipTypeWrappers } from 'eslint-rule-forge';
 import {
   asLengthAccess,
   isArrayOrTupleExpression,
   isIntegerLiteralOrConstant,
   isPartOfBoundedLengthCheck,
 } from './ast-utils.mjs';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 
 type Options = readonly [];
 
@@ -40,13 +34,6 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     const services = context.sourceCode.parserServices;
 
     const mut_nodesToFix: {
@@ -104,20 +91,21 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
         });
       },
       'Program:exit': () => {
-        const namedImports = getNamedImports(tsDataForgeImports);
+        const arrAt = tsDataForgeValueAt(sourceCode, 'Arr');
 
-        const hasArrImport = namedImports.includes('Arr');
-
-        for (const [
-          index,
-          { node, arrayExpression, lengthExpression },
-        ] of mut_nodesToFix.entries()) {
+        for (const {
+          node,
+          arrayExpression,
+          lengthExpression,
+        } of mut_nodesToFix) {
           const arrayText = getArgumentText(sourceCode, arrayExpression);
 
           const lengthText = sourceCode.getText(lengthExpression);
 
           const originalText = sourceCode.getText(node);
 
+          const arr = arrAt(node);
+
           context.report({
             node,
             messageId: 'useIsMinLengthArray',
@@ -126,18 +114,17 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
               arrayName: arrayText,
               length: lengthText,
             },
-            fix: (fixer) => {
-              const replacement = `Arr.isMinLengthArray(${lengthText}, ${arrayText})`;
-
-              const importFixes =
-                index === 0 && !hasArrImport
-                  ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
-                      'Arr',
-                    ])
-                  : [];
-
-              return [...importFixes, fixer.replaceText(node, replacement)];
-            },
+            fix:
+              arr === undefined
+                ? null
+                : (fixer) => {
+                    const replacement = `${arr.localName}.isMinLengthArray(${lengthText}, ${arrayText})`;
+
+                    return [
+                      ...arr.edits(fixer),
+                      fixer.replaceText(node, replacement),
+                    ];
+                  },
           });
         }
       },

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

@@ -172,13 +172,22 @@ describe('prefer-arr-is-min-length-array', () => {
           const ok1 = xs.length >= 2;
           const ok2 = ys.length >= 1;
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          const xs = [1, 2, 3];
-          const ys = [4, 5];
-          const ok1 = Arr.isMinLengthArray(2, xs);
-          const ok2 = Arr.isMinLengthArray(1, ys);
-        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3];
+            const ys = [4, 5];
+            const ok1 = Arr.isMinLengthArray(2, xs);
+            const ok2 = ys.length >= 1;
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3];
+            const ys = [4, 5];
+            const ok1 = Arr.isMinLengthArray(2, xs);
+            const ok2 = Arr.isMinLengthArray(1, ys);
+          `,
+        ],
         errors: [
           { messageId: 'useIsMinLengthArray' },
           { messageId: 'useIsMinLengthArray' },

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

@@ -3,15 +3,9 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
-  skipTypeWrappers,
-} from 'eslint-rule-forge';
+import { getArgumentText, skipTypeWrappers } from 'eslint-rule-forge';
 import { asLengthAccess, isArrayOrTupleExpression } from './ast-utils.mjs';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 
 type Options = readonly [];
 
@@ -36,13 +30,6 @@ export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     const services = context.sourceCode.parserServices;
 
     const mut_nodesToFix: {
@@ -90,18 +77,15 @@ export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
         });
       },
       'Program:exit': () => {
-        const namedImports = getNamedImports(tsDataForgeImports);
-
-        const hasArrImport = namedImports.includes('Arr');
+        const arrAt = tsDataForgeValueAt(sourceCode, 'Arr');
 
-        for (const [
-          index,
-          { node, arrayExpression },
-        ] of mut_nodesToFix.entries()) {
+        for (const { node, arrayExpression } of mut_nodesToFix) {
           const arrayText = getArgumentText(sourceCode, arrayExpression);
 
           const originalText = sourceCode.getText(node);
 
+          const arr = arrAt(node);
+
           context.report({
             node,
             messageId: 'useIsNonEmpty',
@@ -109,18 +93,17 @@ export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
               original: originalText,
               arrayName: arrayText,
             },
-            fix: (fixer) => {
-              const replacement = `Arr.isNonEmpty(${arrayText})`;
-
-              const importFixes =
-                index === 0 && !hasArrImport
-                  ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
-                      'Arr',
-                    ])
-                  : [];
-
-              return [...importFixes, fixer.replaceText(node, replacement)];
-            },
+            fix:
+              arr === undefined
+                ? null
+                : (fixer) => {
+                    const replacement = `${arr.localName}.isNonEmpty(${arrayText})`;
+
+                    return [
+                      ...arr.edits(fixer),
+                      fixer.replaceText(node, replacement),
+                    ];
+                  },
           });
         }
       },

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

@@ -167,3 +167,113 @@ describe('prefer-arr-is-non-empty with parenthesized operands', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-arr-is-non-empty and the import it adds', () => {
+  tester.run('prefer-arr-is-non-empty', preferArrIsNonEmpty, {
+    valid: [],
+    invalid: [
+      {
+        name: 'a leading directive stays first',
+        code: dedent`
+          'use client';
+          declare const xs: readonly number[];
+          const ok = xs.length > 0;
+        `,
+        output: dedent`
+          'use client';
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = Arr.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'joins an existing named import from the module',
+        code: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = xs.length > 0;
+        `,
+        output: dedent`
+          import { asInt, Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = Arr.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'turns a type-only specifier into a value import',
+        code: dedent`
+          import { type Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = xs.length > 0;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = Arr.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'writes the local name of an aliased import',
+        code: dedent`
+          import { Arr as A } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = xs.length > 0;
+        `,
+        output: dedent`
+          import { Arr as A } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = A.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'no fix when an import type binds the name',
+        code: dedent`
+          import type { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ok = xs.length > 0;
+        `,
+        output: null,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'no fix where a local binding takes the name',
+        code: dedent`
+          declare const xs: readonly number[];
+          const f = (Arr: unknown) => xs.length > 0;
+        `,
+        output: null,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'each fix adds the import it needs, one per pass',
+        code: dedent`
+          declare const xs: readonly number[];
+          const a = xs.length > 0;
+          const b = 0 < xs.length;
+        `,
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.isNonEmpty(xs);
+            const b = 0 < xs.length;
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.isNonEmpty(xs);
+            const b = Arr.isNonEmpty(xs);
+          `,
+        ],
+        errors: [
+          { messageId: 'useIsNonEmpty' },
+          { messageId: 'useIsNonEmpty' },
+        ],
+      },
+    ],
+  });
+}, 20000);

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

@@ -4,17 +4,14 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import {
-  buildNamedImportFix,
   getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
   skipTypeWrappers,
   typeWrapperLayers,
 } from 'eslint-rule-forge';
 import { Arr } from 'ts-data-forge';
 import type { FixedLengthTuple } from 'ts-type-forge';
 import * as ts from 'typescript';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 
 type Options = readonly [];
 
@@ -47,8 +44,9 @@ type SliceCall = Readonly<{
 type AccumulationCandidate = Readonly<{
   call: TSESTree.CallExpression;
   /**
-   * What the call is replaced with, or `undefined` when the rewrite could not
-   * be derived and the report carries no fix.
+   * What the call is replaced with, after the name `Arr` is bound to
+   * (`scan(xs, f, init)`), or `undefined` when the rewrite could not be
+   * derived and the report carries no fix.
    */
   replacement: string | undefined;
 }>;
@@ -180,13 +178,6 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     const services = sourceCode.parserServices;
 
     const checker = services?.program?.getTypeChecker();
@@ -363,7 +354,7 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
           ? `(${elementText})`
           : elementText;
 
-      return `Arr.scan(${arrayText}, (${parameterText}) => ${bodyText}, ${getArgumentText(sourceCode, seed)})`;
+      return `scan(${arrayText}, (${parameterText}) => ${bodyText}, ${getArgumentText(sourceCode, seed)})`;
     };
 
     /**
@@ -498,36 +489,20 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
       // been seen by the time its `map` is judged, whichever order the traversal
       // reached them in.
       'Program:exit': () => {
-        const hasArrImport =
-          getNamedImports(tsDataForgeImports).includes('Arr');
-
-        // The import is inserted once per pass: two fixes writing the same
-        // insertion point would otherwise produce it twice.
-        const mut_importNeededBy = hasArrImport
-          ? undefined
-          : mut_accumulations.find(
-              (accumulation) => accumulation.replacement !== undefined,
-            )?.call;
+        const arrAt = tsDataForgeValueAt(sourceCode, 'Arr');
 
-        for (const accumulation of mut_accumulations) {
-          const { call, replacement } = accumulation;
+        for (const { call, replacement } of mut_accumulations) {
+          const arr = arrAt(call);
 
           context.report({
             node: call,
             messageId: 'preferArrScanAccumulate',
             fix:
-              replacement === undefined
+              replacement === undefined || arr === undefined
                 ? undefined
                 : (fixer) => [
-                    ...(call === mut_importNeededBy
-                      ? buildNamedImportFix(
-                          fixer,
-                          program,
-                          TS_DATA_FORGE_MODULE,
-                          ['Arr'],
-                        )
-                      : []),
-                    fixer.replaceText(call, replacement),
+                    ...arr.edits(fixer),
+                    fixer.replaceText(call, `${arr.localName}.${replacement}`),
                   ],
           });
         }

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

@@ -442,3 +442,58 @@ describe('prefer-arr-scan with parenthesized operands', () => {
     ],
   });
 });
+
+describe('prefer-arr-scan and the import it adds', () => {
+  tester.run('prefer-arr-scan', preferArrScan, {
+    valid: [],
+    invalid: [
+      {
+        name: 'writes the local name of an aliased import',
+        code: dedent`
+          import { Arr as A } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = xs.reduce<readonly number[]>(
+            (acc, x) => [...acc, (acc.at(-1) ?? 0) + x],
+            [0],
+          );
+        `,
+        output: dedent`
+          import { Arr as A } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = A.scan(xs, (acc, x) => (acc) + x, 0);
+        `,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+      {
+        name: 'turns a type-only specifier into a value import',
+        code: dedent`
+          import { type Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = xs.reduce<readonly number[]>(
+            (acc, x) => [...acc, (acc.at(-1) ?? 0) + x],
+            [0],
+          );
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = Arr.scan(xs, (acc, x) => (acc) + x, 0);
+        `,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+      {
+        name: 'no fix when an import type binds the name',
+        code: dedent`
+          import type { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = xs.reduce<readonly number[]>(
+            (acc, x) => [...acc, (acc.at(-1) ?? 0) + x],
+            [0],
+          );
+        `,
+        output: null,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+    ],
+  });
+});