eslint-config-typed 3.13.6 → 3.14.0

package/dist/plugins/vitest-coding-style/rules/no-expect-to-strict-equal.mjs

@@ -5,12 +5,12 @@ const noExpectToStrictEqualRule = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Disallow `expect().toStrictEqual()` in favor of `assert.deepStrictEqual()`.',
+            description: 'Disallow `expect(X).toStrictEqual(Y)` in favor of `assert.deepStrictEqual(X, Y)`, as the former also checks type equality between X and Y.',
         },
         fixable: 'code',
         schema: [],
         messages: {
-            useAssert: 'Use `assert.deepStrictEqual()` instead of `expect().toStrictEqual()`.',
+            useAssert: 'Use `assert.deepStrictEqual(X, Y)` instead of `expect(X).toStrictEqual(Y)`.',
         },
     },
     defaultOptions: [],

package/dist/plugins/vitest-coding-style/rules/no-expect-to-strict-equal.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"no-expect-to-strict-equal.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/no-expect-to-strict-equal.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"no-expect-to-strict-equal.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/no-expect-to-strict-equal.mts"],"sourcesContent":[null],"names":[],"mappings":"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"}

package/dist/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-assert-is-not-ok.d.mts

@@ -0,0 +1,6 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'preferAssertOverAssertNotOk';
+type Options = readonly [];
+export declare const preferAssertNotOkOverAssertIsNotOkRule: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-assert-not-ok-over-assert-is-not-ok.d.mts.map

package/dist/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-assert-is-not-ok.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-not-ok-over-assert-is-not-ok.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-assert-is-not-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzE,KAAK,UAAU,GAAG,6BAA6B,CAAC;AAEhD,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,UAAU,CACtE,UAAU,EACV,OAAO,CAiCR,CAAC"}

package/dist/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-assert-is-not-ok.mjs

@@ -0,0 +1,35 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+const preferAssertNotOkOverAssertIsNotOkRule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer assert.notOk(X) over assert.isNotOk(X).',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferAssertOverAssertNotOk: 'Use assert.notOk(X) instead of assert.isNotOk(X).',
+        },
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        MemberExpression: (node) => {
+            if (node.object.type === AST_NODE_TYPES.Identifier &&
+                node.object.name === 'assert' &&
+                node.property.type === AST_NODE_TYPES.Identifier &&
+                node.property.name === 'isNotOk' &&
+                node.parent.type === AST_NODE_TYPES.CallExpression &&
+                node.parent.callee === node) {
+                context.report({
+                    node,
+                    messageId: 'preferAssertOverAssertNotOk',
+                    fix: (fixer) => fixer.replaceText(node, 'assert.notOk'),
+                });
+            }
+        },
+    }),
+};
+
+export { preferAssertNotOkOverAssertIsNotOkRule };
+//# sourceMappingURL=prefer-assert-not-ok-over-assert-is-not-ok.mjs.map

package/dist/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-assert-is-not-ok.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-not-ok-over-assert-is-not-ok.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-assert-is-not-ok.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAMO,MAAM,sCAAsC,GAG/C;AACF,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,YAAY;AAClB,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EAAE,gDAAgD;AAC9D,SAAA;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,2BAA2B,EACzB,mDAAmD;AACtD,SAAA;AACF,KAAA;AACD,IAAA,cAAc,EAAE,EAAE;AAClB,IAAA,MAAM,EAAE,CAAC,OAAO,MAAM;AACpB,QAAA,gBAAgB,EAAE,CAAC,IAAI,KAAI;YACzB,IACE,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AAC9C,gBAAA,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ;AAC7B,gBAAA,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AAChD,gBAAA,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS;AAChC,gBAAA,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,cAAc;AAClD,gBAAA,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,IAAI,EAC3B;gBACA,OAAO,CAAC,MAAM,CAAC;oBACb,IAAI;AACJ,oBAAA,SAAS,EAAE,6BAA6B;AACxC,oBAAA,GAAG,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,cAAc,CAAC;AACxD,iBAAA,CAAC;YACJ;QACF,CAAC;KACF,CAAC;;;;;"}

package/dist/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-expect-false.d.mts

@@ -0,0 +1,6 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'preferAssertNotOkOverExpectFalse';
+type Options = readonly [];
+export declare const preferAssertNotOkOverExpectFalseRule: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-assert-not-ok-over-expect-false.d.mts.map

package/dist/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-expect-false.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-not-ok-over-expect-false.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-expect-false.mts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAIlC,KAAK,UAAU,GAAG,kCAAkC,CAAC;AAErD,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,UAAU,CACpE,UAAU,EACV,OAAO,CA2DR,CAAC"}

