eslint-config-typed 3.14.1 → 4.0.0

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

@@ -1,15 +1,21 @@
 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';
 
 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,
+    'prefer-assert-deep-strict-equal-over-deep-equal': preferAssertDeepStrictEqualOverDeepEqualRule,
+    '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,
 };
 
 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":";;;;;;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;;;;;"}
+{"version":3,"file":"rules.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/rules.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;AAUO,MAAM,sBAAsB,GAAG;AACpC,IAAA,2BAA2B,EAAE,yBAAyB;AAEtD,IAAA,iDAAiD,EAC/C,4CAA4C;AAE9C,IAAA,mCAAmC,EAAE,gCAAgC;AACrE,IAAA,2CAA2C,EACzC,sCAAsC;AAExC,IAAA,wCAAwC,EACtC,oCAAoC;AACtC,IAAA,0CAA0C,EACxC,sCAAsC;AAExC,IAAA,oDAAoD,EAClD,8CAA8C;AAChD,IAAA,oDAAoD,EAClD,8CAA8C;;;;;"}

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

@@ -1,8 +1,11 @@
 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";
+    readonly 'vitest-coding-style/prefer-assert-deep-strict-equal-over-deep-equal': "error";
+    readonly 'vitest-coding-style/prefer-assert-is-false-over-assert-not-ok': "error";
+    readonly 'vitest-coding-style/prefer-assert-is-false-over-expect-false': "error";
+    readonly 'vitest-coding-style/prefer-assert-is-false-over-negated-assert-is-true': "error";
+    readonly 'vitest-coding-style/prefer-assert-is-true-over-assert': "error";
+    readonly 'vitest-coding-style/prefer-assert-is-true-over-expect-true': "error";
+    readonly 'vitest-coding-style/prefer-assert-is-true-over-negated-assert-is-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;;;;;;CAMQ,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;;;;;;;;;CAYQ,CAAC"}

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

@@ -1,9 +1,12 @@
 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',
+    'vitest-coding-style/prefer-assert-deep-strict-equal-over-deep-equal': 'error',
+    'vitest-coding-style/prefer-assert-is-false-over-assert-not-ok': 'error',
+    'vitest-coding-style/prefer-assert-is-false-over-expect-false': 'error',
+    'vitest-coding-style/prefer-assert-is-false-over-negated-assert-is-true': 'error',
+    'vitest-coding-style/prefer-assert-is-true-over-assert': 'error',
+    'vitest-coding-style/prefer-assert-is-true-over-expect-true': 'error',
+    'vitest-coding-style/prefer-assert-is-true-over-negated-assert-is-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;AACxD,IAAA,kDAAkD,EAAE,OAAO;AAC3D,IAAA,gEAAgE,EAAE,OAAO;AACzE,IAAA,oDAAoD,EAAE,OAAO;AAC7D,IAAA,4DAA4D,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,qEAAqE,EACnE,OAAO;AACT,IAAA,+DAA+D,EAAE,OAAO;AACxE,IAAA,8DAA8D,EAAE,OAAO;AACvE,IAAA,wEAAwE,EACtE,OAAO;AACT,IAAA,uDAAuD,EAAE,OAAO;AAChE,IAAA,4DAA4D,EAAE,OAAO;AACrE,IAAA,wEAAwE,EACtE,OAAO;;;;;"}

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

@@ -15,7 +15,7 @@ declare namespace NoExpectToStrictEqual {
     type RuleEntry = Linter.StringSeverity;
 }
 /**
- * Prefer assert(X) over assert.ok(X), assert.isOk(X).
+ * Prefer assert.deepStrictEqual(X) over assert.deepEqual(X).
  *
  * ```md
  * | key        | value      |
@@ -25,11 +25,11 @@ declare namespace NoExpectToStrictEqual {
  * | fixable    | code       |
  * ```
  */
