eslint-plugin-jest-formatting 3.0.0 → 4.0.0

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

@@ -1,29 +1,83 @@
 # padding-around-before-each-blocks
 
-## Rule Details
+- **Rule ID:** `jest-formatting/padding-around-before-each-blocks`
+- **Presets:** `recommended`; covered by `padding-around-all` in `strict`
+- **Fixable:** yes, `eslint --fix` inserts the missing blank lines
+- **Options:** none
+- **Message IDs:** `missingPaddingBefore`, `missingPaddingAfter`
 
-This rule enforces a line of padding before _and_ after 1 or more `beforeEach` statements
+## Rule summary
 
-Note that it doesn't add/enforce a padding line if it's the last statement in its scope
+Require a blank line before and after every `beforeEach` call.
 
-Examples of **incorrect** code for this rule:
+- Matches every statement that starts with the identifier `beforeEach`.
+- Only neighbouring statements in the same block are compared: the top level of the file, a `{ ... }` block such as a callback body, or a `switch` case. The first statement in a block needs no blank line before it, and the last needs none after it.
+- One blank line is enough; extra blank lines are never reported.
+- Two consecutive `beforeEach` calls also need a blank line between them.
+- A comment on its own line is not a blank line, but a blank line on either side of a comment satisfies the rule.
+
+## Why
+
+`beforeEach` resets state before every test in its scope. A blank line on each side marks it as shared per-test setup rather than part of a specific test, which is the first thing a reader needs when working out why a test sees the state it does.
+
+## Incorrect examples
 
 ```js
-const something = 123;
+/* eslint jest-formatting/padding-around-before-each-blocks: "error" */
+let counter;
 beforeEach(() => {
-  // more stuff
+  counter = 0;
+});
+test('starts at zero', () => {
+  expect(counter).toBe(0);
 });
-describe('foo', () => {});
 ```
 
-Examples of **correct** code for this rule:
+ESLint reports:
+
+```text
+3:1  error  Missing blank line before `beforeEach`. Expected at least one blank line between the previous statement and this `beforeEach` call. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).  jest-formatting/padding-around-before-each-blocks
+6:1  error  Missing blank line after `beforeEach`. Expected at least one blank line between the `beforeEach` call above and this statement. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).  jest-formatting/padding-around-before-each-blocks
+```
+
+## Correct examples
 
 ```js
-const something = 123;
+/* eslint jest-formatting/padding-around-before-each-blocks: "error" */
+let counter;
 
 beforeEach(() => {
-  // more stuff
+  counter = 0;
+});
+
+test('starts at zero', () => {
+  expect(counter).toBe(0);
 });
+```
+
+## Options
+
+This rule has no options; configure only the severity. Passing options makes ESLint reject the configuration, because the rule's schema is empty.
+
+```js
+// eslint.config.js (flat); the same `rules` entry works in a legacy .eslintrc
+import jestFormatting from 'eslint-plugin-jest-formatting';
 
-describe('foo', () => {});
+export default [
+  {
+    plugins: { 'jest-formatting': jestFormatting },
+    rules: {
+      'jest-formatting/padding-around-before-each-blocks': 'error',
+    },
+  },
+];
 ```
+
+## Fixability
+
+Fixable (`meta.fixable` is `"whitespace"`). `eslint --fix` resolves every report from this rule by inserting a newline after the last token of the statement before the gap, after any comment that trails on the same line, so that a blank line separates the two statements. The fix only adds whitespace; it never removes, moves, or reformats code.
+
+Both messages are reported on the statement that should have a blank line above it. `{{token}}` is the identifier that matched, for example `beforeEach`.
+
+- `missingPaddingBefore`, reported on the `beforeEach` call: Missing blank line before `{{token}}`. Expected at least one blank line between the previous statement and this `{{token}}` call. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).
+- `missingPaddingAfter`, reported on the statement after the `beforeEach` call: Missing blank line after `{{token}}`. Expected at least one blank line between the `{{token}}` call above and this statement. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).

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

@@ -1,14 +1,29 @@
 # padding-around-describe-blocks
 