package/dist/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-expect-false.mjs

@@ -0,0 +1,54 @@
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import * as ts from 'typescript';
+
+const preferAssertNotOkOverExpectFalseRule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer assert.notOk(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)',
+        },
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        return {
+            CallExpression: (node) => {
+                if (node.callee.type === AST_NODE_TYPES.MemberExpression &&
+                    node.callee.object.type === AST_NODE_TYPES.CallExpression &&
+                    node.callee.object.callee.type === AST_NODE_TYPES.Identifier &&
+                    node.callee.object.callee.name === 'expect' &&
+                    node.callee.property.type === AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === 'toBe' &&
+                    Arr.isArrayOfLength(node.arguments, 1) &&
+                    node.arguments[0].type === AST_NODE_TYPES.Literal &&
+                    node.arguments[0].value === false) {
+                    const arg = node.callee.object.arguments[0];
+                    if (arg !== undefined) {
+                        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(arg);
+                        const type = checker.getTypeAtLocation(tsNode);
+                        const isBoolean = (type.flags & ts.TypeFlags.Boolean) !== 0;
+                        if (!isBoolean) {
+                            return;
+                        }
+                    }
+                    const argText = context.sourceCode.getText(arg);
+                    context.report({
+                        node,
+                        messageId: 'preferAssertNotOkOverExpectFalse',
+                        fix: (fixer) => fixer.replaceText(node, `assert.notOk(${argText})`),
+                    });
+                }
+            },
+        };
+    },
+};
+
+export { preferAssertNotOkOverExpectFalseRule };
+//# sourceMappingURL=prefer-assert-not-ok-over-expect-false.mjs.map

package/dist/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-expect-false.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-not-ok-over-expect-false.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-not-ok-over-expect-false.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAYO,MAAM,oCAAoC,GAG7C;AACF,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,YAAY;AAClB,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EACT,0EAA0E;AAC7E,SAAA;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,gCAAgC,EAC9B,sDAAsD;AACzD,SAAA;AACF,KAAA;AACD,IAAA,cAAc,EAAE,EAAE;AAClB,IAAA,MAAM,EAAE,CAAC,OAAO,KAAI;QAClB,MAAM,cAAc,GAAG,WAAW,CAAC,iBAAiB,CAAC,OAAO,CAAC;QAE7D,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,cAAc,EAAE;QAEvD,OAAO;AACL,YAAA,cAAc,EAAE,CAAC,IAAI,KAAI;gBACvB,IACE,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,gBAAgB;oBACpD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,cAAc;oBACzD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;oBAC5D,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ;oBAC3C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AACvD,oBAAA,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,MAAM;oBACpC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;oBACtC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,cAAc,CAAC,OAAO;oBACjD,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,KAAK,EACjC;AACA,oBAAA,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;AAE3C,oBAAA,IAAI,GAAG,KAAK,SAAS,EAAE;wBACrB,MAAM,MAAM,GAAG,cAAc,CAAC,qBAAqB,CAAC,GAAG,CAAC,GAAG,CAAC;wBAE5D,MAAM,IAAI,GAAG,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC;AAE9C,wBAAA,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,OAAO,MAAM,CAAC;wBAE3D,IAAI,CAAC,SAAS,EAAE;4BACd;wBACF;oBACF;oBAEA,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC;oBAE/C,OAAO,CAAC,MAAM,CAAC;wBACb,IAAI;AACJ,wBAAA,SAAS,EAAE,kCAAkC;AAC7C,wBAAA,GAAG,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAA,aAAA,EAAgB,OAAO,GAAG,CAAC;AACpE,qBAAA,CAAC;gBACJ;YACF,CAAC;SACF;IACH,CAAC;;;;;"}

package/dist/plugins/vitest-coding-style/rules/prefer-assert-over-assert-ok.d.mts

@@ -0,0 +1,6 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'preferAssertOverAssertOk';
+type Options = readonly [];
+export declare const preferAssertOverAssertOkRule: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-assert-over-assert-ok.d.mts.map

package/dist/plugins/vitest-coding-style/rules/prefer-assert-over-assert-ok.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-over-assert-ok.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-over-assert-ok.mts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzE,KAAK,UAAU,GAAG,0BAA0B,CAAC;AAE7C,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,UAAU,CAC5D,UAAU,EACV,OAAO,CAiCR,CAAC"}

package/dist/plugins/vitest-coding-style/rules/prefer-assert-over-assert-ok.mjs