-declare namespace PreferAssertOverAssertOk {
+declare namespace PreferAssertDeepStrictEqualOverDeepEqual {
     type RuleEntry = Linter.StringSeverity;
 }
 /**
- * Prefer assert.notOk(X) over assert.isNotOk(X).
+ * Prefer assert.isTrue(X) over assert(X), assert.isOk(X), assert.ok(X).
  *
  * ```md
  * | key        | value      |
@@ -39,11 +39,11 @@ declare namespace PreferAssertOverAssertOk {
  * | fixable    | code       |
  * ```
  */
-declare namespace PreferAssertNotOkOverAssertIsNotOk {
+declare namespace PreferAssertIsTrueOverAssert {
     type RuleEntry = Linter.StringSeverity;
 }
 /**
- * Prefer assert(X) over expect(X).toBe(true) (only if X is boolean)
+ * Prefer assert.isFalse(X) over assert.isNotOk(X), assert.notOk(X).
  *
  * ```md
  * | key        | value      |
@@ -53,11 +53,11 @@ declare namespace PreferAssertNotOkOverAssertIsNotOk {
  * | fixable    | code       |
  * ```
  */
-declare namespace PreferAssertOverExpectTrue {
+declare namespace PreferAssertIsFalseOverAssertNotOk {
     type RuleEntry = Linter.StringSeverity;
 }
 /**
- * Prefer assert.notOk(X) over expect(X).toBe(false) (only if X is boolean)
+ * Prefer assert.isTrue(X) over expect(X).toBe(true) (only if X is boolean)
  *
  * ```md
  * | key        | value      |
@@ -67,15 +67,60 @@ declare namespace PreferAssertOverExpectTrue {
  * | fixable    | code       |
  * ```
  */
-declare namespace PreferAssertNotOkOverExpectFalse {
+declare namespace PreferAssertIsTrueOverExpectTrue {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * Prefer assert.isFalse(X) over expect(X).toBe(false) (only if X is boolean)
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+declare namespace PreferAssertIsFalseOverExpectFalse {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * Prefer assert.isFalse(X) over assert.isTrue(!X).
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+declare namespace PreferAssertIsFalseOverNegatedAssertIsTrue {
+    type RuleEntry = Linter.StringSeverity;
+}
+/**
+ * Prefer assert.isTrue(X) over assert.isFalse(!X).
+ *
+ * ```md
+ * | key        | value      |
+ * | :--------- | :--------- |
+ * | type       | suggestion |
+ * | deprecated | false      |
+ * | fixable    | code       |
+ * ```
+ */
+declare namespace PreferAssertIsTrueOverNegatedAssertIsFalse {
     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;
+    'vitest-coding-style/prefer-assert-deep-strict-equal-over-deep-equal': PreferAssertDeepStrictEqualOverDeepEqual.RuleEntry;
+    'vitest-coding-style/prefer-assert-is-true-over-assert': PreferAssertIsTrueOverAssert.RuleEntry;
+    'vitest-coding-style/prefer-assert-is-false-over-assert-not-ok': PreferAssertIsFalseOverAssertNotOk.RuleEntry;
+    'vitest-coding-style/prefer-assert-is-true-over-expect-true': PreferAssertIsTrueOverExpectTrue.RuleEntry;
+    'vitest-coding-style/prefer-assert-is-false-over-expect-false': PreferAssertIsFalseOverExpectFalse.RuleEntry;
+    'vitest-coding-style/prefer-assert-is-false-over-negated-assert-is-true': PreferAssertIsFalseOverNegatedAssertIsTrue.RuleEntry;
+    'vitest-coding-style/prefer-assert-is-true-over-negated-assert-is-false': PreferAssertIsTrueOverNegatedAssertIsFalse.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;;;;;;;;;;;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"}
+{"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,wCAAwC,CAAC;IACjD,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,4BAA4B,CAAC;IACrC,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,gCAAgC,CAAC;IACzC,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,0CAA0C,CAAC;IACnD,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,0CAA0C,CAAC;IACnD,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,qEAAqE,EAAE,wCAAwC,CAAC,SAAS,CAAC;IAC1H,uDAAuD,EAAE,4BAA4B,CAAC,SAAS,CAAC;IAChG,+DAA+D,EAAE,kCAAkC,CAAC,SAAS,CAAC;IAC9G,4DAA4D,EAAE,gCAAgC,CAAC,SAAS,CAAC;IACzG,8DAA8D,EAAE,kCAAkC,CAAC,SAAS,CAAC;IAC7G,wEAAwE,EAAE,0CAA0C,CAAC,SAAS,CAAC;IAC/H,wEAAwE,EAAE,0CAA0C,CAAC,SAAS,CAAC;CAChI,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-config-typed",
-  "version": "3.14.1",
+  "version": "4.0.0",
   "private": false,
   "keywords": [
     "typescript"
@@ -19,6 +19,11 @@
         "types": "./dist/types.d.mts",
         "default": "./dist/entry-point.mjs"
       }
+    },
+    "./vitest-coding-style": {
+      "import": {
+        "types": "./src/plugins/vitest-coding-style/rules/vitest-coding-style.d.mts"
+      }
     }
   },
   "module": "./dist/entry-point.mjs",

package/src/plugins/vitest-coding-style/rules/original-assert-api-type.test.mts

@@ -0,0 +1,147 @@
+import { expectType } from 'ts-data-forge';
+// eslint-disable-next-line vitest/no-importing-vitest-globals
+import { type assert as originalAssert } from 'vitest';
+
+expectType<
+  StrictExclude<
+    keyof typeof originalAssert,
+    | 'approximately'
+    | 'changes'
+    | 'changesBy'
+    | 'closeTo'
+    | 'containsAllDeepKeys'
+    | 'containsAllKeys'
+    | 'containsSubset'
+    | 'containSubset'
+    | 'decreases'
+    | 'decreasesButNotBy'
+    | 'decreasesBy'
+    | 'deepEqual' // remove
+    | 'deepInclude'
+    | 'deepNestedInclude'
+    | 'deepNestedPropertyVal'
+    | 'deepOwnInclude'
+    | 'deepProperty'
+    | 'deepPropertyVal'
+    | 'deepStrictEqual'
+    | 'doesNotChange'
+    | 'doesNotContainSubset'
+    | 'doesNotDecrease'
+    | 'doesNotDecreaseBy'
+    | 'doesNotHaveAllDeepKeys'
+    | 'doesNotHaveAllKeys'
+    | 'doesNotHaveAnyDeepKeys'
+    | 'doesNotHaveAnyKeys'
+    | 'doesNotIncrease'
+    | 'doesNotThrow'
+    | 'equal' // remove
+    | 'exists'
+    | 'extensible'
+    | 'fail'
+    | 'frozen'
+    | 'hasAllDeepKeys'
+    | 'hasAllKeys'
+    | 'hasAnyDeepKeys'
+    | 'hasAnyKeys'
+    | 'ifError'
+    | 'include'
+    | 'includeDeepMembers'
+    | 'includeDeepOrderedMembers'
+    | 'includeMembers'
+    | 'includeOrderedMembers'
+    | 'increases'
+    | 'increasesButNotBy'
+    | 'increasesBy'
+    | 'instanceOf'
+    | 'isAbove'
+    | 'isArray'
+    | 'isAtLeast'
+    | 'isAtMost'
+    | 'isBelow'
+    | 'isBoolean'
+    | 'isDefined'
+    | 'isEmpty'
+    | 'isExtensible'
+    | 'isFalse'
+    | 'isFinite'
+    | 'isFrozen'
+    | 'isFunction'
+    | 'isNaN'
+    | 'isNotArray'
+    | 'isNotBoolean'
+    | 'isNotEmpty'
+    | 'isNotExtensible'
+    | 'isNotFalse'
+    | 'isNotFrozen'
+    | 'isNotFunction'
+    | 'isNotNaN'
+    | 'isNotNull'
+    | 'isNotNumber'
+    | 'isNotObject'
+    | 'isNotOk' // remove
+    | 'isNotSealed'
+    | 'isNotString'
+    | 'isNotTrue'
+    | 'isNull'
+    | 'isNumber'
+    | 'isObject'
+    | 'isOk' // remove
+    | 'isSealed'
+    | 'isString'
+    | 'isTrue'
+    | 'isUndefined'
+    | 'lengthOf'
+    | 'match'
+    | 'nestedInclude'
+    | 'nestedProperty'
+    | 'nestedPropertyVal'
+    | 'notDeepEqual'
+    | 'notDeepInclude'
+    | 'notDeepNestedInclude'
+    | 'notDeepNestedPropertyVal'
+    | 'notDeepOwnInclude'
+    | 'notDeepProperty'
+    | 'notDeepPropertyVal'
+    | 'notEqual' // remove
+    | 'notExists'
+    | 'notExtensible'
+    | 'notFrozen'
+    | 'notInclude'
+    | 'notIncludeDeepMembers'
+    | 'notIncludeDeepOrderedMembers'
+    | 'notIncludeMembers'
+    | 'notIncludeOrderedMembers'
+    | 'notInstanceOf'
+    | 'notMatch'
+    | 'notNestedInclude'
+    | 'notNestedProperty'
+    | 'notNestedPropertyVal'
+    | 'notOk' // remove
+    | 'notOwnInclude'
+    | 'notProperty'
+    | 'notPropertyVal'
+    | 'notSameDeepMembers'
+    | 'notSameDeepOrderedMembers'
+    | 'notSameOrderedMembers'
+    | 'notSealed'
+    | 'notStrictEqual'
+    | 'notTypeOf'
+    | 'ok' // remove
+    | 'oneOf'
+    | 'operator'
+    | 'ownInclude'
+    | 'property'
+    | 'propertyVal'
+    | 'sameDeepMembers'
+    | 'sameDeepOrderedMembers'
+    | 'sameMembers'
+    | 'sameOrderedMembers'
+    | 'sealed'
+    | 'strictEqual'
+    | 'throw'
+    | 'Throw'
+    | 'throws'
+    | 'typeOf'
+  >,
+  never
+>('=');

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

@@ -1,9 +1,11 @@
 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';
+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 { preferAssertIsTrueOverAssertRule } from './prefer-assert-is-true-over-assert.mjs';
+import { preferAssertIsTrueOverExpectTrueRule } from './prefer-assert-is-true-over-expect-true.mjs';
 
 const ruleTester = new RuleTester({
   languageOptions: {
@@ -16,27 +18,31 @@ const ruleTester = new RuleTester({
 });
 
 ruleTester.run(
-  'prefer-assert-not-ok-over-expect-false',
-  preferAssertNotOkOverExpectFalseRule,
+  'prefer-assert-deep-strict-equal-over-deep-equal',
+  preferAssertDeepStrictEqualOverDeepEqualRule,
   {
     valid: [
-      { code: 'assert.notOk(0);' },
-      { code: 'expect(0).toBe(true);' },
-      { code: 'expect(0).toEqual(false);' },
+      { code: 'assert.deepStrictEqual(a, b);' },
+      { code: 'foo.deepEqual(a, b);' },
     ],
     invalid: [
       {
-        code: 'expect(Array.isArray({})).toBe(false);',
-        output: 'assert.notOk(Array.isArray({}));',
-        errors: [{ messageId: 'preferAssertNotOkOverExpectFalse' }],
+        code: 'assert.deepEqual(a, b, "message");',
+        output: 'assert.deepStrictEqual(a, b, "message");',
+        errors: [{ messageId: 'preferAssertDeepStrictEqual' }],
+      },
+      {
+        code: 'assert.deepEqual(a, b);',
+        output: 'assert.deepStrictEqual(a, b);',
+        errors: [{ messageId: 'preferAssertDeepStrictEqual' }],
       },
     ],
   },
 );
 
 ruleTester.run(
-  'prefer-assert-over-expect-true',
-  preferAssertOverExpectTrueRule,
+  'prefer-assert-is-over-expect-true',
+  preferAssertIsTrueOverExpectTrueRule,
   {
     valid: [
       { code: 'assert(0);' },
@@ -48,48 +54,120 @@ ruleTester.run(
     invalid: [
       {
         code: 'expect(Array.isArray([{}])).toBe(true);',
-        output: 'assert(Array.isArray([{}]));',
-        errors: [{ messageId: 'preferAssertOverExpectTrue' }],
+        output: 'assert.isTrue(Array.isArray([{}]));',
+        errors: [{ messageId: 'preferAssertIsTrueOverExpectTrue' }],
       },
     ],
   },
 );
 
-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-is-false-over-expect-false',
+  preferAssertIsFalseOverExpectFalseRule,
+  {
+    valid: [
+      { code: 'assert.notOk(0);' },
+      { code: 'expect(0).toBe(true);' },
+      { code: 'expect(0).toEqual(false);' },
+    ],
+    invalid: [
+      {
+        code: 'expect(Array.isArray({})).toBe(false);',
+        output: 'assert.isFalse(Array.isArray({}));',
+        errors: [{ messageId: 'preferAssertIsFalseOverExpectFalse' }],
+      },
+    ],
+  },
+);
 
 ruleTester.run(
-  'prefer-assert-not-ok-over-assert-is-not-ok',
-  preferAssertNotOkOverAssertIsNotOkRule,
+  'prefer-assert-is-true-over-assert',
+  preferAssertIsTrueOverAssertRule,
   {
     valid: [
-      { code: 'assert(0);' },
+      { code: 'assert.isTrue(0);' },
       { code: 'assert.notOk(0);' },
+      { code: 'foo.ok(0);' },
+    ],
+    invalid: [
+      {
+        code: 'assert.isOk(Array.isArray([]));',
+        output: 'assert.isTrue(Array.isArray([]));',
+        errors: [{ messageId: 'preferAssertIsTrueOverAssert' }],
+      },
+      {
+        code: 'assert.ok(Array.isArray([]));',
+        output: 'assert.isTrue(Array.isArray([]));',
+        errors: [{ messageId: 'preferAssertIsTrueOverAssert' }],
+      },
+      {
+        code: 'assert(Array.isArray([]));',
+        output: 'assert.isTrue(Array.isArray([]));',
+        errors: [{ messageId: 'preferAssertIsTrueOverAssert' }],
+      },
+    ],
+  },
+);
+
+ruleTester.run(
+  'prefer-assert-is-false-over-assert-is-not-ok',
+  preferAssertIsFalseOverAssertNotOkRule,
+  {
+    valid: [
+      { code: 'assert(0);' },
+      { code: 'assert.isFalse(0);' },
       { code: 'foo.isNotOk(0);' },
     ],
     invalid: [
       {
         code: 'assert.isNotOk(Array.isArray([]));',
-        output: 'assert.notOk(Array.isArray([]));',
-        errors: [{ messageId: 'preferAssertOverAssertNotOk' }],
+        output: 'assert.isFalse(Array.isArray([]));',
+        errors: [{ messageId: 'preferAssertIsFalseOverAssertNotOk' }],
+      },
+      {
+        code: 'assert.notOk(Array.isArray([]));',
+        output: 'assert.isFalse(Array.isArray([]));',
+        errors: [{ messageId: 'preferAssertIsFalseOverAssertNotOk' }],
       },
     ],
   },
 );
+
+ruleTester.run(
+  'prefer-assert-is-false-over-negated-assert-is-true',
+  preferAssertIsFalseOverNegatedAssertIsTrueRule,
+  {
+    valid: [
+      { code: 'assert.notOk(foo);' },
+      { code: 'assert(!foo, );' },
+      { code: 'expect(!foo).toBeTruthy();' },
+      { code: 'assert(foo);' },
+    ],
+    invalid: [
+      {
+        code: 'assert.isTrue(!foo);',
+        output: 'assert.isFalse(foo);',
+        errors: [{ messageId: 'preferAssertIsFalseOverAssertNegation' }],
+      },
+      {
+        code: 'assert.isTrue(!condition());',
+        output: 'assert.isFalse(condition());',
+        errors: [{ messageId: 'preferAssertIsFalseOverAssertNegation' }],
+      },
+    ],
+  },
+);
+
+describe('chai API', () => {
+  test('assert truthy', () => {
+    // @ts-expect-error truthy value is ok
+    // eslint-disable-next-line vitest-coding-style/prefer-assert-is-true-over-assert, total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unsafe-call
+    assert.isOk(1 as unknown as boolean);
+
+    assert.isTrue(true);
+
+    // @ts-expect-error truthy value is ok
+    // eslint-disable-next-line vitest-coding-style/prefer-assert-is-true-over-assert, total-functions/no-unsafe-type-assertion
+    assert(1 as unknown as boolean);
+  });
+});

package/src/plugins/vitest-coding-style/rules/{prefer-assert-over-assert-ok.mts → prefer-assert-deep-strict-equal-over-deep-equal.mts}

@@ -1,23 +1,23 @@
 import { AST_NODE_TYPES, type TSESLint } from '@typescript-eslint/utils';
 
-type MessageIds = 'preferAssertOverAssertOk';
+type MessageIds = 'preferAssertDeepStrictEqual';
 
 type Options = readonly [];
 
-export const preferAssertOverAssertOkRule: TSESLint.RuleModule<
+export const preferAssertDeepStrictEqualOverDeepEqualRule: TSESLint.RuleModule<
   MessageIds,
   Options
 > = {
   meta: {
     type: 'suggestion',
     docs: {
-      description: 'Prefer assert(X) over assert.ok(X), assert.isOk(X).',
+      description: 'Prefer assert.deepStrictEqual(X) over assert.deepEqual(X).',
     },
     fixable: 'code',
     schema: [],
     messages: {
-      preferAssertOverAssertOk:
-        'Use assert(X) instead of assert.ok(X), assert.isOk(X).',
+      preferAssertDeepStrictEqual:
+        'Use assert.deepStrictEqual(X) instead of assert.deepEqual(X).',
     },
   },
   defaultOptions: [],
@@ -27,14 +27,14 @@ export const preferAssertOverAssertOkRule: TSESLint.RuleModule<
         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.property.name === 'deepEqual' &&
         node.parent.type === AST_NODE_TYPES.CallExpression &&
         node.parent.callee === node
       ) {
         context.report({
           node,
-          messageId: 'preferAssertOverAssertOk',
-          fix: (fixer) => fixer.replaceText(node, 'assert'),
+          messageId: 'preferAssertDeepStrictEqual',
+          fix: (fixer) => fixer.replaceText(node, 'assert.deepStrictEqual'),
         });
       }
     },