eslint-plugin-ts-data-forge 0.1.0

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

@@ -0,0 +1,154 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferArrIsBoundedLengthArray } from './prefer-arr-is-bounded-length-array.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-arr-is-bounded-length-array', () => {
+  tester.run(
+    'prefer-arr-is-bounded-length-array',
+    preferArrIsBoundedLengthArray,
+    {
+      valid: [
+        {
+          name: 'ignores non-array types',
+          code: dedent`
+            const str = "hello";
+            const ok = str.length >= 1 && str.length <= 5;
+          `,
+        },
+        {
+          name: 'ignores a single min bound',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const ok = xs.length >= 1;
+          `,
+        },
+        {
+          name: 'ignores a single max bound',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const ok = xs.length <= 5;
+          `,
+        },
+        {
+          name: 'ignores two bounds of the same kind',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const ok = xs.length >= 1 && xs.length >= 2;
+          `,
+        },
+        {
+          name: 'ignores bounds on different arrays',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const ys = [4, 5];
+            const ok = xs.length >= 1 && ys.length <= 5;
+          `,
+        },
+        {
+          name: 'ignores || combinations',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const ok = xs.length >= 1 || xs.length <= 5;
+          `,
+        },
+        {
+          name: 'ignores comparison with non-const variable',
+          code: dedent`
+            const xs = [1, 2, 3];
+            let lo = 1;
+            const ok = xs.length >= lo && xs.length <= 5;
+          `,
+        },
+      ],
+      invalid: [
+        {
+          name: 'replaces min && max with Arr.isBoundedLengthArray',
+          code: dedent`
+            const xs: readonly number[] = [1, 2, 3];
+            const ok = xs.length >= 1 && xs.length <= 5;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs: readonly number[] = [1, 2, 3];
+            const ok = Arr.isBoundedLengthArray(xs, 1, 5);
+          `,
+          errors: [{ messageId: 'useIsBoundedLengthArray' }],
+        },
+        {
+          name: 'normalizes max && min ordering to (min, max)',
+          code: dedent`
+            const xs: readonly number[] = [1, 2, 3];
+            const ok = xs.length <= 5 && xs.length >= 1;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs: readonly number[] = [1, 2, 3];
+            const ok = Arr.isBoundedLengthArray(xs, 1, 5);
+          `,
+          errors: [{ messageId: 'useIsBoundedLengthArray' }],
+        },
+        {
+          name: 'handles reversed operand order in each comparison',
+          code: dedent`
+            const xs: readonly number[] = [1, 2, 3];
+            const ok = 1 <= xs.length && 5 >= xs.length;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs: readonly number[] = [1, 2, 3];
+            const ok = Arr.isBoundedLengthArray(xs, 1, 5);
+          `,
+          errors: [{ messageId: 'useIsBoundedLengthArray' }],
+        },
+        {
+          name: 'works with const variable bounds',
+          code: dedent`
+            const xs = [1, 2, 3];
+            const lo = 1;
+            const hi = 5;
+            const ok = xs.length >= lo && xs.length <= hi;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            const xs = [1, 2, 3];
+            const lo = 1;
+            const hi = 5;
+            const ok = Arr.isBoundedLengthArray(xs, lo, hi);
+          `,
+          errors: [{ messageId: 'useIsBoundedLengthArray' }],
+        },
+        {
+          name: 'keeps existing Arr import',
+          code: dedent`
+            import { Arr } from 'ts-data-forge';
+
+            const xs = [1, 2, 3];
+            const ok = xs.length >= 1 && xs.length <= 5;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+
+            const xs = [1, 2, 3];
+            const ok = Arr.isBoundedLengthArray(xs, 1, 5);
+          `,
+          errors: [{ messageId: 'useIsBoundedLengthArray' }],
+        },
+      ],
+    },
+  );
+}, 20000);

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

@@ -0,0 +1,149 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import { type DeepReadonly } from 'ts-type-forge';
+import { isIntegerLiteralOrConstant } from './ast-utils.mjs';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useIsFixedLengthArray';
+
+export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `xs.length === n` with `Arr.isFixedLengthArray(xs, n)` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useIsFixedLengthArray:
+        'Replace `{{original}}` with `Arr.isFixedLengthArray({{arrayName}}, {{length}})` from ts-data-forge.',
+    },
+  },
+
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+
+    const program = sourceCode.ast;
+
+    const tsDataForgeImport = getTsDataForgeImport(program);
+
+    const services = context.sourceCode.parserServices;
+
+    const mut_nodesToFix: {
+      node: TSESTree.BinaryExpression;
+      arrayExpression: TSESTree.Expression;
+      lengthExpression: TSESTree.Expression;
+      isNegated: boolean;
+    }[] = [];
+
+    return {
+      BinaryExpression: (node) => {
+        // Check for `xs.length === n` or `n === xs.length` or `xs.length !== n`
+        if (node.operator !== '===' && node.operator !== '!==') return;
+
+        const isNegated = node.operator === '!==';
+
+        const isLengthOnLeft = isLengthAccess(node.left);
+
+        const lengthSide = node[isLengthOnLeft ? 'left' : 'right'];
+
+        const valueSide = node[isLengthOnLeft ? 'right' : 'left'];
+
+        if (!isLengthAccess(lengthSide)) return;
+
+        // Only match integer literals or const variables initialized with integer literals
+        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) return;
+
+        // lengthSide is MemberExpression accessing .length
+        const arrayExpression = lengthSide.object;
+
+        // Check if arrayExpression is actually an array type
+        if (services?.program !== undefined && services.program !== null) {
+          const checker = services.program.getTypeChecker();
+
+          const tsNode = services.esTreeNodeToTSNodeMap?.get(arrayExpression);
+
+          if (tsNode !== undefined) {
+            const type = checker.getTypeAtLocation(tsNode);
+
+            // Check if it's an array type or tuple type
+            const isArrayType =
+              checker.isArrayType(type) || checker.isTupleType(type);
+
+            if (!isArrayType) return;
+          } else {
+            return;
+          }
+        } else {
+          return;
+        }
+
+        mut_nodesToFix.push({
+          node,
+          arrayExpression,
+          lengthExpression: valueSide,
+          isNegated,
+        });
+      },
+      'Program:exit': () => {
+        const namedImports = getNamedImports(tsDataForgeImport);
+
+        const hasArrImport = namedImports.includes('Arr');
+
+        for (const [
+          index,
+          { node, arrayExpression, lengthExpression, isNegated },
+        ] of mut_nodesToFix.entries()) {
+          const arrayText = sourceCode.getText(arrayExpression);
+
+          const lengthText = sourceCode.getText(lengthExpression);
+
+          const originalText = sourceCode.getText(node);
+
+          context.report({
+            node,
+            messageId: 'useIsFixedLengthArray',
+            data: {
+              original: originalText,
+              arrayName: arrayText,
+              length: lengthText,
+            },
+            fix: (fixer) => {
+              const baseCall = `Arr.isFixedLengthArray(${arrayText}, ${lengthText})`;
+
+              const replacement = isNegated ? `!${baseCall}` : baseCall;
+
+              const importFixes =
+                index === 0 && !hasArrImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+} as const;
+
+const isLengthAccess = (
+  node: DeepReadonly<TSESTree.Expression>,
+): node is TSESTree.MemberExpression =>
+  node.type === AST_NODE_TYPES.MemberExpression &&
+  node.property.type === AST_NODE_TYPES.Identifier &&
+  node.property.name === 'length';

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

@@ -0,0 +1,214 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferArrIsFixedLengthArray } from './prefer-arr-is-fixed-length-array.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-arr-is-fixed-length-array', () => {
+  tester.run('prefer-arr-is-fixed-length-array', preferArrIsFixedLengthArray, {
+    valid: [
+      {
+        name: 'ignores non-array types',
+        code: dedent`
+          const str = "hello";
+          const ok = str.length === 5;
+        `,
+      },
+      {
+        name: 'ignores other comparisons',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length > 0;
+        `,
+      },
+      {
+        name: 'ignores comparison with non-const variable',
+        code: dedent`
+          const xs = [1, 2, 3];
+          let n = 3;
+          const ok = xs.length === n;
+        `,
+      },
+      {
+        name: 'ignores comparison with function return value',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length === Math.floor(3.5);
+        `,
+      },
+      {
+        name: 'ignores comparison with const variable initialized by non-literal',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const n = Math.floor(3.5);
+          const ok = xs.length === n;
+        `,
+      },
+      {
+        name: 'ignores comparison with const variable of type number',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const n: number = 3;
+          const ok = xs.length === n;
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces xs.length === n with Arr.isFixedLengthArray',
+        code: dedent`
+          const xs: readonly number[] = [1, 2, 3];
+          const ok = xs.length === 3;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs: readonly number[] = [1, 2, 3];
+          const ok = Arr.isFixedLengthArray(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsFixedLengthArray' }],
+      },
+      {
+        name: 'replaces n === xs.length with Arr.isFixedLengthArray',
+        code: dedent`
+          const xs: readonly number[] = [1, 2, 3];
+          const ok = 3 === xs.length;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs: readonly number[] = [1, 2, 3];
+          const ok = Arr.isFixedLengthArray(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsFixedLengthArray' }],
+      },
+      {
+        name: 'works with no type annotation',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length === 3;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3];
+          const ok = Arr.isFixedLengthArray(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsFixedLengthArray' }],
+      },
+      {
+        name: 'works with const assertion',
+        code: dedent`
+          const xs = [1, 2, 3] as const;
+          const ok = xs.length === 3;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3] as const;
+          const ok = Arr.isFixedLengthArray(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsFixedLengthArray' }],
+      },
+      {
+        name: 'works with variable length',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const n = 3;
+          const ok = xs.length === n;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3];
+          const n = 3;
+          const ok = Arr.isFixedLengthArray(xs, n);
+        `,
+        errors: [{ messageId: 'useIsFixedLengthArray' }],
+      },
+      {
+        name: 'keeps existing Arr import',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+
+          const xs = [1, 2, 3];
+          const ok = xs.length === 3;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+
+          const xs = [1, 2, 3];
+          const ok = Arr.isFixedLengthArray(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsFixedLengthArray' }],
+      },
+      {
+        name: 'replaces multiple checks',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ys = [4, 5];
+          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(xs, 3);
+          const ok2 = Arr.isFixedLengthArray(ys, 2);
+        `,
+        errors: [
+          { messageId: 'useIsFixedLengthArray' },
+          { messageId: 'useIsFixedLengthArray' },
+        ],
+      },
+      {
+        name: 'replaces xs.length !== n with !Arr.isFixedLengthArray',
+        code: dedent`
+          const xs: readonly number[] = [1, 2, 3];
+          const ok = xs.length !== 3;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs: readonly number[] = [1, 2, 3];
+          const ok = !Arr.isFixedLengthArray(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsFixedLengthArray' }],
+      },
+      {
+        name: 'replaces n !== xs.length with !Arr.isFixedLengthArray',
+        code: dedent`
+          const xs: readonly number[] = [1, 2, 3];
+          const ok = 3 !== xs.length;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs: readonly number[] = [1, 2, 3];
+          const ok = !Arr.isFixedLengthArray(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsFixedLengthArray' }],
+      },
+      {
+        name: 'works with !== and no type annotation',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length !== 5;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3];
+          const ok = !Arr.isFixedLengthArray(xs, 5);
+        `,
+        errors: [{ messageId: 'useIsFixedLengthArray' }],
+      },
+    ],
+  });
+}, 20000);

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

@@ -0,0 +1,141 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import {
+  isIntegerLiteralOrConstant,
+  isLengthAccess,
+  isPartOfBoundedLengthCheck,
+} from './ast-utils.mjs';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useIsMaxLengthArray';
+
+export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `xs.length <= n` with `Arr.isMaxLengthArray(xs, n)` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useIsMaxLengthArray:
+        'Replace `{{original}}` with `Arr.isMaxLengthArray({{arrayName}}, {{length}})` from ts-data-forge.',
+    },
+  },
+
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+
+    const program = sourceCode.ast;
+
+    const tsDataForgeImport = getTsDataForgeImport(program);
+
+    const services = context.sourceCode.parserServices;
+
+    const mut_nodesToFix: {
+      node: TSESTree.BinaryExpression;
+      arrayExpression: TSESTree.Expression;
+      lengthExpression: TSESTree.Expression;
+    }[] = [];
+
+    return {
+      BinaryExpression: (node) => {
+        // Check for `xs.length <= n` or `n >= xs.length`
+        if (node.operator !== '>=' && node.operator !== '<=') return;
+
+        // Defer to `prefer-arr-is-bounded-length-array` when this comparison is
+        // the upper bound of a `min && max` pair on the same array.
+        if (isPartOfBoundedLengthCheck(node, sourceCode)) return;
+
+        // xs.length <= n  or  n >= xs.length
+        const isLengthOnLeft = node.operator === '<=';
+
+        const lengthSide = node[isLengthOnLeft ? 'left' : 'right'];
+
+        const valueSide = node[isLengthOnLeft ? 'right' : 'left'];
+
+        // Check if lengthSide is accessing .length
+        if (!isLengthAccess(lengthSide)) return;
+
+        // Only match integer literals or const variables initialized with integer literals
+        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) return;
+
+        // lengthSide is MemberExpression accessing .length
+        const arrayExpression = lengthSide.object;
+
+        // Check if arrayExpression is actually an array type
+        if (services?.program !== undefined && services.program !== null) {
+          const checker = services.program.getTypeChecker();
+
+          const tsNode = services.esTreeNodeToTSNodeMap?.get(arrayExpression);
+
+          if (tsNode !== undefined) {
+            const type = checker.getTypeAtLocation(tsNode);
+
+            // Check if it's an array type or tuple type
+            const isArrayType =
+              checker.isArrayType(type) || checker.isTupleType(type);
+
+            if (!isArrayType) return;
+          } else {
+            return;
+          }
+        } else {
+          return;
+        }
+
+        mut_nodesToFix.push({
+          node,
+          arrayExpression,
+          lengthExpression: valueSide,
+        });
+      },
+      'Program:exit': () => {
+        const namedImports = getNamedImports(tsDataForgeImport);
+
+        const hasArrImport = namedImports.includes('Arr');
+
+        for (const [
+          index,
+          { node, arrayExpression, lengthExpression },
+        ] of mut_nodesToFix.entries()) {
+          const arrayText = sourceCode.getText(arrayExpression);
+
+          const lengthText = sourceCode.getText(lengthExpression);
+
+          const originalText = sourceCode.getText(node);
+
+          context.report({
+            node,
+            messageId: 'useIsMaxLengthArray',
+            data: {
+              original: originalText,
+              arrayName: arrayText,
+              length: lengthText,
+            },
+            fix: (fixer) => {
+              const replacement = `Arr.isMaxLengthArray(${arrayText}, ${lengthText})`;
+
+              const importFixes =
+                index === 0 && !hasArrImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+} as const;