eslint-config-typed 3.14.1 → 4.0.1

package/src/plugins/vitest-coding-style/rules/prefer-assert-is-false-over-assert-negation.mts

@@ -0,0 +1,53 @@
+import { AST_NODE_TYPES, type TSESLint } from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+
+type MessageIds = 'preferAssertIsFalseOverAssertNegation';
+
+type Options = readonly [];
+
+export const preferAssertIsFalseOverNegatedAssertIsTrueRule: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Prefer assert.isFalse(X) over assert.isTrue(!X).',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      preferAssertIsFalseOverAssertNegation:
+        'Use assert.isFalse(X) instead of assert.isTrue(!X).',
+    },
+  },
+  defaultOptions: [],
+  create: (context) => ({
+    CallExpression: (node) => {
+      if (
+        node.callee.type === AST_NODE_TYPES.MemberExpression &&
+        node.callee.object.type === AST_NODE_TYPES.Identifier &&
+        node.callee.object.name === 'assert' &&
+        node.callee.property.type === AST_NODE_TYPES.Identifier &&
+        node.callee.property.name === 'isTrue' &&
+        Arr.isArrayOfLength(node.arguments, 1)
+      ) {
+        const [arg] = node.arguments;
+
+        if (
+          arg.type === AST_NODE_TYPES.UnaryExpression &&
+          arg.operator === '!'
+        ) {
+          const targetText = context.sourceCode.getText(arg.argument);
+
+          context.report({
+            node: arg,
+            messageId: 'preferAssertIsFalseOverAssertNegation',
+            fix: (fixer) =>
+              fixer.replaceText(node, `assert.isFalse(${targetText})`),
+          });
+        }
+      }
+    },
+  }),
+};

package/src/plugins/vitest-coding-style/rules/{prefer-assert-not-ok-over-assert-is-not-ok.mts → prefer-assert-is-false-over-assert-not-ok.mts}

@@ -1,23 +1,24 @@
 import { AST_NODE_TYPES, type TSESLint } from '@typescript-eslint/utils';
 
-type MessageIds = 'preferAssertOverAssertNotOk';
+type MessageIds = 'preferAssertIsFalseOverAssertNotOk';
 
 type Options = readonly [];
 
-export const preferAssertNotOkOverAssertIsNotOkRule: TSESLint.RuleModule<
+export const preferAssertIsFalseOverAssertNotOkRule: TSESLint.RuleModule<
   MessageIds,
   Options
 > = {
   meta: {
     type: 'suggestion',
     docs: {
-      description: 'Prefer assert.notOk(X) over assert.isNotOk(X).',
+      description:
+        'Prefer assert.isFalse(X) over assert.isNotOk(X), assert.notOk(X).',
     },
     fixable: 'code',
     schema: [],
     messages: {
-      preferAssertOverAssertNotOk:
-        'Use assert.notOk(X) instead of assert.isNotOk(X).',
+      preferAssertIsFalseOverAssertNotOk:
+        'Use assert.isFalse(X) instead of assert.isNotOk(X), assert.notOk(X).',
     },
   },
   defaultOptions: [],
@@ -27,14 +28,14 @@ export const preferAssertNotOkOverAssertIsNotOkRule: TSESLint.RuleModule<
         node.object.type === AST_NODE_TYPES.Identifier &&
         node.object.name === 'assert' &&
         node.property.type === AST_NODE_TYPES.Identifier &&
-        node.property.name === 'isNotOk' &&
+        (node.property.name === 'isNotOk' || node.property.name === 'notOk') &&
         node.parent.type === AST_NODE_TYPES.CallExpression &&
         node.parent.callee === node
       ) {
         context.report({
           node,
-          messageId: 'preferAssertOverAssertNotOk',
-          fix: (fixer) => fixer.replaceText(node, 'assert.notOk'),
+          messageId: 'preferAssertIsFalseOverAssertNotOk',
+          fix: (fixer) => fixer.replaceText(node, 'assert.isFalse'),
         });
       }
     },

package/src/plugins/vitest-coding-style/rules/{prefer-assert-not-ok-over-expect-false.mts → prefer-assert-is-false-over-expect-false.mts}