-## Rule Details
+- **Rule ID:** `jest-formatting/padding-around-describe-blocks`
+- **Presets:** `recommended`; covered by `padding-around-all` in `strict`
+- **Fixable:** yes, `eslint --fix` inserts the missing blank lines
+- **Options:** none
+- **Message IDs:** `missingPaddingBefore`, `missingPaddingAfter`
 
-This rule enforces a line of padding before _and_ after 1 or more `beforeEach` statements
+## Rule summary
 
-Note that it doesn't add/enforce a padding line if it's the last statement in its scope
+Require a blank line before and after every `describe` block, including `fdescribe` and `xdescribe`.
 
-Examples of **incorrect** code for this rule:
+- Matches every statement that starts with `describe`, `fdescribe`, or `xdescribe`, including `describe.each(...)`, `describe.only(...)`, and `describe.skip(...)`.
+- Only neighbouring statements in the same block are compared: the top level of the file, a `{ ... }` block such as a callback body, or a `switch` case. The first statement in a block needs no blank line before it, and the last needs none after it.
+- One blank line is enough; extra blank lines are never reported.
+- Consecutive `describe` blocks need a blank line between them.
+- A comment on its own line is not a blank line, but a blank line on either side of a comment satisfies the rule.
+
+## Why
+
+`describe` blocks are the outline of a test file. Blank lines around them, and between consecutive blocks, make that outline visible while scrolling, so the boundaries between groups of tests are clear without reading closing braces or indentation.
+
+## Incorrect examples
 
 ```js
+/* eslint jest-formatting/padding-around-describe-blocks: "error" */
 const thing = 123;
 describe('foo', () => {
   // stuff
@@ -18,9 +33,17 @@ describe('bar', () => {
 });
 ```
 
-Examples of **correct** code for this rule:
+ESLint reports:
+
+```text
+3:1  error  Missing blank line before `describe`. Expected at least one blank line between the previous statement and this `describe` call. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).  jest-formatting/padding-around-describe-blocks
+6:1  error  Missing blank line after `describe`. Expected at least one blank line between the `describe` call above and this statement. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).  jest-formatting/padding-around-describe-blocks
+```
+
+## Correct examples
 
 ```js
+/* eslint jest-formatting/padding-around-describe-blocks: "error" */
 const thing = 123;
 
 describe('foo', () => {
@@ -31,3 +54,39 @@ describe('bar', () => {
   // more stuff
 });
 ```
+
+```js
+/* eslint jest-formatting/padding-around-describe-blocks: "error" */
+describe('outer', () => {
+  describe('first', () => {});
+
+  describe.each([1, 2])('case %i', () => {});
+});
+```
+
+## Options
+
+This rule has no options; configure only the severity. Passing options makes ESLint reject the configuration, because the rule's schema is empty.
+
+```js
+// eslint.config.js (flat); the same `rules` entry works in a legacy .eslintrc
+import jestFormatting from 'eslint-plugin-jest-formatting';
+
+export default [
+  {
+    plugins: { 'jest-formatting': jestFormatting },
+    rules: {
+      'jest-formatting/padding-around-describe-blocks': 'error',
+    },
+  },
+];
+```
+
+## Fixability
+
+Fixable (`meta.fixable` is `"whitespace"`). `eslint --fix` resolves every report from this rule by inserting a newline after the last token of the statement before the gap, after any comment that trails on the same line, so that a blank line separates the two statements. The fix only adds whitespace; it never removes, moves, or reformats code.
+
+Both messages are reported on the statement that should have a blank line above it. `{{token}}` is the identifier that matched, for example `xdescribe`.
+
+- `missingPaddingBefore`, reported on the `describe` call: Missing blank line before `{{token}}`. Expected at least one blank line between the previous statement and this `{{token}}` call. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).
+- `missingPaddingAfter`, reported on the statement after the `describe` call: Missing blank line after `{{token}}`. Expected at least one blank line between the `{{token}}` call above and this statement. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).

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

@@ -1,15 +1,29 @@
 # padding-around-expect-groups
 
-## Rule Details
+- **Rule ID:** `jest-formatting/padding-around-expect-groups`
+- **Presets:** not in `recommended`; covered by `padding-around-all` in `strict`
+- **Fixable:** yes, `eslint --fix` inserts the missing blank lines
+- **Options:** none
+- **Message IDs:** `missingPaddingBefore`, `missingPaddingAfter`
 
