eslint-config-typed 3.14.1 → 4.0.1

package/README.md

@@ -16,12 +16,12 @@ A comprehensive ESLint configuration package with strongly-typed rule definition
     - [defineConfig helper](#defineconfig-helper)
     - [defineKnownRules utility](#defineknownrules-utility)
     - [withDefaultOption utility](#withdefaultoption-utility)
+- [TypeScript Configuration Files](#typescript-configuration-files)
 - [Configuration Examples](#configuration-examples)
     - [TypeScript + React Project](#typescript--react-project)
     - [Node.js TypeScript Project](#nodejs-typescript-project)
     - [React + Testing Libraries](#react--testing-libraries)
 - [VS Code Integration](#vs-code-integration)
-- [TypeScript Configuration Files](#typescript-configuration-files)
 - [Included plugins](#included-plugins)
 - [API Reference](#api-reference)
     - [Configuration Functions](#configuration-functions)
@@ -31,6 +31,10 @@ A comprehensive ESLint configuration package with strongly-typed rule definition
     - [Rule Collections](#rule-collections)
     - [Exported Pre-configured Rule Options](#exported-pre-configured-rule-options)
     - [Custom Plugins](#custom-plugins)
+        - [Forked plugins](#forked-plugins)
+        - [ts-restrictions](#ts-restrictions)
+        - [vitest-coding-style](#vitest-coding-style)
+        - [react-coding-style](#react-coding-style)
     - [Type Definitions](#type-definitions)
         - [Core Types](#core-types)
         - [Rule Types](#rule-types)
@@ -43,6 +47,7 @@ A comprehensive ESLint configuration package with strongly-typed rule definition
         - [1. ESLint can't find tsconfig.json](#1-eslint-cant-find-tsconfigjson)
         - [2. Import resolution errors](#2-import-resolution-errors)
         - [3. Performance issues](#3-performance-issues)
+        - [4. How to Use import-x/no-unused-modules](#4-how-to-use-import-xno-unused-modules)
     - [Known Limitations](#known-limitations)
 - [Contributing](#contributing)
 - [License](#license)
@@ -536,16 +541,21 @@ The shape of the rule option varies depending on the rule, so please check the c
 
 ### Custom Plugins
 
+#### Forked plugins
+
 - **`eslintPluginTotalFunctions`**
-    - `eslint-plugin-total-functions` with support for Flat Config
+    - Flat Config version of `eslint-plugin-total-functions`
 - **`eslintPluginTreeShakable`**
-    - `eslint-plugin-tree-shakable` with support for Flat Config
-- **`eslintPluginReactCodingStyle`**
-    - Custom ESLint plugin that codifies this repository's React memo component conventions (namespace imports, `React.memo<Props>`, arrow props naming, etc.). See [`src/plugins/react-coding-style/README.md`](src/plugins/react-coding-style/README.md) for the rationale and examples.
-    - Provides rules such as `react-coding-style/import-style`, `react-coding-style/component-var-type-annotation`, `react-coding-style/react-memo-type-parameter`, `react-coding-style/react-memo-props-argument-name`, `react-coding-style/props-type-annotation-style`, and `react-coding-style/react-hooks-definition-style`.
-- **`eslintPluginTsRestrictions`** - Custom ESLint plugin with additional rules for TypeScript
-    - Currently, this plugin only provides the `ts-restrictions/no-restricted-syntax` rule (which duplicates ESLint's `no-restricted-syntax` rule).
-    - Can be used to set the error level to `error` or `warn` as needed.
+    - Flat Config version of `eslint-plugin-tree-shakable`
+- **`eslintPluginStrictDependencies`**
+    - Flat Config version of `eslint-plugin-strict-dependencies`
+
+#### ts-restrictions
+
+**`eslintPluginTsRestrictions`** - Custom ESLint plugin with additional rules for TypeScript
+
+- Currently, this plugin only provides the `ts-restrictions/no-restricted-syntax` rule (which duplicates ESLint's `no-restricted-syntax` rule).
+- Can be used to set the error level to `error` or `warn` as needed.
 
 Example:
 
@@ -579,6 +589,77 @@ export default [
 ] satisfies FlatConfig[];
 ```
 
+#### vitest-coding-style
+
+**`eslintPluginVitestCodingStyle`** - Opinionated rules that constrain how Vitest `assert`/`expect` APIs are used. Rules that rely on type information (for example `prefer-assert-is-true-over-expect-true` / `prefer-assert-is-false-over-expect-false`) assume the plugin types are loaded via tsconfig; add this plugin type definition to `compilerOptions.types` as shown below.
+
+```jsonc
+{
+    "compilerOptions": {
+        "types": [
+            // "vitest/globals", // Remove this line
+            "eslint-config-typed/vitest", // Add this line
+            "vitest/importMeta",
+        ],
+    },
+}
+```
+
+This type definition provides overridden `Chai.Assert` type:
+
+- Change the type definition of `isTrue`/`isFalse`
+    - Change the arg type from `unknown` to `boolean`
+    - Change the return type of `isTrue` from `asserts value is true` to `asserts value` so that it can be used as an assertion function like `assert.ok`.
+    - Removed optional `message` arg
+    - Before
+        - `isTrue: (value: unknown, message?: string) => asserts value is true`
+        - `isFalse: (value: unknown, message?: string) => asserts value is false`
+    - After
+        - `isTrue: (value: boolean) => asserts value;`
+        - `isFalse: (value: boolean) => asserts value is false`
+- Removed the call signature (`assert(x)`)
+- Removed `deepEqual`, `equal`, `notEqual`, `ok`, `notOk`, `isOk`, `isNotOk`,
+    - `deepEqual` : Removed in favor of `assert.deepStrictEqual`
+    - `equal` : Removed in favor of `assert.strictEqual`
+    - `notEqual` : Removed in favor of `assert.notStrictEqual`
+    - `ok` : Removed in favor of `assert.isTrue`
+    - `notOk` : Removed in favor of `assert.isFalse`
+    - `isOk` : Removed in favor of `assert.isTrue`
+    - `isNotOk` : Removed in favor of `assert.isFalse`
+- Removed optional `message` arg from all `assert.*` methods
+- Convert arg types to be readonly
+- Replace `Object` with `object`
+
+| Included rules                                       | Description                                                                                   |
+| :--------------------------------------------------- | :-------------------------------------------------------------------------------------------- |
+| `no-expect-to-strict-equal`                          | Forbid `expect(x).toStrictEqual(y)`; prefer `assert.deepStrictEqual(x, y)`                    |
+| `prefer-assert-deep-strict-equal-over-deep-equal`    | Replace `assert.deepEqual(x)` with `assert.deepStrictEqual(x)`                                |
+| `prefer-assert-is-true-over-assert`                  | Canonicalize `assert(x)` / `assert.isOk(x)` / `assert.ok(x)` to `assert.isTrue(x)`            |
+| `prefer-assert-is-false-over-assert-not-ok`          | Canonicalize `assert.isNotOk(x)` / `assert.notOk(x)` to `assert.isFalse(x)`                   |
+| `prefer-assert-is-false-over-negated-assert-is-true` | Rewrite `assert.isTrue(!x)` to `assert.isFalse(x)`                                            |
+| `prefer-assert-is-true-over-negated-assert-is-false` | Rewrite `assert.isFalse(!x)` to `assert.isTrue(x)`                                            |
+| `prefer-assert-is-true-over-expect-true`             | Rewrite `expect(x).toBe(true)` to `assert.isTrue(x)` (only when `x` is boolean; type-aware)   |
+| `prefer-assert-is-false-over-expect-false`           | Rewrite `expect(x).toBe(false)` to `assert.isFalse(x)` (only when `x` is boolean; type-aware) |
+
+#### react-coding-style
+
+**`eslintPluginReactCodingStyle`** - Custom ESLint plugin that codifies this repository's React memo component conventions (namespace imports, `React.memo<Props>`, arrow props naming, etc.).
+
+- See [`src/plugins/react-coding-style/README.md`](src/plugins/react-coding-style/README.md) for the rationale and examples.
+- Provides rules such as `react-coding-style/import-style`, `react-coding-style/component-var-type-annotation`, `react-coding-style/react-memo-type-parameter`, `react-coding-style/react-memo-props-argument-name`, `react-coding-style/props-type-annotation-style`, and `react-coding-style/react-hooks-definition-style`.
+
+| Included rules                   | Description                                                                                                           |
+| :------------------------------- | :-------------------------------------------------------------------------------------------------------------------- |
+| `component-name`                 | Enforce concise React.memo component variable names (default max length 42; optional pattern)                         |
+| `component-var-type-annotation`  | Forbid React.FC / React.FunctionComponent type annotations; prefer `React.memo<Props>((props) => ...)`                |
+| `import-style`                   | Enforce React import style (`import * as React` by default; configurable to named imports)                            |
+| `props-type-annotation-style`    | Forbid annotating props in the React.memo arrow function; use `React.memo<Props>((props) => ...)`                     |
+| `react-memo-props-argument-name` | Require the React.memo arrow function to take a single identifier named `props`                                       |
+| `react-memo-type-parameter`      | Require `React.memo<Props>` when props exist; forbid type parameter when there are no props                           |
+| `use-memo-hook-style`            | Forbid type assertions/annotations inside and around `React.useMemo`; annotate via type parameter or variable instead |
+| `ban-use-imperative-handle-hook` | Forbid `React.useImperativeHandle`; move logic to the parent component                                                |
+| `display-name`                   | Require explicit `displayName` on React.memo components                                                               |
+
 ### Type Definitions
 
 All rules and configurations come with complete TypeScript type definitions:

package/dist/plugins/vitest-coding-style/rules/prefer-assert-deep-strict-equal-over-deep-equal.d.mts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-deep-strict-equal-over-deep-equal.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-deep-strict-equal-over-deep-equal.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,4CAA4C,EAAE,QAAQ,CAAC,UAAU,CAC5E,UAAU,EACV,OAAO,CAiCR,CAAC"}

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

@@ -1,15 +1,15 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
-const preferAssertOverAssertOkRule = {
+const preferAssertDeepStrictEqualOverDeepEqualRule = {
     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: [],
@@ -18,18 +18,18 @@ const preferAssertOverAssertOkRule = {
             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.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'),
                 });
             }
         },
     }),
 };
 
-export { preferAssertOverAssertOkRule };
-//# sourceMappingURL=prefer-assert-over-assert-ok.mjs.map
+export { preferAssertDeepStrictEqualOverDeepEqualRule };
+//# sourceMappingURL=prefer-assert-deep-strict-equal-over-deep-equal.mjs.map

package/dist/plugins/vitest-coding-style/rules/prefer-assert-deep-strict-equal-over-deep-equal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-deep-strict-equal-over-deep-equal.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-deep-strict-equal-over-deep-equal.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAMO,MAAM,4CAA4C,GAGrD;AACF,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,YAAY;AAClB,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EAAE,4DAA4D;AAC1E,SAAA;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,2BAA2B,EACzB,+DAA+D;AAClE,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,WAAW;AAClC,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,wBAAwB,CAAC;AAClE,iBAAA,CAAC;YACJ;QACF,CAAC;KACF,CAAC;;;;;"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-is-false-over-assert-negation.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-is-false-over-assert-negation.mts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzE,KAAK,UAAU,GAAG,uCAAuC,CAAC;AAE1D,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,eAAO,MAAM,8CAA8C,EAAE,QAAQ,CAAC,UAAU,CAC9E,UAAU,EACV,OAAO,CA2CR,CAAC"}

package/dist/plugins/vitest-coding-style/rules/prefer-assert-is-false-over-assert-negation.mjs

@@ -0,0 +1,41 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+
+const preferAssertIsFalseOverNegatedAssertIsTrueRule = {
+    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})`),
+                    });
+                }
+            }
+        },
+    }),
+};
+
+export { preferAssertIsFalseOverNegatedAssertIsTrueRule };
+//# sourceMappingURL=prefer-assert-is-false-over-assert-negation.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-is-false-over-assert-negation.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-is-false-over-assert-negation.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAOO,MAAM,8CAA8C,GAGvD;AACF,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,YAAY;AAClB,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EAAE,kDAAkD;AAChE,SAAA;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,qCAAqC,EACnC,qDAAqD;AACxD,SAAA;AACF,KAAA;AACD,IAAA,cAAc,EAAE,EAAE;AAClB,IAAA,MAAM,EAAE,CAAC,OAAO,MAAM;AACpB,QAAA,cAAc,EAAE,CAAC,IAAI,KAAI;YACvB,IACE,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,gBAAgB;gBACpD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AACrD,gBAAA,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ;gBACpC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AACvD,gBAAA,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,QAAQ;gBACtC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,EACtC;AACA,gBAAA,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,SAAS;AAE5B,gBAAA,IACE,GAAG,CAAC,IAAI,KAAK,cAAc,CAAC,eAAe;AAC3C,oBAAA,GAAG,CAAC,QAAQ,KAAK,GAAG,EACpB;AACA,oBAAA,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC;oBAE3D,OAAO,CAAC,MAAM,CAAC;AACb,wBAAA,IAAI,EAAE,GAAG;AACT,wBAAA,SAAS,EAAE,uCAAuC;AAClD,wBAAA,GAAG,EAAE,CAAC,KAAK,KACT,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAA,eAAA,EAAkB,UAAU,GAAG,CAAC;AAC3D,qBAAA,CAAC;gBACJ;YACF;QACF,CAAC;KACF,CAAC;;;;;"}

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

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

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

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

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

@@ -1,15 +1,15 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 
-const preferAssertNotOkOverAssertIsNotOkRule = {
+const preferAssertIsFalseOverAssertNotOkRule = {
     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: [],
@@ -18,18 +18,18 @@ const preferAssertNotOkOverAssertIsNotOkRule = {
             if (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'),
                 });
             }
         },
     }),
 };
 
-export { preferAssertNotOkOverAssertIsNotOkRule };
-//# sourceMappingURL=prefer-assert-not-ok-over-assert-is-not-ok.mjs.map
+export { preferAssertIsFalseOverAssertNotOkRule };
+//# sourceMappingURL=prefer-assert-is-false-over-assert-not-ok.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-is-false-over-assert-not-ok.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-is-false-over-assert-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,EACT,mEAAmE;AACtE,SAAA;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,kCAAkC,EAChC,sEAAsE;AACzE,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,SAAS,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,OAAO,CAAC;AACpE,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,oCAAoC;AAC/C,oBAAA,GAAG,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC;AAC1D,iBAAA,CAAC;YACJ;QACF,CAAC;KACF,CAAC;;;;;"}

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

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

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

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

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

@@ -2,16 +2,16 @@ import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { Arr } from 'ts-data-forge';
 import * as ts from 'typescript';
 
-const preferAssertNotOkOverExpectFalseRule = {
+const preferAssertIsFalseOverExpectFalseRule = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer assert.notOk(X) over expect(X).toBe(false) (only if X is boolean)',
+            description: '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: [],
@@ -41,8 +41,8 @@ const preferAssertNotOkOverExpectFalseRule = {
                     const argText = context.sourceCode.getText(arg);
                     context.report({
                         node,
-                        messageId: 'preferAssertNotOkOverExpectFalse',
-                        fix: (fixer) => fixer.replaceText(node, `assert.notOk(${argText})`),
+                        messageId: 'preferAssertIsFalseOverExpectFalse',
+                        fix: (fixer) => fixer.replaceText(node, `assert.isFalse(${argText})`),
                     });
                 }
             },
@@ -50,5 +50,5 @@ const preferAssertNotOkOverExpectFalseRule = {
     },
 };
 
-export { preferAssertNotOkOverExpectFalseRule };
-//# sourceMappingURL=prefer-assert-not-ok-over-expect-false.mjs.map
+export { preferAssertIsFalseOverExpectFalseRule };
+//# sourceMappingURL=prefer-assert-is-false-over-expect-false.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-is-false-over-expect-false.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-is-false-over-expect-false.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAYO,MAAM,sCAAsC,GAG/C;AACF,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,YAAY;AAClB,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EACT,4EAA4E;AAC/E,SAAA;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,kCAAkC,EAChC,wDAAwD;AAC3D,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,oCAAoC;AAC/C,wBAAA,GAAG,EAAE,CAAC,KAAK,KACT,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAA,eAAA,EAAkB,OAAO,GAAG,CAAC;AACxD,qBAAA,CAAC;gBACJ;YACF,CAAC;SACF;IACH,CAAC;;;;;"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-is-true-over-assert-negated-is-false.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-is-true-over-assert-negated-is-false.mts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzE,KAAK,UAAU,GAAG,4CAA4C,CAAC;AAE/D,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,eAAO,MAAM,8CAA8C,EAAE,QAAQ,CAAC,UAAU,CAC9E,UAAU,EACV,OAAO,CA2CR,CAAC"}

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

@@ -0,0 +1,41 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+
+const preferAssertIsTrueOverNegatedAssertIsFalseRule = {
+    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})`),
+                    });
+                }
+            }
+        },
+    }),
+};
+
+export { preferAssertIsTrueOverNegatedAssertIsFalseRule };
+//# sourceMappingURL=prefer-assert-is-true-over-assert-negated-is-false.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-is-true-over-assert-negated-is-false.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-is-true-over-assert-negated-is-false.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAOO,MAAM,8CAA8C,GAGvD;AACF,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,YAAY;AAClB,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EAAE,kDAAkD;AAChE,SAAA;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,0CAA0C,EACxC,qDAAqD;AACxD,SAAA;AACF,KAAA;AACD,IAAA,cAAc,EAAE,EAAE;AAClB,IAAA,MAAM,EAAE,CAAC,OAAO,MAAM;AACpB,QAAA,cAAc,EAAE,CAAC,IAAI,KAAI;YACvB,IACE,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,gBAAgB;gBACpD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AACrD,gBAAA,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ;gBACpC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AACvD,gBAAA,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS;gBACvC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,EACtC;AACA,gBAAA,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,SAAS;AAE5B,gBAAA,IACE,GAAG,CAAC,IAAI,KAAK,cAAc,CAAC,eAAe;AAC3C,oBAAA,GAAG,CAAC,QAAQ,KAAK,GAAG,EACpB;AACA,oBAAA,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC;oBAE3D,OAAO,CAAC,MAAM,CAAC;AACb,wBAAA,IAAI,EAAE,GAAG;AACT,wBAAA,SAAS,EAAE,4CAA4C;AACvD,wBAAA,GAAG,EAAE,CAAC,KAAK,KACT,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAA,cAAA,EAAiB,UAAU,GAAG,CAAC;AAC1D,qBAAA,CAAC;gBACJ;YACF;QACF,CAAC;KACF,CAAC;;;;;"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-is-true-over-assert.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-is-true-over-assert.mts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzE,KAAK,UAAU,GAAG,8BAA8B,CAAC;AAEjD,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,UAAU,CAChE,UAAU,EACV,OAAO,CA0DR,CAAC"}

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

@@ -0,0 +1,52 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+const preferAssertIsTrueOverAssertRule = {
+    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'),
+                    });
+                }
+            }
+        },
+    }),
+};
+
+export { preferAssertIsTrueOverAssertRule };
+//# sourceMappingURL=prefer-assert-is-true-over-assert.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-assert-is-true-over-assert.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-is-true-over-assert.mts"],"sourcesContent":[null],"names":[],"mappings":";;AAMO,MAAM,gCAAgC,GAGzC;AACF,IAAA,IAAI,EAAE;AACJ,QAAA,IAAI,EAAE,YAAY;AAClB,QAAA,IAAI,EAAE;AACJ,YAAA,WAAW,EACT,uEAAuE;AAC1E,SAAA;AACD,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,MAAM,EAAE,EAAE;AACV,QAAA,QAAQ,EAAE;AACR,YAAA,4BAA4B,EAC1B,gDAAgD;AACnD,SAAA;AACF,KAAA;AACD,IAAA,cAAc,EAAE,EAAE;AAClB,IAAA,MAAM,EAAE,CAAC,OAAO,MAAM;AACpB,QAAA,cAAc,EAAE,CAAC,IAAI,KAAI;;YAEvB,IACE,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AAC9C,gBAAA,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ,EAC7B;gBACA,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;oBAC/B;gBACF;gBAEA,OAAO,CAAC,MAAM,CAAC;oBACb,IAAI,EAAE,IAAI,CAAC,MAAM;AACjB,oBAAA,SAAS,EAAE,8BAA8B;AACzC,oBAAA,IAAI,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE;AAC1B,oBAAA,GAAG,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,eAAe,CAAC;AAChE,iBAAA,CAAC;gBAEF;YACF;;YAIA,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,gBAAgB,EAAE;AACxD,gBAAA,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM;gBAE1B,IACE,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AAChD,oBAAA,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,QAAQ;AAC/B,oBAAA,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;AAClD,qBAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,MAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC,EAClE;oBACA,OAAO,CAAC,MAAM,CAAC;AACb,wBAAA,IAAI,EAAE,MAAM;AACZ,wBAAA,SAAS,EAAE,8BAA8B;wBACzC,IAAI,EAAE,EAAE,MAAM,EAAE,CAAA,OAAA,EAAU,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAA,CAAE,EAAE;AAClD,wBAAA,GAAG,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC;AAC3D,qBAAA,CAAC;gBACJ;YACF;QACF,CAAC;KACF,CAAC;;;;;"}

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

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

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

@@ -1 +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"}
+{"version":3,"file":"prefer-assert-is-true-over-expect-true.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-is-true-over-expect-true.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,CA4DR,CAAC"}

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

@@ -2,16 +2,16 @@ import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { Arr } from 'ts-data-forge';
 import * as ts from 'typescript';
 
-const preferAssertOverExpectTrueRule = {
+const preferAssertIsTrueOverExpectTrueRule = {
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer assert(X) over expect(X).toBe(true) (only if X is boolean)',
+            description: '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: [],
@@ -41,8 +41,8 @@ const preferAssertOverExpectTrueRule = {
                     const argText = context.sourceCode.getText(arg);
                     context.report({
                         node,
-                        messageId: 'preferAssertOverExpectTrue',
-                        fix: (fixer) => fixer.replaceText(node, `assert(${argText})`),
+                        messageId: 'preferAssertIsTrueOverExpectTrue',
+                        fix: (fixer) => fixer.replaceText(node, `assert.isTrue(${argText})`),
                     });
                 }
             },
@@ -50,5 +50,5 @@ const preferAssertOverExpectTrueRule = {
     },
 };
 
-export { preferAssertOverExpectTrueRule };
-//# sourceMappingURL=prefer-assert-over-expect-true.mjs.map
+export { preferAssertIsTrueOverExpectTrueRule };
+//# sourceMappingURL=prefer-assert-is-true-over-expect-true.mjs.map

package/dist/plugins/vitest-coding-style/rules/{prefer-assert-not-ok-over-expect-false.mjs.map → prefer-assert-is-true-over-expect-true.mjs.map}

@@ -1 +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;;;;;"}
+{"version":3,"file":"prefer-assert-is-true-over-expect-true.mjs","sources":["../../../../src/plugins/vitest-coding-style/rules/prefer-assert-is-true-over-expect-true.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,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,kCAAkC;AAC7C,wBAAA,GAAG,EAAE,CAAC,KAAK,KACT,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,CAAA,cAAA,EAAiB,OAAO,GAAG,CAAC;AACvD,qBAAA,CAAC;gBACJ;YACF,CAAC;SACF;IACH,CAAC;;;;;"}

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

@@ -1,8 +1,11 @@
 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>;
+    readonly 'prefer-assert-deep-strict-equal-over-deep-equal': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAssertDeepStrictEqual", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-assert-is-true-over-assert': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAssertIsTrueOverAssert", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-assert-is-false-over-assert-not-ok': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAssertIsFalseOverAssertNotOk", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-assert-is-true-over-expect-true': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAssertIsTrueOverExpectTrue", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-assert-is-false-over-expect-false': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAssertIsFalseOverExpectFalse", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-assert-is-false-over-negated-assert-is-true': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAssertIsFalseOverAssertNegation", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-assert-is-true-over-negated-assert-is-false': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferAssertIsTrueOverNegatedAssertIsFalse", 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":"AAOA,eAAO,MAAM,sBAAsB;;;;;;CAUO,CAAC"}
+{"version":3,"file":"rules.d.mts","sourceRoot":"","sources":["../../../../src/plugins/vitest-coding-style/rules/rules.mts"],"names":[],"mappings":"AAUA,eAAO,MAAM,sBAAsB;;;;;;;;;CAmBO,CAAC"}