@@ -0,0 +1,35 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+const preferAssertOverAssertOkRule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer assert(X) over assert.ok(X), assert.isOk(X).',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferAssertOverAssertOk: 'Use assert(X) instead of assert.ok(X), assert.isOk(X).',
+        },
+    },
+    defaultOptions: [],
+    create: (context) => ({
+        MemberExpression: (node) => {
+            if (node.object.type === AST_NODE_TYPES.Identifier &&
+                node.object.name === 'assert' &&
+                node.property.type === AST_NODE_TYPES.Identifier &&
+                (node.property.name === 'ok' || node.property.name === 'isOk') &&
+                node.parent.type === AST_NODE_TYPES.CallExpression &&
+                node.parent.callee === node) {
+                context.report({
+                    node,
+                    messageId: 'preferAssertOverAssertOk',
+                    fix: (fixer) => fixer.replaceText(node, 'assert'),
+                });
+            }
+        },
+    }),
+};
+
+export { preferAssertOverAssertOkRule };
+//# sourceMappingURL=prefer-assert-over-assert-ok.mjs.map

package/dist/plugins/vitest-coding-style/rules/prefer-assert-over-assert-ok.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-over-assert-ok.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-over-assert-ok.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAMO,MAAM,4BAA4B,GAGrC;AACF,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,YAAY;AAClB,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EAAE,qDAAqD;AACnE,SAAA;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,wBAAwB,EACtB,wDAAwD;AAC3D,SAAA;AACF,KAAA;AACD,IAAA,cAAc,EAAE,EAAE;AAClB,IAAA,MAAM,EAAE,CAAC,OAAO,MAAM;AACpB,QAAA,gBAAgB,EAAE,CAAC,IAAI,KAAI;YACzB,IACE,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AAC9C,gBAAA,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ;AAC7B,gBAAA,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AAChD,iBAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,MAAM,CAAC;AAC9D,gBAAA,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,cAAc;AAClD,gBAAA,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,IAAI,EAC3B;gBACA,OAAO,CAAC,MAAM,CAAC;oBACb,IAAI;AACJ,oBAAA,SAAS,EAAE,0BAA0B;AACrC,oBAAA,GAAG,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,QAAQ,CAAC;AAClD,iBAAA,CAAC;YACJ;QACF,CAAC;KACF,CAAC;;;;;"}

package/dist/plugins/vitest-coding-style/rules/prefer-assert-over-expect-true.d.mts

@@ -0,0 +1,6 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'preferAssertOverExpectTrue';
+type Options = readonly [];
+export declare const preferAssertOverExpectTrueRule: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=prefer-assert-over-expect-true.d.mts.map

package/dist/plugins/vitest-coding-style/rules/prefer-assert-over-expect-true.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-over-expect-true.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-over-expect-true.mts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EACd,MAAM,0BAA0B,CAAC;AAIlC,KAAK,UAAU,GAAG,4BAA4B,CAAC;AAE/C,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,UAAU,CAC9D,UAAU,EACV,OAAO,CA2DR,CAAC"}

package/dist/plugins/vitest-coding-style/rules/prefer-assert-over-expect-true.mjs

@@ -0,0 +1,54 @@
+import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import * as ts from 'typescript';
+
+const preferAssertOverExpectTrueRule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer assert(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)',
+        },
+    },
+    defaultOptions: [],
+    create: (context) => {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        return {
+            CallExpression: (node) => {
+                if (node.callee.type === AST_NODE_TYPES.MemberExpression &&
+                    node.callee.object.type === AST_NODE_TYPES.CallExpression &&
+                    node.callee.object.callee.type === AST_NODE_TYPES.Identifier &&
+                    node.callee.object.callee.name === 'expect' &&
+                    node.callee.property.type === AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === 'toBe' &&
+                    Arr.isArrayOfLength(node.arguments, 1) &&
+                    node.arguments[0].type === AST_NODE_TYPES.Literal &&
+                    node.arguments[0].value === true) {
+                    const arg = node.callee.object.arguments[0];
+                    if (arg !== undefined) {
+                        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(arg);
+                        const type = checker.getTypeAtLocation(tsNode);
+                        const isBoolean = (type.flags & ts.TypeFlags.Boolean) !== 0;
+                        if (!isBoolean) {
+                            return;
+                        }
+                    }
+                    const argText = context.sourceCode.getText(arg);
+                    context.report({
+                        node,
+                        messageId: 'preferAssertOverExpectTrue',
+                        fix: (fixer) => fixer.replaceText(node, `assert(${argText})`),
+                    });
+                }
+            },
+        };
+    },
+};
+
+export { preferAssertOverExpectTrueRule };
+//# sourceMappingURL=prefer-assert-over-expect-true.mjs.map