-This rule enforces a line of padding before _and_ after 1 or more `expect` statements
+## Rule summary
 
-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.
+Require a blank line before and after every group of consecutive `expect` statements, with no blank line required inside the group.
 
-Examples of **incorrect** code for this rule:
+- Matches every statement that starts with `expect`, including `await expect(...)`, `expect.assertions(...)`, and `expect.hasAssertions()`. A `return expect(...)` is a return statement and is not matched.
+- Only neighbouring statements in the same block are compared: the top level of the file, a `{ ... }` block such as a callback body, or a `switch` case. The first statement in a block needs no blank line before it, and the last needs none after it.
+- One blank line is enough; extra blank lines are never reported.
+- Consecutive `expect` statements form one group and need no blank line between them; the group as a whole needs a blank line before it and after it.
+- A comment on its own line is not a blank line, but a blank line on either side of a comment satisfies the rule.
+
+## Why
+
+Tests read best in arrange, act, assert order. Separating each run of assertions from the code that set up and produced the values makes it obvious which `expect` calls belong to which action, while keeping assertions about the same result together as one group.
+
+## Incorrect examples
 
 ```js
+/* eslint jest-formatting/padding-around-expect-groups: "error" */
 test('thing one', () => {
   let abc = 123;
   expect(abc).toEqual(123);
@@ -19,9 +33,18 @@ test('thing one', () => {
 });
 ```
 
-Examples of **correct** code for this rule:
+ESLint reports:
+
+```text
+4:3  error  Missing blank line before `expect`. Expected at least one blank line between the previous statement and this `expect` call. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).  jest-formatting/padding-around-expect-groups
+6:3  error  Missing blank line after `expect`. Expected at least one blank line between the `expect` call above and this statement. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).  jest-formatting/padding-around-expect-groups
+7:3  error  Missing blank line before `expect`. Expected at least one blank line between the previous statement and this `expect` call. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).  jest-formatting/padding-around-expect-groups
+```
+
+## Correct examples
 
 ```js
+/* eslint jest-formatting/padding-around-expect-groups: "error" */
 test('thing one', () => {
   let abc = 123;
 
@@ -33,3 +56,38 @@ test('thing one', () => {
   expect(abc).toEqual(456);
 });
 ```
+
+```js
+/* eslint jest-formatting/padding-around-expect-groups: "error" */
+test('resolves', async () => {
+  await expect(fetchUser(1)).resolves.toEqual({ id: 1 });
+  expect(cache.size).toBe(1);
+});
+```
+
+## Options
+
+This rule has no options; configure only the severity. Passing options makes ESLint reject the configuration, because the rule's schema is empty.
+
+```js
+// eslint.config.js (flat); the same `rules` entry works in a legacy .eslintrc
+import jestFormatting from 'eslint-plugin-jest-formatting';
+
+export default [
+  {
+    plugins: { 'jest-formatting': jestFormatting },
+    rules: {
+      'jest-formatting/padding-around-expect-groups': 'error',
+    },
+  },
+];
+```
+
+## Fixability
+
+Fixable (`meta.fixable` is `"whitespace"`). `eslint --fix` resolves every report from this rule by inserting a newline after the last token of the statement before the gap, after any comment that trails on the same line, so that a blank line separates the two statements. The fix only adds whitespace; it never removes, moves, or reformats code.
+
+Both messages are reported on the statement that should have a blank line above it. `{{token}}` is the identifier that matched, for example `expect`.
+
+- `missingPaddingBefore`, reported on the `expect` call: Missing blank line before `{{token}}`. Expected at least one blank line between the previous statement and this `{{token}}` call. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).
+- `missingPaddingAfter`, reported on the statement after the `expect` call: Missing blank line after `{{token}}`. Expected at least one blank line between the `{{token}}` call above and this statement. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).

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

@@ -1,39 +1,102 @@
 # padding-around-test-blocks
 
-## Rule Details
+- **Rule ID:** `jest-formatting/padding-around-test-blocks`
+- **Presets:** `recommended`; covered by `padding-around-all` in `strict`
+- **Fixable:** yes, `eslint --fix` inserts the missing blank lines
+- **Options:** none
+- **Message IDs:** `missingPaddingBefore`, `missingPaddingAfter`
 
