eslint-plugin-ts-data-forge 0.1.0

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

@@ -0,0 +1,188 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferArrIsMaxLengthArray } from './prefer-arr-is-max-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-max-length-array', () => {
+  tester.run('prefer-arr-is-max-length-array', preferArrIsMaxLengthArray, {
+    valid: [
+      {
+        name: 'ignores non-array types',
+        code: dedent`
+          const str = "hello";
+          const ok = str.length <= 5;
+        `,
+      },
+      {
+        name: 'ignores > comparisons',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length > 0;
+        `,
+      },
+      {
+        name: 'ignores < comparisons',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length < 5;
+        `,
+      },
+      {
+        name: 'ignores >= comparisons (that is a min bound)',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length >= 3;
+        `,
+      },
+      {
+        name: 'ignores === comparisons',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length === 3;
+        `,
+      },
+      {
+        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 const variable of type number',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const n: number = 3;
+          const ok = xs.length <= n;
+        `,
+      },
+      {
+        name: 'defers bounded range to the bounded rule',
+        code: dedent`
+          const xs: readonly number[] = [1, 2, 3];
+          const ok = xs.length >= 1 && xs.length <= 5;
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces xs.length <= n with Arr.isMaxLengthArray',
+        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.isMaxLengthArray(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsMaxLengthArray' }],
+      },
+      {
+        name: 'replaces n >= xs.length with Arr.isMaxLengthArray',
+        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.isMaxLengthArray(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsMaxLengthArray' }],
+      },
+      {
+        name: 'works with no type annotation',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length <= 1;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3];
+          const ok = Arr.isMaxLengthArray(xs, 1);
+        `,
+        errors: [{ messageId: 'useIsMaxLengthArray' }],
+      },
+      {
+        name: 'works with const assertion',
+        code: dedent`
+          const xs = [1, 2, 3] as const;
+          const ok = xs.length <= 2;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3] as const;
+          const ok = Arr.isMaxLengthArray(xs, 2);
+        `,
+        errors: [{ messageId: 'useIsMaxLengthArray' }],
+      },
+      {
+        name: 'works with variable length',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const n = 2;
+          const ok = xs.length <= n;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3];
+          const n = 2;
+          const ok = Arr.isMaxLengthArray(xs, n);
+        `,
+        errors: [{ messageId: 'useIsMaxLengthArray' }],
+      },
+      {
+        name: 'keeps existing Arr import',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+
+          const xs = [1, 2, 3];
+          const ok = xs.length <= 1;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+
+          const xs = [1, 2, 3];
+          const ok = Arr.isMaxLengthArray(xs, 1);
+        `,
+        errors: [{ messageId: 'useIsMaxLengthArray' }],
+      },
+      {
+        name: 'replaces multiple checks',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ys = [4, 5];
+          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(xs, 2);
+          const ok2 = Arr.isMaxLengthArray(ys, 1);
+        `,
+        errors: [
+          { messageId: 'useIsMaxLengthArray' },
+          { messageId: 'useIsMaxLengthArray' },
+        ],
+      },
+    ],
+  });
+}, 20000);

package/src/rules/prefer-arr-is-min-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 = 'useIsMinLengthArray';
+
+export const preferArrIsMinLengthArray: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `xs.length >= n` with `Arr.isMinLengthArray(xs, n)` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useIsMinLengthArray:
+        'Replace `{{original}}` with `Arr.isMinLengthArray({{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 lower 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: 'useIsMinLengthArray',
+            data: {
+              original: originalText,
+              arrayName: arrayText,
+              length: lengthText,
+            },
+            fix: (fixer) => {
+              const replacement = `Arr.isMinLengthArray(${arrayText}, ${lengthText})`;
+
+              const importFixes =
+                index === 0 && !hasArrImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+} as const;

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