package/dist/plugins/vitest-coding-style/rules/prefer-assert-over-expect-true.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-over-expect-true.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-over-expect-true.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAYO,MAAM,8BAA8B,GAGvC;AACF,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,YAAY;AAClB,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EACT,mEAAmE;AACtE,SAAA;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,0BAA0B,EACxB,+CAA+C;AAClD,SAAA;AACF,KAAA;AACD,IAAA,cAAc,EAAE,EAAE;AAClB,IAAA,MAAM,EAAE,CAAC,OAAO,KAAI;QAClB,MAAM,cAAc,GAAG,WAAW,CAAC,iBAAiB,CAAC,OAAO,CAAC;QAE7D,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,cAAc,EAAE;QAEvD,OAAO;AACL,YAAA,cAAc,EAAE,CAAC,IAAI,KAAI;gBACvB,IACE,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,gBAAgB;oBACpD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,cAAc;oBACzD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;oBAC5D,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ;oBAC3C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AACvD,oBAAA,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,MAAM;oBACpC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC;oBACtC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,cAAc,CAAC,OAAO;oBACjD,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,EAChC;AACA,oBAAA,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;AAE3C,oBAAA,IAAI,GAAG,KAAK,SAAS,EAAE;wBACrB,MAAM,MAAM,GAAG,cAAc,CAAC,qBAAqB,CAAC,GAAG,CAAC,GAAG,CAAC;wBAE5D,MAAM,IAAI,GAAG,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC;AAE9C,wBAAA,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,OAAO,MAAM,CAAC;wBAE3D,IAAI,CAAC,SAAS,EAAE;4BACd;wBACF;oBACF;oBAEA,MAAM,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC;oBAE/C,OAAO,CAAC,MAAM,CAAC;wBACb,IAAI;AACJ,wBAAA,SAAS,EAAE,4BAA4B;AACvC,wBAAA,GAAG,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAA,OAAA,EAAU,OAAO,GAAG,CAAC;AAC9D,qBAAA,CAAC;gBACJ;YACF,CAAC;SACF;IACH,CAAC;;;;;"}

package/dist/plugins/vitest-coding-style/rules/rules.d.mts

@@ -1,4 +1,8 @@
 export declare const vitestCodingStyleRules: {
     readonly 'no-expect-to-strict-equal': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useAssert", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-assert-over-assert-ok': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAssertOverAssertOk", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-assert-not-ok-over-assert-is-not-ok': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAssertOverAssertNotOk", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-assert-over-expect-true': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAssertOverExpectTrue", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-assert-not-ok-over-expect-false': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAssertNotOkOverExpectFalse", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
 };
 //# sourceMappingURL=rules.d.mts.map

package/dist/plugins/vitest-coding-style/rules/rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/rules.mts"],"names":[],"mappings":"AAGA,eAAO,MAAM,sBAAsB;;CAEO,CAAC"}
+{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/rules.mts"],"names":[],"mappings":"AAOA,eAAO,MAAM,sBAAsB;;;;;;CAUO,CAAC"}

package/dist/plugins/vitest-coding-style/rules/rules.mjs

@@ -1,7 +1,15 @@
 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';
 
 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-over-expect-true': preferAssertOverExpectTrueRule,
+    'prefer-assert-not-ok-over-expect-false': preferAssertNotOkOverExpectFalseRule,
 };
 
 export { vitestCodingStyleRules };

package/dist/plugins/vitest-coding-style/rules/rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rules.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAGO,MAAM,sBAAsB,GAAG;AACpC,IAAA,2BAA2B,EAAE,yBAAyB;;;;;"}
+{"version":3,"file":"rules.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAOO,MAAM,sBAAsB,GAAG;AACpC,IAAA,2BAA2B,EAAE,yBAAyB;AAEtD,IAAA,8BAA8B,EAAE,4BAA4B;AAC5D,IAAA,4CAA4C,EAC1C,sCAAsC;AAExC,IAAA,gCAAgC,EAAE,8BAA8B;AAChE,IAAA,wCAAwC,EACtC,oCAAoC;;;;;"}

package/dist/rules/eslint-vitest-coding-style-rules.d.mts

@@ -1,4 +1,8 @@
 export declare const eslintVitestCodingStyleRules: {
     readonly 'vitest-coding-style/no-expect-to-strict-equal': "error";
+    readonly 'vitest-coding-style/prefer-assert-over-assert-ok': "error";
+    readonly 'vitest-coding-style/prefer-assert-not-ok-over-assert-is-not-ok': "error";
+    readonly 'vitest-coding-style/prefer-assert-over-expect-true': "error";
+    readonly 'vitest-coding-style/prefer-assert-not-ok-over-expect-false': "error";
 };
 //# sourceMappingURL=eslint-vitest-coding-style-rules.d.mts.map

