eslint-config-typed 4.2.1 → 4.3.1

package/src/plugins/ts-data-forge/rules/prefer-is-record-and-has-key.mts

@@ -0,0 +1,158 @@
+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 = 'useIsRecordAndHasKey';
+
+export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
+  {
+    meta: {
+      type: 'suggestion',
+      docs: {
+        description:
+          'Replace `Object.hasOwn(obj, key)` or `key in obj` with `isRecord(obj) && hasKey(obj, key)` from ts-data-forge',
+      },
+      fixable: 'code',
+      schema: [],
+      messages: {
+        useIsRecordAndHasKey:
+          'Replace `{{original}}` with `isRecord({{objName}}) && hasKey({{objName}}, {{keyName}})` from ts-data-forge.',
+      },
+    },
+
+    create: (context) => {
+      const sourceCode = context.sourceCode;
+
+      const program = sourceCode.ast;
+
+      const tsDataForgeImport = getTsDataForgeImport(program);
+
+      const mut_nodesToFix: {
+        node: TSESTree.CallExpression | TSESTree.BinaryExpression;
+        objExpression: TSESTree.Expression;
+        keyExpression: TSESTree.Expression;
+      }[] = [];
+
+      return {
+        // Handle Object.hasOwn(obj, key)
+        CallExpression: (node) => {
+          if (
+            node.callee.type !== AST_NODE_TYPES.MemberExpression ||
+            node.callee.object.type !== AST_NODE_TYPES.Identifier ||
+            node.callee.object.name !== 'Object' ||
+            node.callee.property.type !== AST_NODE_TYPES.Identifier ||
+            node.callee.property.name !== 'hasOwn'
+          ) {
+            return;
+          }
+
+          // Check arguments: Object.hasOwn(obj, key)
+          if (node.arguments.length !== 2) return;
+
+          const objArg = node.arguments[0];
+
+          const keyArg = node.arguments[1];
+
+          if (objArg === undefined || keyArg === undefined) return;
+
+          // Type guard: ensure arguments are Expressions (not SpreadElement)
+          if (
+            objArg.type === AST_NODE_TYPES.SpreadElement ||
+            keyArg.type === AST_NODE_TYPES.SpreadElement
+          ) {
+            return;
+          }
+
+          mut_nodesToFix.push({
+            node,
+            objExpression: objArg,
+            keyExpression: keyArg,
+          });
+        },
+
+        // Handle key in obj
+        BinaryExpression: (node) => {
+          if (node.operator !== 'in') return;
+
+          const keyExpression = node.left;
+
+          const objExpression = node.right;
+
+          // Type guard: ensure keyExpression is Expression (not PrivateIdentifier)
+          if (keyExpression.type === AST_NODE_TYPES.PrivateIdentifier) return;
+
+          mut_nodesToFix.push({
+            node,
+            objExpression,
+            keyExpression,
+          });
+        },
+
+        'Program:exit': () => {
+          const namedImports = getNamedImports(tsDataForgeImport);
+
+          const hasIsRecordImport = namedImports.includes('isRecord');
+
+          const hasHasKeyImport = namedImports.includes('hasKey');
+
+          for (const [
+            index,
+            { node, objExpression, keyExpression },
+          ] of mut_nodesToFix.entries()) {
+            const objText = sourceCode.getText(objExpression);
+
+            const keyText = sourceCode.getText(keyExpression);
+
+            const originalText = sourceCode.getText(node);
+
+            context.report({
+              node,
+              messageId: 'useIsRecordAndHasKey',
+              data: {
+                original: originalText,
+                objName: objText,
+                keyName: keyText,
+              },
+              fix: (fixer) => {
+                const replacement = `isRecord(${objText}) && hasKey(${objText}, ${keyText})`;
+
+                const importsToAdd: string[] = [];
+
+                if (!hasIsRecordImport) {
+                  // eslint-disable-next-line functional/immutable-data
+                  importsToAdd.push('isRecord');
+                }
+
+                if (!hasHasKeyImport) {
+                  // eslint-disable-next-line functional/immutable-data
+                  importsToAdd.push('hasKey');
+                }
+
+                const importFixes =
+                  index === 0 && importsToAdd.length > 0
+                    ? buildImportFixes(
+                        fixer,
+                        program,
+                        tsDataForgeImport,
+                        importsToAdd,
+                      )
+                    : [];
+
+                return [...importFixes, fixer.replaceText(node, replacement)];
+              },
+            });
+          }
+        },
+      };
+    },
+    defaultOptions: [],
+  };