@@ -6,11 +6,11 @@ import {
 import { Arr } from 'ts-data-forge';
 import * as ts from 'typescript';
 
-type MessageIds = 'preferAssertNotOkOverExpectFalse';
+type MessageIds = 'preferAssertIsFalseOverExpectFalse';
 
 type Options = readonly [];
 
-export const preferAssertNotOkOverExpectFalseRule: TSESLint.RuleModule<
+export const preferAssertIsFalseOverExpectFalseRule: TSESLint.RuleModule<
   MessageIds,
   Options
 > = {
@@ -18,13 +18,13 @@ export const preferAssertNotOkOverExpectFalseRule: TSESLint.RuleModule<
     type: 'suggestion',
     docs: {
       description:
-        'Prefer assert.notOk(X) over expect(X).toBe(false) (only if X is boolean)',
+        'Prefer assert.isFalse(X) over expect(X).toBe(false) (only if X is boolean)',
     },
     fixable: 'code',
     schema: [],
     messages: {
-      preferAssertNotOkOverExpectFalse:
-        'Use assert.notOk(X) instead of expect(X).toBe(false)',
+      preferAssertIsFalseOverExpectFalse:
+        'Use assert.isFalse(X) instead of expect(X).toBe(false)',
     },
   },
   defaultOptions: [],
@@ -64,8 +64,9 @@ export const preferAssertNotOkOverExpectFalseRule: TSESLint.RuleModule<
 
           context.report({
             node,
-            messageId: 'preferAssertNotOkOverExpectFalse',
-            fix: (fixer) => fixer.replaceText(node, `assert.notOk(${argText})`),
+            messageId: 'preferAssertIsFalseOverExpectFalse',
+            fix: (fixer) =>
+              fixer.replaceText(node, `assert.isFalse(${argText})`),
           });
         }
       },

package/src/plugins/vitest-coding-style/rules/prefer-assert-is-true-over-assert-negated-is-false.mts

@@ -0,0 +1,53 @@
+import { AST_NODE_TYPES, type TSESLint } from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+
+type MessageIds = 'preferAssertIsTrueOverNegatedAssertIsFalse';
+
+type Options = readonly [];
+
+export const preferAssertIsTrueOverNegatedAssertIsFalseRule: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Prefer assert.isTrue(X) over assert.isFalse(!X).',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      preferAssertIsTrueOverNegatedAssertIsFalse:
+        'Use assert.isTrue(X) instead of assert.isFalse(!X).',
+    },
+  },
+  defaultOptions: [],
+  create: (context) => ({
+    CallExpression: (node) => {
+      if (
+        node.callee.type === AST_NODE_TYPES.MemberExpression &&
+        node.callee.object.type === AST_NODE_TYPES.Identifier &&
+        node.callee.object.name === 'assert' &&
+        node.callee.property.type === AST_NODE_TYPES.Identifier &&
+        node.callee.property.name === 'isFalse' &&
+        Arr.isArrayOfLength(node.arguments, 1)
+      ) {
+        const [arg] = node.arguments;
+
+        if (
+          arg.type === AST_NODE_TYPES.UnaryExpression &&
+          arg.operator === '!'
+        ) {
+          const targetText = context.sourceCode.getText(arg.argument);
+
+          context.report({
+            node: arg,
+            messageId: 'preferAssertIsTrueOverNegatedAssertIsFalse',
+            fix: (fixer) =>
+              fixer.replaceText(node, `assert.isTrue(${targetText})`),
+          });
+        }
+      }
+    },
+  }),
+};

package/src/plugins/vitest-coding-style/rules/prefer-assert-is-true-over-assert.mts

@@ -0,0 +1,67 @@
+import { AST_NODE_TYPES, type TSESLint } from '@typescript-eslint/utils';
+
+type MessageIds = 'preferAssertIsTrueOverAssert';
+
+type Options = readonly [];
+
+export const preferAssertIsTrueOverAssertRule: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Prefer assert.isTrue(X) over assert(X), assert.isOk(X), assert.ok(X).',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      preferAssertIsTrueOverAssert:
+        'Use assert.isTrue(X) instead of {{method}}(X).',
+    },
+  },
+  defaultOptions: [],
+  create: (context) => ({
+    CallExpression: (node) => {
+      // assert(X) -> assert.isTrue(X)
+      if (
+        node.callee.type === AST_NODE_TYPES.Identifier &&
+        node.callee.name === 'assert'
+      ) {
+        if (node.arguments.length === 0) {
+          return;
+        }
+
+        context.report({
+          node: node.callee,
+          messageId: 'preferAssertIsTrueOverAssert',
+          data: { method: 'assert' },
+          fix: (fixer) => fixer.replaceText(node.callee, 'assert.isTrue'),
+        });
+
+        return;
+      }
+
+      // assert.isOk(X) -> assert.isTrue(X)
+
+      if (node.callee.type === AST_NODE_TYPES.MemberExpression) {
+        const callee = node.callee;
+
+        if (
+          callee.object.type === AST_NODE_TYPES.Identifier &&
+          callee.object.name === 'assert' &&
+          callee.property.type === AST_NODE_TYPES.Identifier &&
+          (callee.property.name === 'isOk' || callee.property.name === 'ok')
+        ) {
+          context.report({
+            node: callee,
+            messageId: 'preferAssertIsTrueOverAssert',
+            data: { method: `assert.${callee.property.name}` },
+            fix: (fixer) => fixer.replaceText(callee, 'assert.isTrue'),
+          });
+        }
+      }
+    },
+  }),
+};

package/src/plugins/vitest-coding-style/rules/{prefer-assert-over-expect-true.mts → prefer-assert-is-true-over-expect-true.mts}