package/dist/rules/eslint-vitest-coding-style-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-vitest-coding-style-rules.d.mts","sourceRoot":"","sources":["../../src/rules/eslint-vitest-coding-style-rules.mts"],"names":[],"mappings":"AAEA,eAAO,MAAM,4BAA4B;;CAEQ,CAAC"}
+{"version":3,"file":"eslint-vitest-coding-style-rules.d.mts","sourceRoot":"","sources":["../../src/rules/eslint-vitest-coding-style-rules.mts"],"names":[],"mappings":"AAEA,eAAO,MAAM,4BAA4B;;;;;;CAMQ,CAAC"}

package/dist/rules/eslint-vitest-coding-style-rules.mjs

@@ -1,5 +1,9 @@
 const eslintVitestCodingStyleRules = {
     'vitest-coding-style/no-expect-to-strict-equal': 'error',
+    'vitest-coding-style/prefer-assert-over-assert-ok': 'error',
+    'vitest-coding-style/prefer-assert-not-ok-over-assert-is-not-ok': 'error',
+    'vitest-coding-style/prefer-assert-over-expect-true': 'error',
+    'vitest-coding-style/prefer-assert-not-ok-over-expect-false': 'error',
 };
 
 export { eslintVitestCodingStyleRules };

package/dist/rules/eslint-vitest-coding-style-rules.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-vitest-coding-style-rules.mjs","sources":["../../src/rules/eslint-vitest-coding-style-rules.mts"],"sourcesContent":[null],"names":[],"mappings":"AAEO,MAAM,4BAA4B,GAAG;AAC1C,IAAA,+CAA+C,EAAE,OAAO;;;;;"}
+{"version":3,"file":"eslint-vitest-coding-style-rules.mjs","sources":["../../src/rules/eslint-vitest-coding-style-rules.mts"],"sourcesContent":[null],"names":[],"mappings":"AAEO,MAAM,4BAA4B,GAAG;AAC1C,IAAA,+CAA+C,EAAE,OAAO;AACxD,IAAA,kDAAkD,EAAE,OAAO;AAC3D,IAAA,gEAAgE,EAAE,OAAO;AACzE,IAAA,oDAAoD,EAAE,OAAO;AAC7D,IAAA,4DAA4D,EAAE,OAAO;;;;;"}

package/dist/types/rules/eslint-vitest-coding-style-rules.d.mts

