eslint-plugin-jest 28.6.0 → 28.8.0

package/README.md

@@ -317,61 +317,69 @@ Automatically fixable by the
 Manually fixable by
 [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 
-| Name                                                                         | Description                                                               | 💼  | ⚠️  | 🔧  | 💡  |
-| :--------------------------------------------------------------------------- | :------------------------------------------------------------------------ | :-- | :-- | :-- | :-- |
-| [consistent-test-it](docs/rules/consistent-test-it.md)                       | Enforce `test` and `it` usage conventions                                 |     |     | 🔧  |     |
-| [expect-expect](docs/rules/expect-expect.md)                                 | Enforce assertion to be made in a test body                               |     | ✅  |     |     |
-| [max-expects](docs/rules/max-expects.md)                                     | Enforces a maximum number assertion calls in a test body                  |     |     |     |     |
-| [max-nested-describe](docs/rules/max-nested-describe.md)                     | Enforces a maximum depth to nested describe calls                         |     |     |     |     |
-| [no-alias-methods](docs/rules/no-alias-methods.md)                           | Disallow alias methods                                                    | ✅  | 🎨  | 🔧  |     |
-| [no-commented-out-tests](docs/rules/no-commented-out-tests.md)               | Disallow commented out tests                                              |     | ✅  |     |     |
-| [no-conditional-expect](docs/rules/no-conditional-expect.md)                 | Disallow calling `expect` conditionally                                   | ✅  |     |     |     |
-| [no-conditional-in-test](docs/rules/no-conditional-in-test.md)               | Disallow conditional logic in tests                                       |     |     |     |     |
-| [no-confusing-set-timeout](docs/rules/no-confusing-set-timeout.md)           | Disallow confusing usages of jest.setTimeout                              |     |     |     |     |
-| [no-deprecated-functions](docs/rules/no-deprecated-functions.md)             | Disallow use of deprecated functions                                      | ✅  |     | 🔧  |     |
-| [no-disabled-tests](docs/rules/no-disabled-tests.md)                         | Disallow disabled tests                                                   |     | ✅  |     |     |
-| [no-done-callback](docs/rules/no-done-callback.md)                           | Disallow using a callback in asynchronous tests and hooks                 | ✅  |     |     | 💡  |
-| [no-duplicate-hooks](docs/rules/no-duplicate-hooks.md)                       | Disallow duplicate setup and teardown hooks                               |     |     |     |     |
-| [no-export](docs/rules/no-export.md)                                         | Disallow using `exports` in files containing tests                        | ✅  |     |     |     |
-| [no-focused-tests](docs/rules/no-focused-tests.md)                           | Disallow focused tests                                                    | ✅  |     |     | 💡  |
-| [no-hooks](docs/rules/no-hooks.md)                                           | Disallow setup and teardown hooks                                         |     |     |     |     |
-| [no-identical-title](docs/rules/no-identical-title.md)                       | Disallow identical titles                                                 | ✅  |     |     |     |
-| [no-interpolation-in-snapshots](docs/rules/no-interpolation-in-snapshots.md) | Disallow string interpolation inside snapshots                            | ✅  |     |     |     |
-| [no-jasmine-globals](docs/rules/no-jasmine-globals.md)                       | Disallow Jasmine globals                                                  | ✅  |     | 🔧  |     |
-| [no-large-snapshots](docs/rules/no-large-snapshots.md)                       | Disallow large snapshots                                                  |     |     |     |     |
-| [no-mocks-import](docs/rules/no-mocks-import.md)                             | Disallow manually importing from `__mocks__`                              | ✅  |     |     |     |
-| [no-restricted-jest-methods](docs/rules/no-restricted-jest-methods.md)       | Disallow specific `jest.` methods                                         |     |     |     |     |
-| [no-restricted-matchers](docs/rules/no-restricted-matchers.md)               | Disallow specific matchers & modifiers                                    |     |     |     |     |
-| [no-standalone-expect](docs/rules/no-standalone-expect.md)                   | Disallow using `expect` outside of `it` or `test` blocks                  | ✅  |     |     |     |
-| [no-test-prefixes](docs/rules/no-test-prefixes.md)                           | Require using `.only` and `.skip` over `f` and `x`                        | ✅  |     | 🔧  |     |
-| [no-test-return-statement](docs/rules/no-test-return-statement.md)           | Disallow explicitly returning from tests                                  |     |     |     |     |
-| [no-untyped-mock-factory](docs/rules/no-untyped-mock-factory.md)             | Disallow using `jest.mock()` factories without an explicit type parameter |     |     | 🔧  |     |
-| [prefer-called-with](docs/rules/prefer-called-with.md)                       | Suggest using `toBeCalledWith()` or `toHaveBeenCalledWith()`              |     |     |     |     |
-| [prefer-comparison-matcher](docs/rules/prefer-comparison-matcher.md)         | Suggest using the built-in comparison matchers                            |     |     | 🔧  |     |
-| [prefer-each](docs/rules/prefer-each.md)                                     | Prefer using `.each` rather than manual loops                             |     |     |     |     |
-| [prefer-equality-matcher](docs/rules/prefer-equality-matcher.md)             | Suggest using the built-in equality matchers                              |     |     |     | 💡  |
-| [prefer-expect-assertions](docs/rules/prefer-expect-assertions.md)           | Suggest using `expect.assertions()` OR `expect.hasAssertions()`           |     |     |     | 💡  |
-| [prefer-expect-resolves](docs/rules/prefer-expect-resolves.md)               | Prefer `await expect(...).resolves` over `expect(await ...)` syntax       |     |     | 🔧  |     |
-| [prefer-hooks-in-order](docs/rules/prefer-hooks-in-order.md)                 | Prefer having hooks in a consistent order                                 |     |     |     |     |
-| [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)                     | Suggest having hooks before any test cases                                |     |     |     |     |
-| [prefer-importing-jest-globals](docs/rules/prefer-importing-jest-globals.md) | Prefer importing Jest globals                                             |     |     | 🔧  |     |
-| [prefer-jest-mocked](docs/rules/prefer-jest-mocked.md)                       | Prefer `jest.mocked()` over `fn as jest.Mock`                             |     |     | 🔧  |     |
-| [prefer-lowercase-title](docs/rules/prefer-lowercase-title.md)               | Enforce lowercase test names                                              |     |     | 🔧  |     |
-| [prefer-mock-promise-shorthand](docs/rules/prefer-mock-promise-shorthand.md) | Prefer mock resolved/rejected shorthands for promises                     |     |     | 🔧  |     |
-| [prefer-snapshot-hint](docs/rules/prefer-snapshot-hint.md)                   | Prefer including a hint with external snapshots                           |     |     |     |     |
-| [prefer-spy-on](docs/rules/prefer-spy-on.md)                                 | Suggest using `jest.spyOn()`                                              |     |     | 🔧  |     |
-| [prefer-strict-equal](docs/rules/prefer-strict-equal.md)                     | Suggest using `toStrictEqual()`                                           |     |     |     | 💡  |
-| [prefer-to-be](docs/rules/prefer-to-be.md)                                   | Suggest using `toBe()` for primitive literals                             | 🎨  |     | 🔧  |     |
-| [prefer-to-contain](docs/rules/prefer-to-contain.md)                         | Suggest using `toContain()`                                               | 🎨  |     | 🔧  |     |
-| [prefer-to-have-length](docs/rules/prefer-to-have-length.md)                 | Suggest using `toHaveLength()`                                            | 🎨  |     | 🔧  |     |
-| [prefer-todo](docs/rules/prefer-todo.md)                                     | Suggest using `test.todo`                                                 |     |     | 🔧  |     |
-| [require-hook](docs/rules/require-hook.md)                                   | Require setup and teardown code to be within a hook                       |     |     |     |     |
-| [require-to-throw-message](docs/rules/require-to-throw-message.md)           | Require a message for `toThrow()`                                         |     |     |     |     |
-| [require-top-level-describe](docs/rules/require-top-level-describe.md)       | Require test cases and hooks to be inside a `describe` block              |     |     |     |     |
-| [valid-describe-callback](docs/rules/valid-describe-callback.md)             | Enforce valid `describe()` callback                                       | ✅  |     |     |     |
-| [valid-expect](docs/rules/valid-expect.md)                                   | Enforce valid `expect()` usage                                            | ✅  |     | 🔧  |     |
-| [valid-expect-in-promise](docs/rules/valid-expect-in-promise.md)             | Require promises that have expectations in their chain to be valid        | ✅  |     |     |     |
-| [valid-title](docs/rules/valid-title.md)                                     | Enforce valid titles                                                      | ✅  |     | 🔧  |     |
+| Name                                                                                 | Description                                                               | 💼  | ⚠️  | 🔧  | 💡  |
+| :----------------------------------------------------------------------------------- | :------------------------------------------------------------------------ | :-- | :-- | :-- | :-- |
+| [consistent-test-it](docs/rules/consistent-test-it.md)                               | Enforce `test` and `it` usage conventions                                 |     |     | 🔧  |     |
+| [expect-expect](docs/rules/expect-expect.md)                                         | Enforce assertion to be made in a test body                               |     | ✅  |     |     |
+| [max-expects](docs/rules/max-expects.md)                                             | Enforces a maximum number assertion calls in a test body                  |     |     |     |     |
+| [max-nested-describe](docs/rules/max-nested-describe.md)                             | Enforces a maximum depth to nested describe calls                         |     |     |     |     |
+| [no-alias-methods](docs/rules/no-alias-methods.md)                                   | Disallow alias methods                                                    | ✅  | 🎨  | 🔧  |     |
+| [no-commented-out-tests](docs/rules/no-commented-out-tests.md)                       | Disallow commented out tests                                              |     | ✅  |     |     |
+| [no-conditional-expect](docs/rules/no-conditional-expect.md)                         | Disallow calling `expect` conditionally                                   | ✅  |     |     |     |
+| [no-conditional-in-test](docs/rules/no-conditional-in-test.md)                       | Disallow conditional logic in tests                                       |     |     |     |     |
+| [no-confusing-set-timeout](docs/rules/no-confusing-set-timeout.md)                   | Disallow confusing usages of jest.setTimeout                              |     |     |     |     |
+| [no-deprecated-functions](docs/rules/no-deprecated-functions.md)                     | Disallow use of deprecated functions                                      | ✅  |     | 🔧  |     |
+| [no-disabled-tests](docs/rules/no-disabled-tests.md)                                 | Disallow disabled tests                                                   |     | ✅  |     |     |
+| [no-done-callback](docs/rules/no-done-callback.md)                                   | Disallow using a callback in asynchronous tests and hooks                 | ✅  |     |     | 💡  |
+| [no-duplicate-hooks](docs/rules/no-duplicate-hooks.md)                               | Disallow duplicate setup and teardown hooks                               |     |     |     |     |
+| [no-export](docs/rules/no-export.md)                                                 | Disallow using `exports` in files containing tests                        | ✅  |     |     |     |
+| [no-focused-tests](docs/rules/no-focused-tests.md)                                   | Disallow focused tests                                                    | ✅  |     |     | 💡  |
+| [no-hooks](docs/rules/no-hooks.md)                                                   | Disallow setup and teardown hooks                                         |     |     |     |     |
+| [no-identical-title](docs/rules/no-identical-title.md)                               | Disallow identical titles                                                 | ✅  |     |     |     |
+| [no-interpolation-in-snapshots](docs/rules/no-interpolation-in-snapshots.md)         | Disallow string interpolation inside snapshots                            | ✅  |     |     |     |
+| [no-jasmine-globals](docs/rules/no-jasmine-globals.md)                               | Disallow Jasmine globals                                                  | ✅  |     | 🔧  |     |
+| [no-large-snapshots](docs/rules/no-large-snapshots.md)                               | Disallow large snapshots                                                  |     |     |     |     |
+| [no-mocks-import](docs/rules/no-mocks-import.md)                                     | Disallow manually importing from `__mocks__`                              | ✅  |     |     |     |
+| [no-restricted-jest-methods](docs/rules/no-restricted-jest-methods.md)               | Disallow specific `jest.` methods                                         |     |     |     |     |
+| [no-restricted-matchers](docs/rules/no-restricted-matchers.md)                       | Disallow specific matchers & modifiers                                    |     |     |     |     |
+| [no-standalone-expect](docs/rules/no-standalone-expect.md)                           | Disallow using `expect` outside of `it` or `test` blocks                  | ✅  |     |     |     |
+| [no-test-prefixes](docs/rules/no-test-prefixes.md)                                   | Require using `.only` and `.skip` over `f` and `x`                        | ✅  |     | 🔧  |     |
+| [no-test-return-statement](docs/rules/no-test-return-statement.md)                   | Disallow explicitly returning from tests                                  |     |     |     |     |
+| [no-untyped-mock-factory](docs/rules/no-untyped-mock-factory.md)                     | Disallow using `jest.mock()` factories without an explicit type parameter |     |     | 🔧  |     |
+| [padding-around-after-all-blocks](docs/rules/padding-around-after-all-blocks.md)     | Enforce padding around `afterAll` blocks                                  |     |     | 🔧  |     |
+| [padding-around-after-each-blocks](docs/rules/padding-around-after-each-blocks.md)   | Enforce padding around `afterEach` blocks                                 |     |     | 🔧  |     |
+| [padding-around-all](docs/rules/padding-around-all.md)                               | Enforce padding around Jest functions                                     |     |     | 🔧  |     |
+| [padding-around-before-all-blocks](docs/rules/padding-around-before-all-blocks.md)   | Enforce padding around `beforeAll` blocks                                 |     |     | 🔧  |     |
+| [padding-around-before-each-blocks](docs/rules/padding-around-before-each-blocks.md) | Enforce padding around `beforeEach` blocks                                |     |     | 🔧  |     |
+| [padding-around-describe-blocks](docs/rules/padding-around-describe-blocks.md)       | Enforce padding around `describe` blocks                                  |     |     | 🔧  |     |
+| [padding-around-expect-groups](docs/rules/padding-around-expect-groups.md)           | Enforce padding around `expect` groups                                    |     |     | 🔧  |     |
+| [padding-around-test-blocks](docs/rules/padding-around-test-blocks.md)               | Enforce padding around afterAll blocks                                    |     |     | 🔧  |     |
+| [prefer-called-with](docs/rules/prefer-called-with.md)                               | Suggest using `toBeCalledWith()` or `toHaveBeenCalledWith()`              |     |     |     |     |
+| [prefer-comparison-matcher](docs/rules/prefer-comparison-matcher.md)                 | Suggest using the built-in comparison matchers                            |     |     | 🔧  |     |
+| [prefer-each](docs/rules/prefer-each.md)                                             | Prefer using `.each` rather than manual loops                             |     |     |     |     |
+| [prefer-equality-matcher](docs/rules/prefer-equality-matcher.md)                     | Suggest using the built-in equality matchers                              |     |     |     | 💡  |
+| [prefer-expect-assertions](docs/rules/prefer-expect-assertions.md)                   | Suggest using `expect.assertions()` OR `expect.hasAssertions()`           |     |     |     | 💡  |
+| [prefer-expect-resolves](docs/rules/prefer-expect-resolves.md)                       | Prefer `await expect(...).resolves` over `expect(await ...)` syntax       |     |     | 🔧  |     |
+| [prefer-hooks-in-order](docs/rules/prefer-hooks-in-order.md)                         | Prefer having hooks in a consistent order                                 |     |     |     |     |
+| [prefer-hooks-on-top](docs/rules/prefer-hooks-on-top.md)                             | Suggest having hooks before any test cases                                |     |     |     |     |
+| [prefer-importing-jest-globals](docs/rules/prefer-importing-jest-globals.md)         | Prefer importing Jest globals                                             |     |     | 🔧  |     |
+| [prefer-jest-mocked](docs/rules/prefer-jest-mocked.md)                               | Prefer `jest.mocked()` over `fn as jest.Mock`                             |     |     | 🔧  |     |
+| [prefer-lowercase-title](docs/rules/prefer-lowercase-title.md)                       | Enforce lowercase test names                                              |     |     | 🔧  |     |
+| [prefer-mock-promise-shorthand](docs/rules/prefer-mock-promise-shorthand.md)         | Prefer mock resolved/rejected shorthands for promises                     |     |     | 🔧  |     |
+| [prefer-snapshot-hint](docs/rules/prefer-snapshot-hint.md)                           | Prefer including a hint with external snapshots                           |     |     |     |     |
+| [prefer-spy-on](docs/rules/prefer-spy-on.md)                                         | Suggest using `jest.spyOn()`                                              |     |     | 🔧  |     |
+| [prefer-strict-equal](docs/rules/prefer-strict-equal.md)                             | Suggest using `toStrictEqual()`                                           |     |     |     | 💡  |
+| [prefer-to-be](docs/rules/prefer-to-be.md)                                           | Suggest using `toBe()` for primitive literals                             | 🎨  |     | 🔧  |     |
+| [prefer-to-contain](docs/rules/prefer-to-contain.md)                                 | Suggest using `toContain()`                                               | 🎨  |     | 🔧  |     |
+| [prefer-to-have-length](docs/rules/prefer-to-have-length.md)                         | Suggest using `toHaveLength()`                                            | 🎨  |     | 🔧  |     |
+| [prefer-todo](docs/rules/prefer-todo.md)                                             | Suggest using `test.todo`                                                 |     |     | 🔧  |     |
+| [require-hook](docs/rules/require-hook.md)                                           | Require setup and teardown code to be within a hook                       |     |     |     |     |
+| [require-to-throw-message](docs/rules/require-to-throw-message.md)                   | Require a message for `toThrow()`                                         |     |     |     |     |
+| [require-top-level-describe](docs/rules/require-top-level-describe.md)               | Require test cases and hooks to be inside a `describe` block              |     |     |     |     |
+| [valid-describe-callback](docs/rules/valid-describe-callback.md)                     | Enforce valid `describe()` callback                                       | ✅  |     |     |     |
+| [valid-expect](docs/rules/valid-expect.md)                                           | Enforce valid `expect()` usage                                            | ✅  |     | 🔧  |     |
+| [valid-expect-in-promise](docs/rules/valid-expect-in-promise.md)                     | Require promises that have expectations in their chain to be valid        | ✅  |     |     |     |
+| [valid-title](docs/rules/valid-title.md)                                             | Enforce valid titles                                                      | ✅  |     | 🔧  |     |
 
 ### Requires Type Checking
 

package/docs/rules/padding-around-after-all-blocks.md

@@ -0,0 +1,32 @@
+# Enforce padding around `afterAll` blocks (`padding-around-after-all-blocks`)
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+## Rule Details
+
+This rule enforces a line of padding before _and_ after 1 or more `afterAll`
+statements.
+
+Note that it doesn't add/enforce a padding line if it's the last statement in
+its scope.
+
+Examples of **incorrect** code for this rule:
+
+```js
+const someText = 'abc';
+afterAll(() => {});
+describe('someText', () => {});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+const someText = 'abc';
+
+afterAll(() => {});
+
+describe('someText', () => {});
+```

package/docs/rules/padding-around-after-each-blocks.md

@@ -0,0 +1,36 @@
+# Enforce padding around `afterEach` blocks (`padding-around-after-each-blocks`)
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+## Rule Details
+
+This rule enforces a line of padding before _and_ after 1 or more `afterEach`
+statements.
+
+Note that it doesn't add/enforce a padding line if it's the last statement in
+its scope.
+
+Examples of **incorrect** code for this rule:
+
+```js
+const something = 123;
+afterEach(() => {
+  // more stuff
+});
+describe('foo', () => {});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+const something = 123;
+
+afterEach(() => {
+  // more stuff
+});
+
+describe('foo', () => {});
+```

package/docs/rules/padding-around-all.md

@@ -0,0 +1,18 @@
+# Enforce padding around Jest functions (`padding-around-all`)
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+## Rule Details
+
+This is a meta rule that simply enables all of the following rules:
+
+- [padding-around-after-all-blocks](padding-around-after-all-blocks.md)
+- [padding-around-after-each-blocks](padding-around-after-each-blocks.md)
+- [padding-around-before-all-blocks](padding-around-before-all-blocks.md)
+- [padding-around-before-each-blocks](padding-around-before-each-blocks.md)
+- [padding-around-expect-groups](padding-around-expect-groups.md)
+- [padding-around-describe-blocks](padding-around-describe-blocks.md)
+- [padding-around-test-blocks](padding-around-test-blocks.md)

package/docs/rules/padding-around-before-all-blocks.md

@@ -0,0 +1,35 @@
+# Enforce padding around `beforeAll` blocks (`padding-around-before-all-blocks`)
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+## Rule Details
+
+This rule enforces a line of padding before _and_ after `beforeAll` statements.
+
+Note that it doesn't add/enforce a padding line if it's the last statement in
+its scope.
+
+Examples of **incorrect** code for this rule:
+
+```js
+const something = 123;
+beforeAll(() => {
+  // more stuff
+});
+describe('foo', () => {});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+const something = 123;
+
+beforeAll(() => {
+  // more stuff
+});
+
+describe('foo', () => {});
+```

package/docs/rules/padding-around-before-each-blocks.md

@@ -0,0 +1,36 @@
+# Enforce padding around `beforeEach` blocks (`padding-around-before-each-blocks`)
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+## Rule Details
+
+This rule enforces a line of padding before _and_ after 1 or more `beforeEach`
+statements
+
+Note that it doesn't add/enforce a padding line if it's the last statement in
+its scope
+
+Examples of **incorrect** code for this rule:
+
+```js
+const something = 123;
+beforeEach(() => {
+  // more stuff
+});
+describe('foo', () => {});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+const something = 123;
+
+beforeEach(() => {
+  // more stuff
+});
+
+describe('foo', () => {});
+```

package/docs/rules/padding-around-describe-blocks.md

@@ -0,0 +1,40 @@
+# Enforce padding around `describe` blocks (`padding-around-describe-blocks`)
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+## Rule Details
+
+This rule enforces a line of padding before _and_ after 1 or more `describe`
+statements
+
+Note that it doesn't add/enforce a padding line if it's the last statement in
+its scope
+
+Examples of **incorrect** code for this rule:
+
+```js
+const thing = 123;
+describe('foo', () => {
+  // stuff
+});
+describe('bar', () => {
+  // more stuff
+});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+const thing = 123;
+
+describe('foo', () => {
+  // stuff
+});
+
+describe('bar', () => {
+  // more stuff
+});
+```

package/docs/rules/padding-around-expect-groups.md

@@ -0,0 +1,42 @@
+# Enforce padding around `expect` groups (`padding-around-expect-groups`)
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+## Rule Details
+
+This rule enforces a line of padding before _and_ after 1 or more `expect`
+statements
+
+Note that it doesn't add/enforce a padding line if it's the last statement in
+its scope and it doesn't add/enforce padding between two or more adjacent
+`expect` statements.
+
+Examples of **incorrect** code for this rule:
+
+```js
+test('thing one', () => {
+  let abc = 123;
+  expect(abc).toEqual(123);
+  expect(123).toEqual(abc);
+  abc = 456;
+  expect(abc).toEqual(456);
+});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+test('thing one', () => {
+  let abc = 123;
+
+  expect(abc).toEqual(123);
+  expect(123).toEqual(abc);
+
+  abc = 456;
+
+  expect(abc).toEqual(456);
+});
+```

package/docs/rules/padding-around-test-blocks.md

@@ -0,0 +1,46 @@
+# Enforce padding around afterAll blocks (`padding-around-test-blocks`)
+
+🔧 This rule is automatically fixable by the
+[`--fix` CLI option](https://eslint.org/docs/latest/user-guide/command-line-interface#--fix).
+
+<!-- end auto-generated rule header -->
+
+## Rule Details
+
+This rule enforces a line of padding before _and_ after 1 or more `test`/`it`
+statements
+
+Note that it doesn't add/enforce a padding line if it's the last statement in
+its scope
+
+Examples of **incorrect** code for this rule:
+
+```js
+const thing = 123;
+test('foo', () => {});
+test('bar', () => {});
+```
+
+```js
+const thing = 123;
+it('foo', () => {});
+it('bar', () => {});
+```
+
+Examples of **correct** code for this rule:
+
+```js
+const thing = 123;
+
+test('foo', () => {});
+
+test('bar', () => {});
+```
+
+```js
+const thing = 123;
+
+it('foo', () => {});
+
+it('bar', () => {});
+```

package/lib/rules/padding-around-after-all-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: _padding.StatementType.AfterAllToken
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.AfterAllToken,
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `afterAll` blocks', config);

package/lib/rules/padding-around-after-each-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: _padding.StatementType.AfterEachToken
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.AfterEachToken,
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `afterEach` blocks', config);

package/lib/rules/padding-around-all.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _paddingAroundAfterAllBlocks = require("./padding-around-after-all-blocks");
+var _paddingAroundAfterEachBlocks = require("./padding-around-after-each-blocks");
+var _paddingAroundBeforeAllBlocks = require("./padding-around-before-all-blocks");
+var _paddingAroundBeforeEachBlocks = require("./padding-around-before-each-blocks");
+var _paddingAroundDescribeBlocks = require("./padding-around-describe-blocks");
+var _paddingAroundExpectGroups = require("./padding-around-expect-groups");
+var _paddingAroundTestBlocks = require("./padding-around-test-blocks");
+var _padding = require("./utils/padding");
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around Jest functions', [..._paddingAroundAfterAllBlocks.config, ..._paddingAroundAfterEachBlocks.config, ..._paddingAroundBeforeAllBlocks.config, ..._paddingAroundBeforeEachBlocks.config, ..._paddingAroundDescribeBlocks.config, ..._paddingAroundExpectGroups.config, ..._paddingAroundTestBlocks.config]);

package/lib/rules/padding-around-before-all-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: _padding.StatementType.BeforeAllToken
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.BeforeAllToken,
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `beforeAll` blocks', config);

package/lib/rules/padding-around-before-each-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: _padding.StatementType.BeforeEachToken
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.BeforeEachToken,
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `beforeEach` blocks', config);

package/lib/rules/padding-around-describe-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: [_padding.StatementType.DescribeToken, _padding.StatementType.FdescribeToken, _padding.StatementType.XdescribeToken]
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: [_padding.StatementType.DescribeToken, _padding.StatementType.FdescribeToken, _padding.StatementType.XdescribeToken],
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `describe` blocks', config);

package/lib/rules/padding-around-expect-groups.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: _padding.StatementType.ExpectToken
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.ExpectToken,
+  nextStatementType: _padding.StatementType.Any
+}, {
+  paddingType: _padding.PaddingType.Any,
+  prevStatementType: _padding.StatementType.ExpectToken,
+  nextStatementType: _padding.StatementType.ExpectToken
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around `expect` groups', config);

package/lib/rules/padding-around-test-blocks.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.config = void 0;
+var _padding = require("./utils/padding");
+const config = exports.config = [{
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: _padding.StatementType.Any,
+  nextStatementType: [_padding.StatementType.TestToken, _padding.StatementType.ItToken, _padding.StatementType.FitToken, _padding.StatementType.XitToken, _padding.StatementType.XtestToken]
+}, {
+  paddingType: _padding.PaddingType.Always,
+  prevStatementType: [_padding.StatementType.TestToken, _padding.StatementType.ItToken, _padding.StatementType.FitToken, _padding.StatementType.XitToken, _padding.StatementType.XtestToken],
+  nextStatementType: _padding.StatementType.Any
+}];
+var _default = exports.default = (0, _padding.createPaddingRule)(__filename, 'Enforce padding around afterAll blocks', config);

package/lib/rules/prefer-jest-mocked.js

@@ -44,7 +44,7 @@ var _default = exports.default = (0, _utils2.createRule)({
       }
       const fnName = (0, _utils2.getSourceCode)(context).text.slice(...(0, _utils2.followTypeAssertionChain)(node.expression).range);
       context.report({
-        node: node,
+        node,
         messageId: 'useJestMocked',
         fix(fixer) {
           return fixer.replaceText(node, `jest.mocked(${fnName})`);

package/lib/rules/utils/ast-utils.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isValidParent = exports.isTokenASemicolon = exports.getPaddingLineSequences = exports.getActualLastToken = exports.areTokensOnSameLine = void 0;
+var _utils = require("@typescript-eslint/utils");
+const isTokenASemicolon = token => token.value === ';' && token.type === _utils.AST_TOKEN_TYPES.Punctuator;
+exports.isTokenASemicolon = isTokenASemicolon;
+const areTokensOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
+
+// We'll only verify nodes with these parent types
+exports.areTokensOnSameLine = areTokensOnSameLine;
+const STATEMENT_LIST_PARENTS = new Set([_utils.AST_NODE_TYPES.Program, _utils.AST_NODE_TYPES.BlockStatement, _utils.AST_NODE_TYPES.SwitchCase, _utils.AST_NODE_TYPES.SwitchStatement]);
+const isValidParent = parentType => {
+  return STATEMENT_LIST_PARENTS.has(parentType);
+};
+
+/**
+ * Gets the actual last token.
+ *
+ * If a semicolon is semicolon-less style's semicolon, this ignores it.
+ * For example:
+ *
+ *     foo()
+ *     ;[1, 2, 3].forEach(bar)
+ */
+exports.isValidParent = isValidParent;
+const getActualLastToken = (sourceCode, node) => {
+  const semiToken = sourceCode.getLastToken(node);
+  const prevToken = sourceCode.getTokenBefore(semiToken);
+  const nextToken = sourceCode.getTokenAfter(semiToken);
+  const isSemicolonLessStyle = Boolean(prevToken && nextToken && prevToken.range[0] >= node.range[0] && isTokenASemicolon(semiToken) && semiToken.loc.start.line !== prevToken.loc.end.line && semiToken.loc.end.line === nextToken.loc.start.line);
+  return isSemicolonLessStyle ? prevToken : semiToken;
+};
+
+/**
+ * Gets padding line sequences between the given 2 statements.
+ * Comments are separators of the padding line sequences.
+ */
+exports.getActualLastToken = getActualLastToken;
+const getPaddingLineSequences = (prevNode, nextNode, sourceCode) => {
+  const pairs = [];
+  const includeComments = true;
+  let prevToken = getActualLastToken(sourceCode, prevNode);
+  if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) {
+    do {
+      const token = sourceCode.getTokenAfter(prevToken, {
+        includeComments
+      });
+      if (token.loc.start.line - prevToken.loc.end.line >= 2) {
+        pairs.push([prevToken, token]);
+      }
+      prevToken = token;
+    } while (prevToken.range[0] < nextNode.range[0]);
+  }
+  return pairs;
+};
+exports.getPaddingLineSequences = getPaddingLineSequences;

package/lib/rules/utils/padding.js

@@ -0,0 +1,308 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPaddingRule = exports.StatementType = exports.PaddingType = void 0;
+var _utils = require("@typescript-eslint/utils");
+var astUtils = _interopRequireWildcard(require("./ast-utils"));
+var _misc = require("./misc");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Require/fix newlines around jest functions
+ *
+ * Based on eslint/padding-line-between-statements by Toru Nagashima
+ * See: https://github.com/eslint/eslint/blob/master/lib/rules/padding-line-between-statements.js
+ *
+ * Some helpers borrowed from eslint ast-utils by Gyandeep Singh
+ * See: https://github.com/eslint/eslint/blob/master/lib/rules/utils/ast-utils.js
+ */
+// Statement types we'll respond to
+let StatementType = exports.StatementType = /*#__PURE__*/function (StatementType) {
+  StatementType[StatementType["Any"] = 0] = "Any";
+  StatementType[StatementType["AfterAllToken"] = 1] = "AfterAllToken";
+  StatementType[StatementType["AfterEachToken"] = 2] = "AfterEachToken";
+  StatementType[StatementType["BeforeAllToken"] = 3] = "BeforeAllToken";
+  StatementType[StatementType["BeforeEachToken"] = 4] = "BeforeEachToken";
+  StatementType[StatementType["DescribeToken"] = 5] = "DescribeToken";
+  StatementType[StatementType["ExpectToken"] = 6] = "ExpectToken";
+  StatementType[StatementType["FdescribeToken"] = 7] = "FdescribeToken";
+  StatementType[StatementType["FitToken"] = 8] = "FitToken";
+  StatementType[StatementType["ItToken"] = 9] = "ItToken";
+  StatementType[StatementType["TestToken"] = 10] = "TestToken";
+  StatementType[StatementType["XdescribeToken"] = 11] = "XdescribeToken";
+  StatementType[StatementType["XitToken"] = 12] = "XitToken";
+  StatementType[StatementType["XtestToken"] = 13] = "XtestToken";
+  return StatementType;
+}({});
+// Padding type to apply between statements
+let PaddingType = exports.PaddingType = /*#__PURE__*/function (PaddingType) {
+  PaddingType[PaddingType["Any"] = 0] = "Any";
+  PaddingType[PaddingType["Always"] = 1] = "Always";
+  return PaddingType;
+}({}); // A configuration object for padding type and the two statement types
+// Tracks position in scope and prevNode. Used to compare current and prev node
+// and then to walk back up to the parent scope or down into the next one.
+// And so on...
+// Creates a StatementTester to test an ExpressionStatement's first token name
+const createTokenTester = tokenName => {
+  return (node, sourceCode) => {
+    let activeNode = node;
+    if (activeNode.type === _utils.AST_NODE_TYPES.ExpressionStatement) {
+      // In the case of `await`, we actually care about its argument
+      if (activeNode.expression.type === _utils.AST_NODE_TYPES.AwaitExpression) {
+        activeNode = activeNode.expression.argument;
+      }
+      const token = sourceCode.getFirstToken(activeNode);
+      return token?.type === _utils.AST_TOKEN_TYPES.Identifier && token.value === tokenName;
+    }
+    return false;
+  };
+};
+
+// A mapping of StatementType to StatementTester for... testing statements
+const statementTesters = {
+  [StatementType.Any]: () => true,
+  [StatementType.AfterAllToken]: createTokenTester('afterAll'),
+  [StatementType.AfterEachToken]: createTokenTester('afterEach'),
+  [StatementType.BeforeAllToken]: createTokenTester('beforeAll'),
+  [StatementType.BeforeEachToken]: createTokenTester('beforeEach'),
+  [StatementType.DescribeToken]: createTokenTester('describe'),
+  [StatementType.ExpectToken]: createTokenTester('expect'),
+  [StatementType.FdescribeToken]: createTokenTester('fdescribe'),
+  [StatementType.FitToken]: createTokenTester('fit'),
+  [StatementType.ItToken]: createTokenTester('it'),
+  [StatementType.TestToken]: createTokenTester('test'),
+  [StatementType.XdescribeToken]: createTokenTester('xdescribe'),
+  [StatementType.XitToken]: createTokenTester('xit'),
+  [StatementType.XtestToken]: createTokenTester('xtest')
+};
+
+/**
+ * Check and report statements for `PaddingType.Always` configuration.
+ * This autofix inserts a blank line between the given 2 statements.
+ * If the `prevNode` has trailing comments, it inserts a blank line after the
+ * trailing comments.
+ */
+const paddingAlwaysTester = (prevNode, nextNode, paddingContext) => {
+  const {
+    sourceCode,
+    ruleContext
+  } = paddingContext;
+  const paddingLines = astUtils.getPaddingLineSequences(prevNode, nextNode, sourceCode);
+
+  // We've got some padding lines. Great.
+  if (paddingLines.length > 0) {
+    return;
+  }
+
+  // Missing padding line
+  ruleContext.report({
+    node: nextNode,
+    messageId: 'missingPadding',
+    fix(fixer) {
+      let prevToken = astUtils.getActualLastToken(sourceCode, prevNode);
+      const nextToken = sourceCode.getFirstTokenBetween(prevToken, nextNode, {
+        includeComments: true,
+        /**
+         * Skip the trailing comments of the previous node.
+         * This inserts a blank line after the last trailing comment.
+         *
+         * For example:
+         *
+         *     foo(); // trailing comment.
+         *     // comment.
+         *     bar();
+         *
+         * Get fixed to:
+         *
+         *     foo(); // trailing comment.
+         *
+         *     // comment.
+         *     bar();
+         */
+        filter(token) {
+          if (astUtils.areTokensOnSameLine(prevToken, token)) {
+            prevToken = token;
+            return false;
+          }
+          return true;
+        }
+      }) || nextNode;
+      const insertText = astUtils.areTokensOnSameLine(prevToken, nextToken) ? '\n\n' : '\n';
+      return fixer.insertTextAfter(prevToken, insertText);
+    }
+  });
+};
+
+// A mapping of PaddingType to PaddingTester
+const paddingTesters = {
+  [PaddingType.Any]: () => true,
+  [PaddingType.Always]: paddingAlwaysTester
+};
+const createScopeInfo = () => {
+  let scope = null;
+
+  // todo: explore seeing if we can refactor to a more TypeScript friendly structure
+  return {
+    get prevNode() {
+      return scope.prevNode;
+    },
+    set prevNode(node) {
+      scope.prevNode = node;
+    },
+    enter() {
+      scope = {
+        upper: scope,
+        prevNode: null
+      };
+    },
+    exit() {
+      scope = scope.upper;
+    }
+  };
+};
+
+/**
+ * Check whether the given node matches the statement type
+ */
+const nodeMatchesType = (node, statementType, paddingContext) => {
+  let innerStatementNode = node;
+  const {
+    sourceCode
+  } = paddingContext;
+
+  // Dig into LabeledStatement body until it's not that anymore
+  while (innerStatementNode.type === _utils.AST_NODE_TYPES.LabeledStatement) {
+    innerStatementNode = innerStatementNode.body;
+  }
+
+  // If it's an array recursively check if any of the statement types match
+  // the node
+  if (Array.isArray(statementType)) {
+    return statementType.some(type => nodeMatchesType(innerStatementNode, type, paddingContext));
+  }
+  return statementTesters[statementType](innerStatementNode, sourceCode);
+};
+
+/**
+ * Executes matching padding tester for last matched padding config for given
+ * nodes
+ */
+const testPadding = (prevNode, nextNode, paddingContext) => {
+  const {
+    configs
+  } = paddingContext;
+  const testType = type => paddingTesters[type](prevNode, nextNode, paddingContext);
+  for (let i = configs.length - 1; i >= 0; --i) {
+    const {
+      prevStatementType: prevType,
+      nextStatementType: nextType,
+      paddingType
+    } = configs[i];
+    if (nodeMatchesType(prevNode, prevType, paddingContext) && nodeMatchesType(nextNode, nextType, paddingContext)) {
+      return testType(paddingType);
+    }
+  }
+
+  // There were no matching padding rules for the prevNode, nextNode,
+  // paddingType combination... so we'll use PaddingType.Any which is always ok
+  return testType(PaddingType.Any);
+};
+
+/**
+ * Verify padding lines between the given node and the previous node.
+ */
+const verifyNode = (node, paddingContext) => {
+  const {
+    scopeInfo
+  } = paddingContext;
+
+  // NOTE: ESLint types use ESTree which provides a Node type, however
+  //  ESTree.Node doesn't support the parent property which is added by
+  //  ESLint during traversal. Our best bet is to ignore the property access
+  //  here as it's the only place that it's checked.
+
+  if (!astUtils.isValidParent(node.parent.type)) {
+    return;
+  }
+  if (scopeInfo.prevNode) {
+    testPadding(scopeInfo.prevNode, node, paddingContext);
+  }
+  scopeInfo.prevNode = node;
+};
+
+/**
+ * Creates an ESLint rule for a given set of padding Config objects.
+ *
+ * The algorithm is approximately this:
+ *
+ * For each 'scope' in the program
+ * - Enter the scope (store the parent scope and previous node)
+ * - For each statement in the scope
+ *   - Check the current node and previous node against the Config objects
+ *   - If the current node and previous node match a Config, check the padding.
+ *     Otherwise, ignore it.
+ *   - If the padding is missing (and required), report and fix
+ *   - Store the current node as the previous
+ *   - Repeat
+ * - Exit scope (return to parent scope and clear previous node)
+ *
+ * The items we're looking for with this rule are ExpressionStatement nodes
+ * where the first token is an Identifier with a name matching one of the Jest
+ * functions. It's not foolproof, of course, but it's probably good enough for
+ * almost all cases.
+ *
+ * The Config objects specify a padding type, a previous statement type, and a
+ * next statement type. Wildcard statement types and padding types are
+ * supported. The current node and previous node are checked against the
+ * statement types. If they match then the specified padding type is
+ * tested/enforced.
+ *
+ * See src/index.ts for examples of Config usage.
+ */
+const createPaddingRule = (name, description, configs, deprecated = false) => {
+  return (0, _misc.createRule)({
+    name,
+    meta: {
+      docs: {
+        description
+      },
+      fixable: 'whitespace',
+      deprecated,
+      messages: {
+        missingPadding: 'Expected blank line before this statement.'
+      },
+      schema: [],
+      type: 'suggestion'
+    },
+    defaultOptions: [],
+    create(context) {
+      const paddingContext = {
+        ruleContext: context,
+        sourceCode: (0, _misc.getSourceCode)(context),
+        scopeInfo: createScopeInfo(),
+        configs
+      };
+      const {
+        scopeInfo
+      } = paddingContext;
+      return {
+        Program: scopeInfo.enter,
+        'Program:exit': scopeInfo.enter,
+        BlockStatement: scopeInfo.enter,
+        'BlockStatement:exit': scopeInfo.exit,
+        SwitchStatement: scopeInfo.enter,
+        'SwitchStatement:exit': scopeInfo.exit,
+        ':statement': node => verifyNode(node, paddingContext),
+        SwitchCase(node) {
+          verifyNode(node, paddingContext);
+          scopeInfo.enter();
+        },
+        'SwitchCase:exit': scopeInfo.exit
+      };
+    }
+  });
+};
+exports.createPaddingRule = createPaddingRule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "28.6.0",
+  "version": "28.8.0",
   "description": "ESLint rules for Jest",
   "keywords": [
     "eslint",
@@ -58,7 +58,7 @@
     ]
   },
   "dependencies": {
-    "@typescript-eslint/utils": "^6.0.0 || ^7.0.0"
+    "@typescript-eslint/utils": "^6.0.0 || ^7.0.0 || ^8.0.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.4.4",
@@ -67,6 +67,7 @@
     "@babel/preset-typescript": "^7.3.3",
     "@commitlint/cli": "^17.0.3",
     "@commitlint/config-conventional": "^17.0.3",
+    "@eslint-community/eslint-plugin-eslint-comments": "^4.3.0",
     "@schemastore/package": "^0.0.10",
     "@semantic-release/changelog": "^6.0.0",
     "@semantic-release/git": "^10.0.0",
@@ -83,7 +84,6 @@
     "eslint": "^7.0.0 || ^8.0.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-doc-generator": "^1.0.0",
-    "eslint-plugin-eslint-comments": "^3.1.2",
     "eslint-plugin-eslint-plugin": "^6.0.0",
     "eslint-plugin-import": "^2.25.1",
     "eslint-plugin-n": "^17.0.0",
@@ -106,7 +106,7 @@
     "typescript": "^5.0.4"
   },
   "peerDependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.0.0 || ^7.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0 || ^7.0.0 || ^8.0.0",
     "eslint": "^7.0.0 || ^8.0.0 || ^9.0.0",
     "jest": "*"
   },
@@ -118,7 +118,7 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@3.8.2",
+  "packageManager": "yarn@3.8.4",
   "engines": {
     "node": "^16.10.0 || ^18.12.0 || >=20.0.0"
   },