eslint-config-typed 4.2.1 → 4.3.1

package/src/plugins/ts-data-forge/rules/prefer-as-int.test.mts

@@ -0,0 +1,267 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferAsInt } from './prefer-as-int.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-as-int', () => {
+  tester.run('prefer-as-int', preferAsInt, {
+    valid: [
+      {
+        name: 'ignores non-Int assertions',
+        code: dedent`
+          const n = 1;
+          const result = n as number;
+        `,
+      },
+    ],
+    invalid: [
+      ...([
+        {
+          name: 'replaces as Int with asInt import',
+          code: dedent`
+            const n = 1;
+            const result = n as Int;
+          `,
+          output: dedent`
+            import { asInt } from 'ts-data-forge';
+            const n = 1;
+            const result = asInt(n);
+          `,
+          errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+        },
+        {
+          name: 'replaces as Int with asInt import when other imports exist',
+          code: dedent`
+            import { noop } from './noop.mjs';
+
+            const n = 1;
+            noop(n as Int);
+          `,
+          output: dedent`
+            import { asInt } from 'ts-data-forge';
+            import { noop } from './noop.mjs';
+
+            const n = 1;
+            noop(asInt(n));
+          `,
+          errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+        },
+        {
+          name: 'replaces multiple as Int with asInt imports',
+          code: dedent`
+            const n = 1;
+            const result = n as Int;
+            const another = (n + 1) as Int;
+          `,
+          output: dedent`
+            import { asInt } from 'ts-data-forge';
+            const n = 1;
+            const result = asInt(n);
+            const another = asInt(n + 1);
+          `,
+          errors: [
+            { messageId: 'useBrandedNumberCastFunction' },
+            { messageId: 'useBrandedNumberCastFunction' },
+          ],
+        },
+        // {
+        //   name: 'replaces as Int with asInt import with another disabled line',
+        //   code: dedent`
+        //     const n = 1;
+
+        //     // eslint-disable-next-line
+        //     const result = n as Int;
+
+        //     const another = (n + 1) as Int;
+        //   `,
+        //   output: dedent`
+        //     import { asInt } from 'ts-data-forge';
+        //     const n = 1;
+
+        //     // eslint-disable-next-line
+        //     const result = n as Int;
+
+        //     const another = asInt(n + 1);
+        //   `,
+        //   errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+        // },
+      ] as const),
+
+      ...([
+        {
+          name: 'keeps existing asInt import',
+          code: dedent`
+            import { asInt } from 'ts-data-forge';
+
+            const n = 1;
+            const result = n as Int;
+          `,
+          output: dedent`
+            import { asInt } from 'ts-data-forge';
+
+            const n = 1;
+            const result = asInt(n);
+          `,
+          errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+        },
+        {
+          name: 'keeps existing asInt import when other imports exist',
+          code: dedent`
+            import { noop } from './noop.mjs';
+            import { asInt } from 'ts-data-forge';
+
+            const n = 1;
+            noop(n as Int);
+          `,
+          output: dedent`
+            import { noop } from './noop.mjs';
+            import { asInt } from 'ts-data-forge';
+
+            const n = 1;
+            noop(asInt(n));
+          `,
+          errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+        },
+      ] as const),
+
+      ...([
+        {
+          name: 'adds import even if ts-data-forge import exists',
+          code: dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+
+            const n = 1;
+            const result = n as Int;
+          `,
+          output: dedent`
+            import { asInt } from 'ts-data-forge';
+            import { isNonNullObject } from 'ts-data-forge';
+
+            const n = 1;
+            const result = asInt(n);
+          `,
+          errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+        },
+        {
+          name: 'adds import even if ts-data-forge import exists (with other imports)',
+          code: dedent`
+            import { noop } from './noop.mjs';
+            import { isNonNullObject } from 'ts-data-forge';
+
+            const n = 1;
+            const result = n as Int;
+          `,
+          output: dedent`
+            import { asInt } from 'ts-data-forge';
+            import { noop } from './noop.mjs';
+            import { isNonNullObject } from 'ts-data-forge';
+
+            const n = 1;
+            const result = asInt(n);
+          `,
+          errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+        },
+      ] as const),
+    ],
+  });
+
+  // Test cases for other branded number types
+  tester.run('prefer-as-int (other types)', preferAsInt, {
+    valid: [],
+    invalid: [
+      {
+        name: 'replaces as Uint32 with asUint32',
+        code: dedent`
+          const n = 1;
+          const result = n as Uint32;
+        `,
+        output: dedent`
+          import { asUint32 } from 'ts-data-forge';
+          const n = 1;
+          const result = asUint32(n);
+        `,
+        errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+      },
+      {
+        name: 'replaces as SafeInt with asSafeInt',
+        code: dedent`
+          const n = 1;
+          const result = n as SafeInt;
+        `,
+        output: dedent`
+          import { asSafeInt } from 'ts-data-forge';
+          const n = 1;
+          const result = asSafeInt(n);
+        `,
+        errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+      },
+      {
+        name: 'replaces as PositiveInt with asPositiveInt',
+        code: dedent`
+          const n = 1;
+          const result = n as PositiveInt;
+        `,
+        output: dedent`
+          import { asPositiveInt } from 'ts-data-forge';
+          const n = 1;
+          const result = asPositiveInt(n);
+        `,
+        errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+      },
+      {
+        name: 'replaces multiple different branded types',
+        code: dedent`
+          const n = 1;
+          const a = n as Int;
+          const b = n as Uint32;
+          const c = n as SafeInt;
+        `,
+        output: [
+          dedent`
+            import { asInt } from 'ts-data-forge';
+            const n = 1;
+            const a = asInt(n);
+            const b = n as Uint32;
+            const c = n as SafeInt;
+          `,
+          dedent`
+            import { asUint32 } from 'ts-data-forge';
+            import { asInt } from 'ts-data-forge';
+            const n = 1;
+            const a = asInt(n);
+            const b = asUint32(n);
+            const c = n as SafeInt;
+          `,
+          dedent`
+            import { asSafeInt } from 'ts-data-forge';
+            import { asUint32 } from 'ts-data-forge';
+            import { asInt } from 'ts-data-forge';
+            const n = 1;
+            const a = asInt(n);
+            const b = asUint32(n);
+            const c = asSafeInt(n);
+          `,
+        ],
+        errors: [
+          { messageId: 'useBrandedNumberCastFunction' },
+          { messageId: 'useBrandedNumberCastFunction' },
+          { messageId: 'useBrandedNumberCastFunction' },
+        ],
+      },
+    ],
+  });
+}, 20000);

package/src/plugins/ts-data-forge/rules/prefer-is-non-null-object.mts

@@ -0,0 +1,144 @@
+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 = 'useIsNonNullObject';
+
+export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `typeof u === "object" && u !== null` with `isNonNullObject(u)` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useIsNonNullObject:
+        'Replace the object/null check with `isNonNullObject()` from ts-data-forge.',
+    },
+  },
+
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+
+    const program = sourceCode.ast;
+
+    const tsDataForgeImport = getTsDataForgeImport(program);
+
+    const mut_nodesToFix: {
+      node: TSESTree.LogicalExpression;
+      identifierName: string;
+    }[] = [];
+
+    return {
+      LogicalExpression: (node) => {
+        const identifierName = getNonNullObjectIdentifierName(node);
+
+        if (identifierName === undefined) return;
+
+        mut_nodesToFix.push({ node, identifierName });
+      },
+      'Program:exit': () => {
+        // Check if isNonNullObject is already imported
+        const hasIsNonNullObjectImport =
+          getNamedImports(tsDataForgeImport).includes('isNonNullObject');
+
+        // 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, identifierName },
+        ] of mut_nodesToFix.entries()) {
+          context.report({
+            node,
+            messageId: 'useIsNonNullObject',
+            fix: (fixer) => {
+              const replacement = `isNonNullObject(${identifierName})`;
+
+              // Add import only for the first node and only if not already imported
+              const importFixes =
+                index === 0 && !hasIsNonNullObjectImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, [
+                      'isNonNullObject',
+                    ])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+};
+
+const getNonNullObjectIdentifierName = (
+  node: DeepReadonly<TSESTree.LogicalExpression>,
+): string | undefined => {
+  if (node.operator !== '&&') return undefined;
+
+  const leftIdentifierName = getTypeofObjectIdentifierName(node.left);
+
+  const rightIdentifierName = getNonNullCheckIdentifierName(node.right);
+
+  if (leftIdentifierName === undefined) return undefined;
+
+  if (rightIdentifierName === undefined) return undefined;
+
+  if (leftIdentifierName !== rightIdentifierName) return undefined;
+
+  return leftIdentifierName;
+};
+
+const getTypeofObjectIdentifierName = (
+  node: DeepReadonly<TSESTree.Expression>,
+): string | undefined => {
+  if (node.type !== AST_NODE_TYPES.BinaryExpression) return undefined;
+
+  if (node.operator !== '===') return undefined;
+
+  const { left, right } = node;
+
+  if (left.type !== AST_NODE_TYPES.UnaryExpression) return undefined;
+
+  if (left.operator !== 'typeof') return undefined;
+
+  if (right.type !== AST_NODE_TYPES.Literal) return undefined;
+
+  if (right.value !== 'object') return undefined;
+
+  if (left.argument.type !== AST_NODE_TYPES.Identifier) return undefined;
+
+  return left.argument.name;
+};
+
+const getNonNullCheckIdentifierName = (
+  node: DeepReadonly<TSESTree.Expression>,
+): string | undefined => {
+  if (node.type !== AST_NODE_TYPES.BinaryExpression) return undefined;
+
+  if (node.operator !== '!==') return undefined;
+
+  const { left, right } = node;
+
+  if (left.type !== AST_NODE_TYPES.Identifier) return undefined;
+
+  if (right.type !== AST_NODE_TYPES.Literal) return undefined;
+
+  if (right.value !== null) return undefined;
+
+  return left.name;
+};

package/src/plugins/ts-data-forge/rules/prefer-is-non-null-object.test.mts

@@ -0,0 +1,156 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferIsNonNullObject } from './prefer-is-non-null-object.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-is-non-null-object', () => {
+  tester.run('prefer-is-non-null-object', preferIsNonNullObject, {
+    valid: [
+      {
+        name: 'ignores non-matching typeof checks',
+        code: dedent`
+          const u = {};
+          const ok = typeof u === "object" && v !== null;
+        `,
+      },
+    ],
+    invalid: [
+      ...([
+        {
+          name: 'replaces typeof object check with isNonNullObject import',
+          code: dedent`
+            const u = {};
+            const ok = typeof u === "object" && u !== null;
+          `,
+          output: dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+            const u = {};
+            const ok = isNonNullObject(u);
+          `,
+          errors: [{ messageId: 'useIsNonNullObject' }],
+        },
+        {
+          name: 'replaces typeof object check with isNonNullObject import when other imports exist',
+          code: dedent`
+            import { noop } from './noop.mjs';
+
+            const u = {};
+            noop(typeof u === "object" && u !== null);
+          `,
+          output: dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+            import { noop } from './noop.mjs';
+
+            const u = {};
+            noop(isNonNullObject(u));
+          `,
+          errors: [{ messageId: 'useIsNonNullObject' }],
+        },
+        {
+          name: 'replaces multiple typeof object checks with isNonNullObject imports',
+          code: dedent`
+            const u = {};
+            const ok = typeof u === "object" && u !== null;
+            const ok2 = typeof u === "object" && u !== null;
+          `,
+          output: dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+            const u = {};
+            const ok = isNonNullObject(u);
+            const ok2 = isNonNullObject(u);
+          `,
+          errors: [
+            { messageId: 'useIsNonNullObject' },
+            { messageId: 'useIsNonNullObject' },
+          ],
+        },
+      ] as const),
+
+      ...([
+        {
+          name: 'keeps existing isNonNullObject import',
+          code: dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+
+            const ok = typeof u === "object" && u !== null;
+          `,
+          output: dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+
+            const ok = isNonNullObject(u);
+          `,
+          errors: [{ messageId: 'useIsNonNullObject' }],
+        },
+        {
+          name: 'keeps existing isNonNullObject import when other imports exist',
+          code: dedent`
+            import { noop } from './noop.mjs';
+            import { isNonNullObject } from 'ts-data-forge';
+
+            const u = {};
+            noop(typeof u === "object" && u !== null);
+          `,
+          output: dedent`
+            import { noop } from './noop.mjs';
+            import { isNonNullObject } from 'ts-data-forge';
+
+            const u = {};
+            noop(isNonNullObject(u));
+          `,
+          errors: [{ messageId: 'useIsNonNullObject' }],
+        },
+      ] as const),
+
+      ...([
+        {
+          name: 'adds import even if ts-data-forge import exists',
+          code: dedent`
+            import { asInt } from 'ts-data-forge';
+
+            const ok = typeof u === "object" && u !== null;
+          `,
+          output: dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+            import { asInt } from 'ts-data-forge';
+
+            const ok = isNonNullObject(u);
+          `,
+          errors: [{ messageId: 'useIsNonNullObject' }],
+        },
+        {
+          name: 'adds import even if ts-data-forge import exists (with other imports)',
+          code: dedent`
+            import { noop } from './noop.mjs';
+            import { asInt } from 'ts-data-forge';
+
+            const u = {};
+            noop(typeof u === "object" && u !== null);
+          `,
+          output: dedent`
+            import { isNonNullObject } from 'ts-data-forge';
+            import { noop } from './noop.mjs';
+            import { asInt } from 'ts-data-forge';
+
+            const u = {};
+            noop(isNonNullObject(u));
+          `,
+          errors: [{ messageId: 'useIsNonNullObject' }],
+        },
+      ] as const),
+    ],
+  });
+}, 20000);