@@ -6,11 +6,11 @@ import {
 import { Arr } from 'ts-data-forge';
 import * as ts from 'typescript';
 
-type MessageIds = 'preferAssertOverExpectTrue';
+type MessageIds = 'preferAssertIsTrueOverExpectTrue';
 
 type Options = readonly [];
 
-export const preferAssertOverExpectTrueRule: TSESLint.RuleModule<
+export const preferAssertIsTrueOverExpectTrueRule: TSESLint.RuleModule<
   MessageIds,
   Options
 > = {
@@ -18,13 +18,13 @@ export const preferAssertOverExpectTrueRule: TSESLint.RuleModule<
     type: 'suggestion',
     docs: {
       description:
-        'Prefer assert(X) over expect(X).toBe(true) (only if X is boolean)',
+        'Prefer assert.isTrue(X) over expect(X).toBe(true) (only if X is boolean)',
     },
     fixable: 'code',
     schema: [],
     messages: {
-      preferAssertOverExpectTrue:
-        'Use assert(X) instead of expect(X).toBe(true)',
+      preferAssertIsTrueOverExpectTrue:
+        'Use assert.isTrue(X) instead of expect(X).toBe(true)',
     },
   },
   defaultOptions: [],
@@ -64,8 +64,9 @@ export const preferAssertOverExpectTrueRule: TSESLint.RuleModule<
 
           context.report({
             node,
-            messageId: 'preferAssertOverExpectTrue',
-            fix: (fixer) => fixer.replaceText(node, `assert(${argText})`),
+            messageId: 'preferAssertIsTrueOverExpectTrue',
+            fix: (fixer) =>
+              fixer.replaceText(node, `assert.isTrue(${argText})`),
           });
         }
       },

package/src/plugins/vitest-coding-style/rules/rules.mts

@@ -1,18 +1,30 @@
 import { type ESLintPlugin } from '../../../types/index.mjs';
 import { noExpectToStrictEqualRule } from './no-expect-to-strict-equal.mjs';
-import { preferAssertNotOkOverAssertIsNotOkRule } from './prefer-assert-not-ok-over-assert-is-not-ok.mjs';
-import { preferAssertNotOkOverExpectFalseRule } from './prefer-assert-not-ok-over-expect-false.mjs';
-import { preferAssertOverAssertOkRule } from './prefer-assert-over-assert-ok.mjs';
-import { preferAssertOverExpectTrueRule } from './prefer-assert-over-expect-true.mjs';
+import { preferAssertDeepStrictEqualOverDeepEqualRule } from './prefer-assert-deep-strict-equal-over-deep-equal.mjs';
+import { preferAssertIsFalseOverNegatedAssertIsTrueRule } from './prefer-assert-is-false-over-assert-negation.mjs';
+import { preferAssertIsFalseOverAssertNotOkRule } from './prefer-assert-is-false-over-assert-not-ok.mjs';
+import { preferAssertIsFalseOverExpectFalseRule } from './prefer-assert-is-false-over-expect-false.mjs';
+import { preferAssertIsTrueOverNegatedAssertIsFalseRule } from './prefer-assert-is-true-over-assert-negated-is-false.mjs';
+import { preferAssertIsTrueOverAssertRule } from './prefer-assert-is-true-over-assert.mjs';
+import { preferAssertIsTrueOverExpectTrueRule } from './prefer-assert-is-true-over-expect-true.mjs';
 
 export const vitestCodingStyleRules = {
   'no-expect-to-strict-equal': noExpectToStrictEqualRule,
 
-  'prefer-assert-over-assert-ok': preferAssertOverAssertOkRule,
-  'prefer-assert-not-ok-over-assert-is-not-ok':
-    preferAssertNotOkOverAssertIsNotOkRule,
+  'prefer-assert-deep-strict-equal-over-deep-equal':
+    preferAssertDeepStrictEqualOverDeepEqualRule,
 
-  'prefer-assert-over-expect-true': preferAssertOverExpectTrueRule,
-  'prefer-assert-not-ok-over-expect-false':
-    preferAssertNotOkOverExpectFalseRule,
+  'prefer-assert-is-true-over-assert': preferAssertIsTrueOverAssertRule,
+  'prefer-assert-is-false-over-assert-not-ok':
+    preferAssertIsFalseOverAssertNotOkRule,
+
+  'prefer-assert-is-true-over-expect-true':
+    preferAssertIsTrueOverExpectTrueRule,
+  'prefer-assert-is-false-over-expect-false':
+    preferAssertIsFalseOverExpectFalseRule,
+
+  'prefer-assert-is-false-over-negated-assert-is-true':
+    preferAssertIsFalseOverNegatedAssertIsTrueRule,
+  'prefer-assert-is-true-over-negated-assert-is-false':
+    preferAssertIsTrueOverNegatedAssertIsFalseRule,
 } as const satisfies ESLintPlugin['rules'];