@@ -0,0 +1,202 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferArrIsMinLengthArray } from './prefer-arr-is-min-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-min-length-array', () => {
+  tester.run('prefer-arr-is-min-length-array', preferArrIsMinLengthArray, {
+    valid: [
+      {
+        name: 'ignores non-array types',
+        code: dedent`
+          const str = "hello";
+          const ok = str.length >= 5;
+        `,
+      },
+      {
+        name: 'ignores < comparisons',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length < 5;
+        `,
+      },
+      {
+        name: 'ignores > comparisons',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length > 0;
+        `,
+      },
+      {
+        name: 'ignores === comparisons',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length === 3;
+        `,
+      },
+      {
+        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.isMinLengthArray',
+        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.isMinLengthArray(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsMinLengthArray' }],
+      },
+      {
+        name: 'replaces n <= xs.length with Arr.isMinLengthArray',
+        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.isMinLengthArray(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsMinLengthArray' }],
+      },
+      {
+        name: 'works with no type annotation',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length >= 1;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3];
+          const ok = Arr.isMinLengthArray(xs, 1);
+        `,
+        errors: [{ messageId: 'useIsMinLengthArray' }],
+      },
+      {
+        name: 'works with const assertion',
+        code: dedent`
+          const xs = [1, 2, 3] as const;
+          const ok = xs.length >= 2;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3] as const;
+          const ok = Arr.isMinLengthArray(xs, 2);
+        `,
+        errors: [{ messageId: 'useIsMinLengthArray' }],
+      },
+      {
+        name: 'works with variable length',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const n = 2;
+          const ok = xs.length >= n;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3];
+          const n = 2;
+          const ok = Arr.isMinLengthArray(xs, n);
+        `,
+        errors: [{ messageId: 'useIsMinLengthArray' }],
+      },
+      {
+        name: 'keeps existing Arr import',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+
+          const xs = [1, 2, 3];
+          const ok = xs.length >= 1;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+
+          const xs = [1, 2, 3];
+          const ok = Arr.isMinLengthArray(xs, 1);
+        `,
+        errors: [{ messageId: 'useIsMinLengthArray' }],
+      },
+      {
+        name: 'replaces multiple checks',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ys = [4, 5];
+          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(xs, 2);
+          const ok2 = Arr.isMinLengthArray(ys, 1);
+        `,
+        errors: [
+          { messageId: 'useIsMinLengthArray' },
+          { messageId: 'useIsMinLengthArray' },
+        ],
+      },
+      {
+        name: 'works with >= 0 (checking non-empty)',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length >= 1;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3];
+          const ok = Arr.isMinLengthArray(xs, 1);
+        `,
+        errors: [{ messageId: 'useIsMinLengthArray' }],
+      },
+    ],
+  });
+}, 20000);

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

@@ -0,0 +1,131 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useIsNonEmpty';
+
+export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `xs.length > 0` with `Arr.isNonEmpty(xs)` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useIsNonEmpty:
+        'Replace `{{original}}` with `Arr.isNonEmpty({{arrayName}})` 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;
+    }[] = [];
+
+    return {
+      BinaryExpression: (node) => {
+        // Check for `xs.length > 0` or `0 < xs.length`
+        if (node.operator !== '>' && node.operator !== '<') return;
+
+        const isLengthOnLeft = node.operator === '>';
+
+        const lengthSide = node[isLengthOnLeft ? 'left' : 'right'];
+
+        const numberSide = node[isLengthOnLeft ? 'right' : 'left'];
+
+        // Check if one side is `.length` and the other is 0
+        if (
+          lengthSide.type !== AST_NODE_TYPES.MemberExpression ||
+          lengthSide.property.type !== AST_NODE_TYPES.Identifier ||
+          lengthSide.property.name !== 'length' ||
+          numberSide.type !== AST_NODE_TYPES.Literal ||
+          numberSide.value !== 0
+        ) {
+          return;
+        }
+
+        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,
+        });
+      },
+      'Program:exit': () => {
+        const namedImports = getNamedImports(tsDataForgeImport);
+
+        const hasArrImport = namedImports.includes('Arr');
+
+        for (const [
+          index,
+          { node, arrayExpression },
+        ] of mut_nodesToFix.entries()) {
+          const arrayText = sourceCode.getText(arrayExpression);
+
+          const originalText = sourceCode.getText(node);
+
+          context.report({
+            node,
+            messageId: 'useIsNonEmpty',
+            data: {
+              original: originalText,
+              arrayName: arrayText,
+            },
+            fix: (fixer) => {
+              const replacement = `Arr.isNonEmpty(${arrayText})`;
+
+              const importFixes =
+                index === 0 && !hasArrImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+} as const;