-This rule enforces a line of padding before _and_ after 1 or more `test`/`it` statements
+## Rule summary
 
-Note that it doesn't add/enforce a padding line if it's the last statement in its scope
+Require a blank line before and after every `test` or `it` block, including `fit`, `xit`, and `xtest`.
 
-Examples of **incorrect** code for this rule:
+- Matches every statement that starts with `test`, `it`, `fit`, `xit`, or `xtest`, including `test.each(...)`, `it.only(...)`, `test.skip(...)`, and `test.todo(...)`.
+- Only neighbouring statements in the same block are compared: the top level of the file, a `{ ... }` block such as a callback body, or a `switch` case. The first statement in a block needs no blank line before it, and the last needs none after it.
+- One blank line is enough; extra blank lines are never reported.
+- Consecutive tests need a blank line between them.
+- A comment on its own line is not a blank line, but a blank line on either side of a comment satisfies the rule.
+
+## Why
+
+Each `test` or `it` block is one self-contained case. A blank line between cases, and between a case and the surrounding setup, makes individual tests easy to find, count, and move, and keeps one test's body from running visually into the next.
+
+## Incorrect examples
 
 ```js
+/* eslint jest-formatting/padding-around-test-blocks: "error" */
 const thing = 123;
 test('foo', () => {});
-test('bar', () => {});
+test.each([1, 2])('bar %i', () => {});
+```
+
+ESLint reports:
+
+```text
+3:1  error  Missing blank line before `test`. Expected at least one blank line between the previous statement and this `test` call. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).  jest-formatting/padding-around-test-blocks
+4:1  error  Missing blank line after `test`. Expected at least one blank line between the `test` call above and this statement. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).  jest-formatting/padding-around-test-blocks
 ```
 
 ```js
-const thing = 123;
-it('foo', () => {});
-it('bar', () => {});
+/* eslint jest-formatting/padding-around-test-blocks: "error" */
+describe('suite', () => {
+  const thing = 123;
+  it('foo', () => {});
+  xit('bar', () => {});
+});
 ```
 
-Examples of **correct** code for this rule:
+ESLint reports:
+
+```text
+4:3  error  Missing blank line before `it`. Expected at least one blank line between the previous statement and this `it` call. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).  jest-formatting/padding-around-test-blocks
+5:3  error  Missing blank line after `it`. Expected at least one blank line between the `it` call above and this statement. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).  jest-formatting/padding-around-test-blocks
+```
+
+## Correct examples
 
 ```js
+/* eslint jest-formatting/padding-around-test-blocks: "error" */
 const thing = 123;
 
 test('foo', () => {});
 
-test('bar', () => {});
+test.each([1, 2])('bar %i', () => {});
 ```
 
 ```js
-const thing = 123;
+/* eslint jest-formatting/padding-around-test-blocks: "error" */
+describe('suite', () => {
+  const thing = 123;
 
-it('foo', () => {});
+  it('foo', () => {});
 
-it('bar', () => {});
+  xit('bar', () => {});
+});
 ```
+
+## Options
+
+This rule has no options; configure only the severity. Passing options makes ESLint reject the configuration, because the rule's schema is empty.
+
+```js
+// eslint.config.js (flat); the same `rules` entry works in a legacy .eslintrc
+import jestFormatting from 'eslint-plugin-jest-formatting';
+
+export default [
+  {
+    plugins: { 'jest-formatting': jestFormatting },
+    rules: {
+      'jest-formatting/padding-around-test-blocks': 'error',
+    },
+  },
+];
+```
+
+## Fixability
+
+Fixable (`meta.fixable` is `"whitespace"`). `eslint --fix` resolves every report from this rule by inserting a newline after the last token of the statement before the gap, after any comment that trails on the same line, so that a blank line separates the two statements. The fix only adds whitespace; it never removes, moves, or reformats code.
+
+Both messages are reported on the statement that should have a blank line above it. `{{token}}` is the identifier that matched, for example `xit`.
+
+- `missingPaddingBefore`, reported on the `test` or `it` call: Missing blank line before `{{token}}`. Expected at least one blank line between the previous statement and this `{{token}}` call. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).
+- `missingPaddingAfter`, reported on the statement after the `test` or `it` call: Missing blank line after `{{token}}`. Expected at least one blank line between the `{{token}}` call above and this statement. Fix: insert an empty line between the statements, before any comments leading the next statement (autofixable with --fix).

