eslint-config-typed 4.2.1 → 4.3.1

package/src/plugins/ts-data-forge/rules/prefer-arr-is-array-of-length.test.mts

@@ -0,0 +1,183 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferArrIsArrayOfLength } from './prefer-arr-is-array-of-length.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-arr-is-array-of-length', () => {
+  tester.run('prefer-arr-is-array-of-length', preferArrIsArrayOfLength, {
+    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;
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces xs.length === n with Arr.isArrayOfLength',
+        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.isArrayOfLength(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsArrayOfLength' }],
+      },
+      {
+        name: 'replaces n === xs.length with Arr.isArrayOfLength',
+        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.isArrayOfLength(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsArrayOfLength' }],
+      },
+      {
+        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.isArrayOfLength(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsArrayOfLength' }],
+      },
+      {
+        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.isArrayOfLength(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsArrayOfLength' }],
+      },
+      {
+        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.isArrayOfLength(xs, n);
+        `,
+        errors: [{ messageId: 'useIsArrayOfLength' }],
+      },
+      {
+        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.isArrayOfLength(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsArrayOfLength' }],
+      },
+      {
+        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.isArrayOfLength(xs, 3);
+          const ok2 = Arr.isArrayOfLength(ys, 2);
+        `,
+        errors: [
+          { messageId: 'useIsArrayOfLength' },
+          { messageId: 'useIsArrayOfLength' },
+        ],
+      },
+      {
+        name: 'replaces xs.length !== n with !Arr.isArrayOfLength',
+        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.isArrayOfLength(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsArrayOfLength' }],
+      },
+      {
+        name: 'replaces n !== xs.length with !Arr.isArrayOfLength',
+        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.isArrayOfLength(xs, 3);
+        `,
+        errors: [{ messageId: 'useIsArrayOfLength' }],
+      },
+      {
+        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.isArrayOfLength(xs, 5);
+        `,
+        errors: [{ messageId: 'useIsArrayOfLength' }],
+      },
+    ],
+  });
+}, 20000);

package/src/plugins/ts-data-forge/rules/prefer-arr-is-array.mts

@@ -0,0 +1,97 @@
+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 = 'useArrIsArray';
+
+export const preferArrIsArray: TSESLint.RuleModule<MessageIds, Options> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `Array.isArray` with `Arr.isArray` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useArrIsArray:
+        'Replace `Array.isArray` with `Arr.isArray` from ts-data-forge.',
+    },
+  },
+
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+
+    const program = sourceCode.ast;
+
+    const tsDataForgeImport = getTsDataForgeImport(program);
+
+    const mut_nodesToFix: TSESTree.CallExpression[] = [];
+
+    return {
+      CallExpression: (node) => {
+        if (!isArrayIsArrayCall(node)) return;
+
+        mut_nodesToFix.push(node);
+      },
+      'Program:exit': () => {
+        // Check if Arr is already imported
+        const hasArrImport = getNamedImports(tsDataForgeImport).includes('Arr');
+
+        // Note: We add import only for the first node to avoid conflicts when
+        // multiple fixes try to insert at the same position. This means if the
+        // first node is disabled via eslint-disable comment, no import will be
+        // added.
+        for (const [index, node] of mut_nodesToFix.entries()) {
+          context.report({
+            node,
+            messageId: 'useArrIsArray',
+            fix: (fixer) => {
+              const callee = node.callee;
+
+              if (callee.type !== AST_NODE_TYPES.MemberExpression) return [];
+
+              const replacement = `Arr.isArray${sourceCode.getText(node).slice(sourceCode.getText(callee).length)}`;
+
+              // Add import only for the first node and only if not already imported
+              const importFixes =
+                index === 0 && !hasArrImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+};
+
+const isArrayIsArrayCall = (
+  node: DeepReadonly<TSESTree.CallExpression>,
+): boolean => {
+  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+
+  const { object, property } = node.callee;
+
+  if (object.type !== AST_NODE_TYPES.Identifier) return false;
+
+  if (object.name !== 'Array') return false;
+
+  if (property.type !== AST_NODE_TYPES.Identifier) return false;
+
+  if (property.name !== 'isArray') return false;
+
+  return true;
+};

package/src/plugins/ts-data-forge/rules/prefer-arr-is-array.test.mts

@@ -0,0 +1,62 @@
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferArrIsArray } from './prefer-arr-is-array.mjs';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
+  valid: [
+    {
+      name: 'Already using Arr.isArray',
+      code: dedent`
+        import { Arr } from 'ts-data-forge';
+        const result = Arr.isArray(value);
+      `,
+    },
+    {
+      name: 'Not Array.isArray call',
+      code: dedent`
+        const obj = { isArray: () => true };
+        const result = obj.isArray(value);
+      `,
+    },
+  ],
+  invalid: [
+    {
+      name: 'Replace Array.isArray with Arr.isArray',
+      code: dedent`
+        const result = Array.isArray(value);
+      `,
+      output: dedent`
+        import { Arr } from 'ts-data-forge';
+        const result = Arr.isArray(value);
+      `,
+      errors: [{ messageId: 'useArrIsArray' }],
+    },
+    {
+      name: 'Replace Array.isArray with Arr.isArray when Arr is already imported',
+      code: dedent`
+        import { Arr } from 'ts-data-forge';
+        const result = Array.isArray(value);
+      `,
+      output: dedent`
+        import { Arr } from 'ts-data-forge';
+        const result = Arr.isArray(value);
+      `,
+      errors: [{ messageId: 'useArrIsArray' }],
+    },
+    {
+      name: 'Replace multiple Array.isArray calls',
+      code: dedent`
+        const result1 = Array.isArray(value1);
+        const result2 = Array.isArray(value2);
+      `,
+      output: dedent`
+        import { Arr } from 'ts-data-forge';
+        const result1 = Arr.isArray(value1);
+        const result2 = Arr.isArray(value2);
+      `,
+      errors: [{ messageId: 'useArrIsArray' }, { messageId: 'useArrIsArray' }],
+    },
+  ],
+});

package/src/plugins/ts-data-forge/rules/prefer-arr-is-non-empty.mts

@@ -0,0 +1,106 @@
+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 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 = isLengthOnLeft ? node.left : node.right;
+
+        const numberSide = isLengthOnLeft ? node.right : node.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;
+        }
+
+        mut_nodesToFix.push({
+          node,
+          arrayExpression: lengthSide.object,
+        });
+      },
+      '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: [],
+};

package/src/plugins/ts-data-forge/rules/prefer-arr-is-non-empty.test.mts

@@ -0,0 +1,83 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferArrIsNonEmpty } from './prefer-arr-is-non-empty.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-arr-is-non-empty', () => {
+  tester.run('prefer-arr-is-non-empty', preferArrIsNonEmpty, {
+    valid: [
+      {
+        name: 'ignores other comparisons',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length >= 1;
+        `,
+      },
+      {
+        name: 'ignores comparisons with non-zero',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length > 1;
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces xs.length > 0 with Arr.isNonEmpty',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = xs.length > 0;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3];
+          const ok = Arr.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'replaces 0 < xs.length with Arr.isNonEmpty',
+        code: dedent`
+          const xs = [1, 2, 3];
+          const ok = 0 < xs.length;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const xs = [1, 2, 3];
+          const ok = Arr.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+      {
+        name: 'keeps existing Arr import',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+
+          const xs = [1, 2, 3];
+          const ok = xs.length > 0;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+
+          const xs = [1, 2, 3];
+          const ok = Arr.isNonEmpty(xs);
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+    ],
+  });
+}, 20000);