@@ -1,6 +1,7 @@
 import { type Linter } from 'eslint';
 /**
- * Disallow `expect().toStrictEqual()` in favor of `assert.deepStrictEqual()`.
+ * Disallow `expect(X).toStrictEqual(Y)` in favor of `assert.deepStrictEqual(X,
+ * Y)`, as the former also checks type equality between X and Y.
  *
  * ```md
  * | key        | value      |
@@ -13,8 +14,68 @@ import { type Linter } from 'eslint';
 declare namespace NoExpectToStrictEqual {
     type RuleEntry = Linter.StringSeverity;
 }
+/**
+ * Prefer assert(X) over assert.ok(X), assert.isOk(X).
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+declare namespace PreferAssertOverAssertOk {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * Prefer assert.notOk(X) over assert.isNotOk(X).
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+declare namespace PreferAssertNotOkOverAssertIsNotOk {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * Prefer assert(X) over expect(X).toBe(true) (only if X is boolean)
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+declare namespace PreferAssertOverExpectTrue {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * Prefer assert.notOk(X) over expect(X).toBe(false) (only if X is boolean)
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+declare namespace PreferAssertNotOkOverExpectFalse {
+    type RuleEntry = Linter.StringSeverity;
+}
 export type EslintVitestCodingStyleRules = Readonly<{
     'vitest-coding-style/no-expect-to-strict-equal': NoExpectToStrictEqual.RuleEntry;
+    'vitest-coding-style/prefer-assert-over-assert-ok': PreferAssertOverAssertOk.RuleEntry;
+    'vitest-coding-style/prefer-assert-not-ok-over-assert-is-not-ok': PreferAssertNotOkOverAssertIsNotOk.RuleEntry;
+    'vitest-coding-style/prefer-assert-over-expect-true': PreferAssertOverExpectTrue.RuleEntry;
+    'vitest-coding-style/prefer-assert-not-ok-over-expect-false': PreferAssertNotOkOverExpectFalse.RuleEntry;
 }>;
 export {};
 //# sourceMappingURL=eslint-vitest-coding-style-rules.d.mts.map

package/dist/types/rules/eslint-vitest-coding-style-rules.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"eslint-vitest-coding-style-rules.d.mts","sourceRoot":"","sources":["../../../src/types/rules/eslint-vitest-coding-style-rules.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;;;;;;;;;GAUG;AACH,kBAAU,qBAAqB,CAAC;IAC9B,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,+CAA+C,EAAE,qBAAqB,CAAC,SAAS,CAAC;CAClF,CAAC,CAAC"}
+{"version":3,"file":"eslint-vitest-coding-style-rules.d.mts","sourceRoot":"","sources":["../../../src/types/rules/eslint-vitest-coding-style-rules.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC;;;;;;;;;;;GAWG;AACH,kBAAU,qBAAqB,CAAC;IAC9B,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,wBAAwB,CAAC;IACjC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,kCAAkC,CAAC;IAC3C,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,0BAA0B,CAAC;IACnC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,gCAAgC,CAAC;IACzC,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED,MAAM,MAAM,4BAA4B,GAAG,QAAQ,CAAC;IAClD,+CAA+C,EAAE,qBAAqB,CAAC,SAAS,CAAC;IACjF,kDAAkD,EAAE,wBAAwB,CAAC,SAAS,CAAC;IACvF,gEAAgE,EAAE,kCAAkC,CAAC,SAAS,CAAC;IAC/G,oDAAoD,EAAE,0BAA0B,CAAC,SAAS,CAAC;IAC3F,4DAA4D,EAAE,gCAAgC,CAAC,SAAS,CAAC;CAC1G,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-typed",
-  "version": "3.13.6",
+  "version": "3.14.0",
   "private": false,
   "keywords": [
     "typescript"
@@ -83,7 +83,7 @@
     "eslint-plugin-import-x": "^4.16.1",
     "eslint-plugin-jest": "29.1.0",
     "eslint-plugin-jsx-a11y": "6.10.2",
-    "eslint-plugin-math": "^0.13.0",
+    "eslint-plugin-math": "^0.13.1",
     "eslint-plugin-n": "^17.23.1",
     "eslint-plugin-playwright": "2.3.0",
     "eslint-plugin-prefer-arrow-functions": "3.9.1",
@@ -121,7 +121,7 @@
     "@types/json-schema": "^7.0.15",
     "@types/micromatch": "^4.0.10",
     "@types/node": "^24.10.1",
-    "@types/react": "^19.2.6",
+    "@types/react": "^19.2.7",
     "@typescript-eslint/rule-tester": "8.47.0",
     "@vitest/coverage-v8": "^4.0.10",
     "@vitest/ui": "^4.0.10",
@@ -141,11 +141,11 @@
     "prettier-plugin-organize-imports": "^4.3.0",
     "prettier-plugin-packagejson": "^2.5.19",
     "react": "^19.2.0",
-    "rollup": "^4.53.2",
+    "rollup": "^4.53.3",
     "semantic-release": "^25.0.2",
     "ts-fortress": "^6.1.0",
     "ts-morph": "^27.0.2",
-    "ts-repo-utils": "^7.8.2",
+    "ts-repo-utils": "^7.9.2",
     "ts-type-forge": "^2.3.0",
     "tslib": "^2.8.1",
     "tsx": "^4.20.6",

package/src/plugins/vitest-coding-style/rules/no-expect-to-strict-equal.mts

@@ -17,13 +17,13 @@ export const noExpectToStrictEqualRule: TSESLint.RuleModule<MessageIds> = {
     type: 'suggestion',
     docs: {
       description:
-        'Disallow `expect().toStrictEqual()` in favor of `assert.deepStrictEqual()`.',
+        'Disallow `expect(X).toStrictEqual(Y)` in favor of `assert.deepStrictEqual(X, Y)`, as the former also checks type equality between X and Y.',
     },
     fixable: 'code',
     schema: [],
     messages: {
       useAssert:
-        'Use `assert.deepStrictEqual()` instead of `expect().toStrictEqual()`.',
+        'Use `assert.deepStrictEqual(X, Y)` instead of `expect(X).toStrictEqual(Y)`.',
     },
   },
   defaultOptions: [],

package/src/plugins/vitest-coding-style/rules/prefer-assert-coding-style-rules.test.mts

@@ -0,0 +1,95 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+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';
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      sourceType: 'module',
+      project: './tsconfig.tests.json',
+    },
+    parser,
+  },
+});
+
+ruleTester.run(
+  'prefer-assert-not-ok-over-expect-false',
+  preferAssertNotOkOverExpectFalseRule,
+  {
+    valid: [
+      { code: 'assert.notOk(0);' },
+      { code: 'expect(0).toBe(true);' },
+      { code: 'expect(0).toEqual(false);' },
+    ],
+    invalid: [
+      {
+        code: 'expect(Array.isArray({})).toBe(false);',
+        output: 'assert.notOk(Array.isArray({}));',
+        errors: [{ messageId: 'preferAssertNotOkOverExpectFalse' }],
+      },
+    ],
+  },
+);
+
+ruleTester.run(
+  'prefer-assert-over-expect-true',
+  preferAssertOverExpectTrueRule,
+  {
+    valid: [
+      { code: 'assert(0);' },
+      { code: 'expect(0).toBe(false);' },
+      { code: 'expect(0).toEqual(true);' },
+      // Non-boolean argument
+      { code: 'expect(123).toBe(true);' },
+    ],
+    invalid: [
+      {
+        code: 'expect(Array.isArray([{}])).toBe(true);',
+        output: 'assert(Array.isArray([{}]));',
+        errors: [{ messageId: 'preferAssertOverExpectTrue' }],
+      },
+    ],
+  },
+);
+
+ruleTester.run('prefer-assert-over-assert-ok', preferAssertOverAssertOkRule, {
+  valid: [
+    { code: 'assert(0);' },
+    { code: 'assert.notOk(0);' },
+    { code: 'foo.ok(0);' },
+  ],
+  invalid: [
+    {
+      code: 'assert.ok(Array.isArray([]));',
+      output: 'assert(Array.isArray([]));',
+      errors: [{ messageId: 'preferAssertOverAssertOk' }],
+    },
+    {
+      code: 'assert.isOk(Array.isArray([]));',
+      output: 'assert(Array.isArray([]));',
+      errors: [{ messageId: 'preferAssertOverAssertOk' }],
+    },
+  ],
+});
+
+ruleTester.run(
+  'prefer-assert-not-ok-over-assert-is-not-ok',
+  preferAssertNotOkOverAssertIsNotOkRule,
+  {
+    valid: [
+      { code: 'assert(0);' },
+      { code: 'assert.notOk(0);' },
+      { code: 'foo.isNotOk(0);' },
+    ],
+    invalid: [
+      {
+        code: 'assert.isNotOk(Array.isArray([]));',
+        output: 'assert.notOk(Array.isArray([]));',
+        errors: [{ messageId: 'preferAssertOverAssertNotOk' }],
+      },
+    ],
+  },
+);

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

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

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

@@ -0,0 +1,74 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  type TSESLint,
+} from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import * as ts from 'typescript';
+
+type MessageIds = 'preferAssertNotOkOverExpectFalse';
+
+type Options = readonly [];
+
+export const preferAssertNotOkOverExpectFalseRule: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Prefer assert.notOk(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)',
+    },
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const parserServices = ESLintUtils.getParserServices(context);
+
+    const checker = parserServices.program.getTypeChecker();
+
+    return {
+      CallExpression: (node) => {
+        if (
+          node.callee.type === AST_NODE_TYPES.MemberExpression &&
+          node.callee.object.type === AST_NODE_TYPES.CallExpression &&
+          node.callee.object.callee.type === AST_NODE_TYPES.Identifier &&
+          node.callee.object.callee.name === 'expect' &&
+          node.callee.property.type === AST_NODE_TYPES.Identifier &&
+          node.callee.property.name === 'toBe' &&
+          Arr.isArrayOfLength(node.arguments, 1) &&
+          node.arguments[0].type === AST_NODE_TYPES.Literal &&
+          node.arguments[0].value === false
+        ) {
+          const arg = node.callee.object.arguments[0];
+
+          if (arg !== undefined) {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(arg);
+
+            const type = checker.getTypeAtLocation(tsNode);
+
+            const isBoolean = (type.flags & ts.TypeFlags.Boolean) !== 0;
+
+            if (!isBoolean) {
+              return;
+            }
+          }
+
+          const argText = context.sourceCode.getText(arg);
+
+          context.report({
+            node,
+            messageId: 'preferAssertNotOkOverExpectFalse',
+            fix: (fixer) => fixer.replaceText(node, `assert.notOk(${argText})`),
+          });
+        }
+      },
+    };
+  },
+};

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

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

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

@@ -0,0 +1,74 @@
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  type TSESLint,
+} from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import * as ts from 'typescript';
+
+type MessageIds = 'preferAssertOverExpectTrue';
+
+type Options = readonly [];
+
+export const preferAssertOverExpectTrueRule: TSESLint.RuleModule<
+  MessageIds,
+  Options
+> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Prefer assert(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)',
+    },
+  },
+  defaultOptions: [],
+  create: (context) => {
+    const parserServices = ESLintUtils.getParserServices(context);
+
+    const checker = parserServices.program.getTypeChecker();
+
+    return {
+      CallExpression: (node) => {
+        if (
+          node.callee.type === AST_NODE_TYPES.MemberExpression &&
+          node.callee.object.type === AST_NODE_TYPES.CallExpression &&
+          node.callee.object.callee.type === AST_NODE_TYPES.Identifier &&
+          node.callee.object.callee.name === 'expect' &&
+          node.callee.property.type === AST_NODE_TYPES.Identifier &&
+          node.callee.property.name === 'toBe' &&
+          Arr.isArrayOfLength(node.arguments, 1) &&
+          node.arguments[0].type === AST_NODE_TYPES.Literal &&
+          node.arguments[0].value === true
+        ) {
+          const arg = node.callee.object.arguments[0];
+
+          if (arg !== undefined) {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(arg);
+
+            const type = checker.getTypeAtLocation(tsNode);
+
+            const isBoolean = (type.flags & ts.TypeFlags.Boolean) !== 0;
+
+            if (!isBoolean) {
+              return;
+            }
+          }
+
+          const argText = context.sourceCode.getText(arg);
+
+          context.report({
+            node,
+            messageId: 'preferAssertOverExpectTrue',
+            fix: (fixer) => fixer.replaceText(node, `assert(${argText})`),
+          });
+        }
+      },
+    };
+  },
+};

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

@@ -1,6 +1,18 @@
 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';
 
 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-over-expect-true': preferAssertOverExpectTrueRule,
+  'prefer-assert-not-ok-over-expect-false':
+    preferAssertNotOkOverExpectFalseRule,
 } as const satisfies ESLintPlugin['rules'];

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

@@ -2,4 +2,8 @@ import { type EslintVitestCodingStyleRules } from '../types/index.mjs';
 
 export const eslintVitestCodingStyleRules = {
   'vitest-coding-style/no-expect-to-strict-equal': 'error',
+  'vitest-coding-style/prefer-assert-over-assert-ok': 'error',
+  'vitest-coding-style/prefer-assert-not-ok-over-assert-is-not-ok': 'error',
+  'vitest-coding-style/prefer-assert-over-expect-true': 'error',
+  'vitest-coding-style/prefer-assert-not-ok-over-expect-false': 'error',
 } as const satisfies EslintVitestCodingStyleRules;

package/src/types/rules/eslint-vitest-coding-style-rules.mts

@@ -2,7 +2,8 @@
 import { type Linter } from 'eslint';
 
 /**
- * Disallow `expect().toStrictEqual()` in favor of `assert.deepStrictEqual()`.
+ * Disallow `expect(X).toStrictEqual(Y)` in favor of `assert.deepStrictEqual(X,
+ * Y)`, as the former also checks type equality between X and Y.
  *
  * ```md
  * | key        | value      |
@@ -16,6 +17,70 @@ namespace NoExpectToStrictEqual {
   export type RuleEntry = Linter.StringSeverity;
 }
 
+/**
+ * Prefer assert(X) over assert.ok(X), assert.isOk(X).
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+namespace PreferAssertOverAssertOk {
+  export type RuleEntry = Linter.StringSeverity;
+}
+
+/**
+ * Prefer assert.notOk(X) over assert.isNotOk(X).
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+namespace PreferAssertNotOkOverAssertIsNotOk {
+  export type RuleEntry = Linter.StringSeverity;
+}
+
+/**
+ * Prefer assert(X) over expect(X).toBe(true) (only if X is boolean)
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+namespace PreferAssertOverExpectTrue {
+  export type RuleEntry = Linter.StringSeverity;
+}
+
+/**
+ * Prefer assert.notOk(X) over expect(X).toBe(false) (only if X is boolean)
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+namespace PreferAssertNotOkOverExpectFalse {
+  export type RuleEntry = Linter.StringSeverity;
+}
+
 export type EslintVitestCodingStyleRules = Readonly<{
   'vitest-coding-style/no-expect-to-strict-equal': NoExpectToStrictEqual.RuleEntry;
+  'vitest-coding-style/prefer-assert-over-assert-ok': PreferAssertOverAssertOk.RuleEntry;
+  'vitest-coding-style/prefer-assert-not-ok-over-assert-is-not-ok': PreferAssertNotOkOverAssertIsNotOk.RuleEntry;
+  'vitest-coding-style/prefer-assert-over-expect-true': PreferAssertOverExpectTrue.RuleEntry;
+  'vitest-coding-style/prefer-assert-not-ok-over-expect-false': PreferAssertNotOkOverExpectFalse.RuleEntry;
 }>;