package/lib/ast-utils.js

@@ -1,36 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPaddingLineSequences = exports.getActualLastToken = exports.isValidParent = exports.areTokensOnSameLine = exports.isTokenASemicolon = void 0;
-exports.isTokenASemicolon = (token) => token.value === ';' && token.type === 'Punctuator';
-exports.areTokensOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
+const isTokenASemicolon = (token) => token.value === ';' && token.type === 'Punctuator';
+exports.isTokenASemicolon = isTokenASemicolon;
+const areTokensOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
+exports.areTokensOnSameLine = areTokensOnSameLine;
 const STATEMENT_LIST_PARENTS = new Set([
     'Program',
     'BlockStatement',
     'SwitchCase',
     'SwitchStatement',
 ]);
-exports.isValidParent = (parentType) => {
+const isValidParent = (parentType) => {
     return STATEMENT_LIST_PARENTS.has(parentType);
 };
-exports.getActualLastToken = (sourceCode, node) => {
+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] &&
-        exports.isTokenASemicolon(semiToken) &&
+        (0, exports.isTokenASemicolon)(semiToken) &&
         semiToken.loc.start.line !== prevToken.loc.end.line &&
         semiToken.loc.end.line === nextToken.loc.start.line);
     return isSemicolonLessStyle ? prevToken : semiToken;
 };
