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

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

@@ -1,16 +1,11 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
-} from 'eslint-rule-forge';
+import { getArgumentText } from 'eslint-rule-forge';
 import {
   isArrayOrTupleExpression,
   isSameArrayText,
   parseLengthComparison,
 } from './ast-utils.mjs';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 
 type Options = readonly [];
 
@@ -38,13 +33,6 @@ export const preferArrIsBoundedLengthArray: 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: {
@@ -100,14 +88,14 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
         });
       },
       'Program:exit': () => {
-        const namedImports = getNamedImports(tsDataForgeImports);
+        const arrAt = tsDataForgeValueAt(sourceCode, 'Arr');
 
-        const hasArrImport = namedImports.includes('Arr');
-
-        for (const [
-          index,
-          { node, arrayExpression, minExpression, maxExpression },
-        ] of mut_nodesToFix.entries()) {
+        for (const {
+          node,
+          arrayExpression,
+          minExpression,
+          maxExpression,
+        } of mut_nodesToFix) {
           const arrayText = getArgumentText(sourceCode, arrayExpression);
 
           const minText = sourceCode.getText(minExpression);
@@ -116,6 +104,8 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
 
           const originalText = sourceCode.getText(node);
 
+          const arr = arrAt(node);
+
           context.report({
             node,
             messageId: 'useIsBoundedLengthArray',
@@ -125,18 +115,17 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
               min: minText,
               max: maxText,
             },
-            fix: (fixer) => {
-              const replacement = `Arr.isBoundedLengthArray(${minText}, ${maxText}, ${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}.isBoundedLengthArray(${minText}, ${maxText}, ${arrayText})`;
+
+                    return [
+                      ...arr.edits(fixer),
+                      fixer.replaceText(node, replacement),
+                    ];
+                  },
           });
         }
       },

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

@@ -1,17 +1,11 @@
 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,
 } from './ast-utils.mjs';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 
 type Options = readonly [];
 
@@ -39,13 +33,6 @@ export const preferArrIsFixedLengthArray: 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: {
@@ -92,27 +79,29 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
         mut_nodesToFix.push({
           node,
           arrayExpression,
-          // The literal or constant itself: a wrapper such as `as number`
-          // would only widen the length the guard narrows to.
+          // The literal or constant itself: a wrapper such as `as number` would
+          // only widen the length the guard narrows to.
           lengthExpression: skipTypeWrappers(valueSide),
           isNegated,
         });
       },
       'Program:exit': () => {
-        const namedImports = getNamedImports(tsDataForgeImports);
+        const arrAt = tsDataForgeValueAt(sourceCode, 'Arr');
 
-        const hasArrImport = namedImports.includes('Arr');
-
-        for (const [
-          index,
-          { node, arrayExpression, lengthExpression, isNegated },
-        ] of mut_nodesToFix.entries()) {
+        for (const {
+          node,
+          arrayExpression,
+          lengthExpression,
+          isNegated,
+        } 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: 'useIsFixedLengthArray',
@@ -121,20 +110,19 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
               arrayName: arrayText,
               length: lengthText,
             },
-            fix: (fixer) => {
-              const baseCall = `Arr.isFixedLengthArray(${lengthText}, ${arrayText})`;
-
-              const replacement = isNegated ? `!${baseCall}` : baseCall;
-
-              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 baseCall = `${arr.localName}.isFixedLengthArray(${lengthText}, ${arrayText})`;
+
+                    const replacement = isNegated ? `!${baseCall}` : baseCall;
+
+                    return [
+                      ...arr.edits(fixer),
+                      fixer.replaceText(node, replacement),
+                    ];
+                  },
           });
         }
       },

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: {
@@ -98,26 +85,27 @@ export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
         mut_nodesToFix.push({
           node,
           arrayExpression,
-          // The literal or constant itself: a wrapper such as `as number`
-          // would only widen the length the guard narrows to.
+          // The literal or constant itself: a wrapper such as `as number` would
+          // only widen the length the guard narrows to.
           lengthExpression: skipTypeWrappers(valueSide),
         });
       },
       '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: {
@@ -98,26 +85,27 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
         mut_nodesToFix.push({
           node,
           arrayExpression,
-          // The literal or constant itself: a wrapper such as `as number`
-          // would only widen the length the guard narrows to.
+          // The literal or constant itself: a wrapper such as `as number` would
+          // only widen the length the guard narrows to.
           lengthExpression: skipTypeWrappers(valueSide),
         });
       },
       '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),
+                    ];
+                  },
           });
         }
       },