package/src/plugins/ts-data-forge/rules/prefer-is-record-and-has-key.test.mts

@@ -0,0 +1,191 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferIsRecordAndHasKey } from './prefer-is-record-and-has-key.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-is-record-and-has-key', () => {
+  tester.run('prefer-is-record-and-has-key', preferIsRecordAndHasKey, {
+    valid: [
+      {
+        name: 'ignores other Object methods',
+        code: dedent`
+          const obj = { a: 1 };
+          const keys = Object.keys(obj);
+        `,
+      },
+      {
+        name: 'ignores hasOwn with wrong number of arguments',
+        code: dedent`
+          const obj = { a: 1 };
+          const ok = Object.hasOwn(obj);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces Object.hasOwn(obj, key) with isRecord && hasKey',
+        code: dedent`
+          const obj = { a: 1 };
+          const ok = Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const ok = isRecord(obj) && hasKey(obj, 'a');
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'replaces key in obj with isRecord && hasKey',
+        code: dedent`
+          const obj = { a: 1 };
+          const ok = 'a' in obj;
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const ok = isRecord(obj) && hasKey(obj, 'a');
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'works with variable key',
+        code: dedent`
+          const obj = { a: 1 };
+          const key = 'a';
+          const ok = Object.hasOwn(obj, key);
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const key = 'a';
+          const ok = isRecord(obj) && hasKey(obj, key);
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'works with in and variable key',
+        code: dedent`
+          const obj = { a: 1 };
+          const key = 'a';
+          const ok = key in obj;
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const key = 'a';
+          const ok = isRecord(obj) && hasKey(obj, key);
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps existing isRecord import',
+        code: dedent`
+          import { isRecord } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-data-forge';
+          import { isRecord } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = isRecord(obj) && hasKey(obj, 'a');
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps existing hasKey import',
+        code: dedent`
+          import { hasKey } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = 'a' in obj;
+        `,
+        output: dedent`
+          import { isRecord } from 'ts-data-forge';
+          import { hasKey } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = isRecord(obj) && hasKey(obj, 'a');
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps both existing imports',
+        code: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+
+          const obj = { a: 1 };
+          const ok = isRecord(obj) && hasKey(obj, 'a');
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'replaces multiple checks',
+        code: dedent`
+          const obj = { a: 1 };
+          const ok1 = Object.hasOwn(obj, 'a');
+          const ok2 = 'b' in obj;
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const obj = { a: 1 };
+          const ok1 = isRecord(obj) && hasKey(obj, 'a');
+          const ok2 = isRecord(obj) && hasKey(obj, 'b');
+        `,
+        errors: [
+          { messageId: 'useIsRecordAndHasKey' },
+          { messageId: 'useIsRecordAndHasKey' },
+        ],
+      },
+      {
+        name: 'works with complex object expressions',
+        code: dedent`
+          const data = { nested: { value: 1 } };
+          const ok = Object.hasOwn(data.nested, 'value');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const data = { nested: { value: 1 } };
+          const ok = isRecord(data.nested) && hasKey(data.nested, 'value');
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'works with in and complex object expressions',
+        code: dedent`
+          const data = { nested: { value: 1 } };
+          const ok = 'value' in data.nested;
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          const data = { nested: { value: 1 } };
+          const ok = isRecord(data.nested) && hasKey(data.nested, 'value');
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+    ],
+  });
+}, 20000);

package/src/plugins/ts-data-forge/rules/prefer-range-for-loop.mts

@@ -0,0 +1,181 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useRangeForLoop';
+
+export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `for (let i = begin; i < end; ++i)` with `for (const i of range(begin, end))` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useRangeForLoop:
+        'Replace with `for (const {{varName}} of range({{begin}}, {{end}}))` from ts-data-forge.',
+    },
+  },
+
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+
+    const program = sourceCode.ast;
+
+    const tsDataForgeImport = getTsDataForgeImport(program);
+
+    const mut_nodesToFix: {
+      node: TSESTree.ForStatement;
+      varName: string;
+      begin: string;
+      end: string;
+      step?: string;
+    }[] = [];
+
+    return {
+      ForStatement: (node) => {
+        // Check init: let i = begin
+        if (
+          node.init === null ||
+          node.init.type !== AST_NODE_TYPES.VariableDeclaration ||
+          node.init.kind !== 'let' ||
+          !Arr.isArrayOfLength(node.init.declarations, 1)
+        ) {
+          return;
+        }
+
+        const declaration = node.init.declarations[0];
+
+        if (
+          declaration.id.type !== AST_NODE_TYPES.Identifier ||
+          declaration.init === null
+        ) {
+          return;
+        }
+
+        const varName = declaration.id.name;
+
+        const beginExpr = declaration.init;
+
+        // Check test: i < end
+        if (
+          node.test === null ||
+          node.test.type !== AST_NODE_TYPES.BinaryExpression ||
+          node.test.operator !== '<' ||
+          node.test.left.type !== AST_NODE_TYPES.Identifier ||
+          node.test.left.name !== varName
+        ) {
+          return;
+        }
+
+        const endExpr = node.test.right;
+
+        // Check update: ++i, i++, i += 1, or i += step
+        if (node.update === null) return;
+
+        let mut_step: string | undefined;
+
+        if (node.update.type === AST_NODE_TYPES.UpdateExpression) {
+          // ++i or i++
+          if (
+            node.update.operator === '++' &&
+            node.update.argument.type === AST_NODE_TYPES.Identifier &&
+            node.update.argument.name === varName
+          ) {
+            mut_step = undefined; // step defaults to 1
+          } else {
+            return;
+          }
+        } else if (
+          node.update.type === AST_NODE_TYPES.AssignmentExpression &&
+          node.update.operator === '+=' &&
+          node.update.left.type === AST_NODE_TYPES.Identifier &&
+          node.update.left.name === varName
+        ) {
+          // i += step
+          const stepValue = node.update.right;
+
+          if (stepValue.type === AST_NODE_TYPES.Literal) {
+            const stepNum = stepValue.value;
+
+            // Only support positive integer steps
+            if (typeof stepNum === 'number' && stepNum > 0) {
+              mut_step = stepNum === 1 ? undefined : String(stepNum);
+            } else {
+              return;
+            }
+          } else {
+            // Variable step like i += step
+            mut_step = sourceCode.getText(stepValue);
+          }
+        } else {
+          return;
+        }
+
+        const beginText = sourceCode.getText(beginExpr);
+
+        const endText = sourceCode.getText(endExpr);
+
+        mut_nodesToFix.push({
+          node,
+          varName,
+          begin: beginText,
+          end: endText,
+          step: mut_step,
+        });
+      },
+      'Program:exit': () => {
+        const namedImports = getNamedImports(tsDataForgeImport);
+
+        const hasRangeImport = namedImports.includes('range');
+
+        for (const [
+          index,
+          { node, varName, begin, end, step },
+        ] of mut_nodesToFix.entries()) {
+          context.report({
+            node: node.init ?? node,
+            messageId: 'useRangeForLoop',
+            data: {
+              varName,
+              begin,
+              end,
+            },
+            fix: (fixer) => {
+              const bodyText = sourceCode.getText(node.body);
+
+              const rangeArgs =
+                step === undefined
+                  ? `${begin}, ${end}`
+                  : `${begin}, ${end}, ${step}`;
+
+              const replacement = `for (const ${varName} of range(${rangeArgs})) ${bodyText}`;
+
+              const importFixes =
+                index === 0 && !hasRangeImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, [
+                      'range',
+                    ])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+};

package/src/plugins/ts-data-forge/rules/prefer-range-for-loop.test.mts

@@ -0,0 +1,156 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferRangeForLoop } from './prefer-range-for-loop.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-range-for-loop', () => {
+  tester.run('prefer-range-for-loop', preferRangeForLoop, {
+    valid: [
+      {
+        name: 'ignores for loop with const',
+        code: dedent`
+          for (const i = 0; i < 10; ++i) {
+            console.log(i);
+          }
+        `,
+      },
+      {
+        name: 'ignores for loop with different condition',
+        code: dedent`
+          for (let i = 0; i <= 10; ++i) {
+            console.log(i);
+          }
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces for loop with ++i',
+        code: dedent`
+          for (let i = 0; i < 10; ++i) {
+            console.log(i);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          for (const i of range(0, 10)) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+      {
+        name: 'replaces for loop with i++',
+        code: dedent`
+          for (let i = 0; i < 10; i++) {
+            console.log(i);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          for (const i of range(0, 10)) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+      {
+        name: 'replaces for loop with i += 1',
+        code: dedent`
+          for (let i = 0; i < 10; i += 1) {
+            console.log(i);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          for (const i of range(0, 10)) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+      {
+        name: 'replaces for loop with variable bounds',
+        code: dedent`
+          const begin = 5;
+          const end = 15;
+          for (let j = begin; j < end; ++j) {
+            console.log(j);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          const begin = 5;
+          const end = 15;
+          for (const j of range(begin, end)) {
+            console.log(j);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+      // {
+      //   name: 'replaces for loop with different condition',
+      //   code: dedent`
+      //     for (let i = 0; i <= 10; ++i) {
+      //       console.log(i);
+      //     }
+      //   `,
+      //   output: dedent`
+      //     import { range } from 'ts-data-forge';
+      //     for (const i of range(0, 11)) {
+      //       console.log(i);
+      //     }
+      //   `,
+      //   errors: [{ messageId: 'useRangeForLoop' }],
+      // },
+      {
+        name: 'replaces for loop with i += 2',
+        code: dedent`
+          for (let i = 0; i < 10; i += 2) {
+            console.log(i);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          for (const i of range(0, 10, 2)) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+
+      {
+        name: 'keeps existing range import',
+        code: dedent`
+          import { range } from 'ts-data-forge';
+
+          for (let i = 0; i < 10; ++i) {
+            console.log(i);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+
+          for (const i of range(0, 10)) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+    ],
+  });
+}, 20000);

package/src/plugins/ts-data-forge/rules/rules.mts

@@ -0,0 +1,22 @@
+import { type ESLintPlugin } from '../../../types/index.mjs';
+import { preferArrIsArrayAtLeastLength } from './prefer-arr-is-array-at-least-length.mjs';
+import { preferArrIsArrayOfLength } from './prefer-arr-is-array-of-length.mjs';
+import { preferArrIsArray } from './prefer-arr-is-array.mjs';
+import { preferArrIsNonEmpty } from './prefer-arr-is-non-empty.mjs';
+import { preferArrSum } from './prefer-arr-sum.mjs';
+import { preferAsInt } from './prefer-as-int.mjs';
+import { preferIsNonNullObject } from './prefer-is-non-null-object.mjs';
+import { preferIsRecordAndHasKey } from './prefer-is-record-and-has-key.mjs';
+import { preferRangeForLoop } from './prefer-range-for-loop.mjs';
+
+export const tsDataForgeRules = {
+  'prefer-arr-is-array-at-least-length': preferArrIsArrayAtLeastLength,
+  'prefer-arr-is-array-of-length': preferArrIsArrayOfLength,
+  'prefer-arr-is-array': preferArrIsArray,
+  'prefer-arr-is-non-empty': preferArrIsNonEmpty,
+  'prefer-arr-sum': preferArrSum,
+  'prefer-as-int': preferAsInt,
+  'prefer-is-non-null-object': preferIsNonNullObject,
+  'prefer-range-for-loop': preferRangeForLoop,
+  'prefer-is-record-and-has-key': preferIsRecordAndHasKey,
+} as const satisfies ESLintPlugin['rules'];