-exports.getPaddingLineSequences = (prevNode, nextNode, sourceCode) => {
+exports.getActualLastToken = getActualLastToken;
+const getPaddingLineSequences = (prevNode, nextNode, sourceCode) => {
     const pairs = [];
     const includeComments = true;
-    let prevToken = exports.getActualLastToken(sourceCode, prevNode);
+    let prevToken = (0, exports.getActualLastToken)(sourceCode, prevNode);
     if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) {
         do {
-            const token = sourceCode.getTokenAfter(prevToken, { includeComments });
+            const token = sourceCode.getTokenAfter(prevToken, {
+                includeComments,
+            });
             if (token.loc.start.line - prevToken.loc.end.line >= 2) {
                 pairs.push([prevToken, token]);
             }
@@ -39,3 +45,4 @@ exports.getPaddingLineSequences = (prevNode, nextNode, sourceCode) => {
     }
     return pairs;
 };
+exports.getPaddingLineSequences = getPaddingLineSequences;

package/lib/index.js

@@ -1,7 +1,8 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.configs = exports.rules = void 0;
 const padding_1 = require("./rules/padding");
+const packageJson = require('../package.json');
+const packageName = packageJson.name;
+const packageVersion = packageJson.version;
 const paddingConfigs = {
     afterAll: [
         {
@@ -113,58 +114,87 @@ const paddingConfigs = {
         },
     ],
 };
-exports.rules = {
-    'padding-around-after-all-blocks': padding_1.createRule(paddingConfigs.afterAll),
-    'padding-around-after-each-blocks': padding_1.createRule(paddingConfigs.afterEach),
-    'padding-around-before-all-blocks': padding_1.createRule(paddingConfigs.beforeAll),
-    'padding-around-before-each-blocks': padding_1.createRule(paddingConfigs.beforeEach),
-    'padding-around-describe-blocks': padding_1.createRule(paddingConfigs.describe),
-    'padding-around-expect-groups': padding_1.createRule(paddingConfigs.expect),
-    'padding-around-test-blocks': padding_1.createRule(paddingConfigs.test),
-    'padding-around-all': padding_1.createRule([].concat(...Object.keys(paddingConfigs).map((k) => paddingConfigs[k]))),
-};
-exports.configs = {
-    recommended: {
-        plugins: ['jest-formatting'],
-        overrides: [
-            {
-                files: [
-                    '**/*.test.*',
-                    '**/*_test.*',
-                    '**/*Test.*',
-                    '**/*.spec.*',
-                    '**/*_spec.*',
-                    '**/*Spec.*',
-                    '**/__tests__/*',
-                ],
-                rules: {
-                    'jest-formatting/padding-around-after-all-blocks': 2,
-                    'jest-formatting/padding-around-after-each-blocks': 2,
-                    'jest-formatting/padding-around-before-all-blocks': 2,
-                    'jest-formatting/padding-around-before-each-blocks': 2,
-                    'jest-formatting/padding-around-describe-blocks': 2,
-                    'jest-formatting/padding-around-test-blocks': 2,
-                },
-            },
-        ],
+const ruleDefinitions = {
+    'padding-around-after-all-blocks': {
+        description: 'Enforce padding around `afterAll` blocks',
+        configs: paddingConfigs.afterAll,
+    },
+    'padding-around-after-each-blocks': {
+        description: 'Enforce padding around `afterEach` blocks',
+        configs: paddingConfigs.afterEach,
+    },
+    'padding-around-before-all-blocks': {
+        description: 'Enforce padding around `beforeAll` blocks',
+        configs: paddingConfigs.beforeAll,
+    },
+    'padding-around-before-each-blocks': {
+        description: 'Enforce padding around `beforeEach` blocks',
+        configs: paddingConfigs.beforeEach,
+    },
+    'padding-around-describe-blocks': {
+        description: 'Enforce padding around `describe` blocks',
+        configs: paddingConfigs.describe,
+    },
+    'padding-around-expect-groups': {
+        description: 'Enforce padding around groups of `expect` statements',
+        configs: paddingConfigs.expect,
+    },
+    'padding-around-test-blocks': {
+        description: 'Enforce padding around `test` and `it` blocks',
+        configs: paddingConfigs.test,
     },
-    strict: {
-        plugins: ['jest-formatting'],
-        overrides: [
-            {
-                files: [
-                    '**/*.test.*',
-                    '**/*_test.*',
-                    '**/*Test.*',
-                    '**/*.spec.*',
-                    '**/*_spec.*',
-                    '**/*Spec.*',
-                    '**/__tests__/*',
-                ],
-                rules: {
-                    'jest-formatting/padding-around-all': 2,
-                },
-            },
-        ],
+    'padding-around-all': {
+        description: 'Enforce padding around all Jest blocks covered by the other `padding-around-*` rules',
+        configs: [].concat(...Object.keys(paddingConfigs).map((k) => paddingConfigs[k])),
     },
 };
+const rules = {};
+Object.keys(ruleDefinitions).forEach((name) => {
+    rules[name] = (0, padding_1.createRule)(Object.assign({ name }, ruleDefinitions[name]));
+});
+const testFileGlobs = [
+    '**/*.test.*',
+    '**/*_test.*',
+    '**/*Test.*',
+    '**/*.spec.*',
+    '**/*_spec.*',
+    '**/*Spec.*',
+    '**/__tests__/*',
+];
+const recommendedRules = {
+    'jest-formatting/padding-around-after-all-blocks': 2,
+    'jest-formatting/padding-around-after-each-blocks': 2,
+    'jest-formatting/padding-around-before-all-blocks': 2,
+    'jest-formatting/padding-around-before-each-blocks': 2,
+    'jest-formatting/padding-around-describe-blocks': 2,
+    'jest-formatting/padding-around-test-blocks': 2,
+};
+const strictRules = {
+    'jest-formatting/padding-around-all': 2,
+};
+const plugin = {
+    meta: { name: packageName, version: packageVersion },
+    rules,
+    configs: {},
+};
+const createLegacyConfig = (configRules) => ({
+    plugins: ['jest-formatting'],
+    overrides: [
+        {
+            files: [...testFileGlobs],
+            rules: configRules,
+        },
+    ],
+});
+const createFlatConfig = (configName, configRules) => ({
+    name: `jest-formatting/${configName}`,
+    plugins: { 'jest-formatting': plugin },
+    rules: configRules,
+});
+plugin.configs = {
+    recommended: createLegacyConfig(recommendedRules),
+    strict: createLegacyConfig(strictRules),
+    'flat/recommended': createFlatConfig('recommended', recommendedRules),
+    'flat/strict': createFlatConfig('strict', strictRules),
+};
+module.exports = plugin;