@codeperfect/eslint-plugin 1.0.0 → 2.1.0

package/dist/domain/testing/enforce-aaa-phase-purity/rule-test-helpers.d.ts

@@ -0,0 +1,42 @@
+import type * as ESTree from "estree";
+import { Linter } from "eslint";
+import type { TestBlockAnalysis } from "../aaa/index.js";
+/** Minimal analysis input accepted by the mocked AAA helper. */
+interface MockedAnalysisInput {
+    /** Section comments relevant to the rule under test. */
+    sectionComments: {
+        /** Phase names declared by the synthetic comment. */
+        phases: TestBlockAnalysis["sectionComments"][number]["phases"];
+    }[];
+    /** Statement metadata relevant to the rule under test. */
+    statements: {
+        /** Synthetic statement node provided to the rule. */
+        node: ESTree.Statement;
+        /** Active phases assigned to the statement. */
+        phases: TestBlockAnalysis["statements"][number]["phases"];
+    }[];
+}
+/**
+ * Runs the rule against one source snippet.
+ * @param code Source code passed to the linter.
+ * @returns Lint messages produced by the rule.
+ * @example
+ * ```typescript
+ * const messages = runRule('it("works", () => {});');
+ * void messages;
+ * ```
+ */
+declare function runRule(code: string): Linter.LintMessage[];
+/**
+ * Runs the rule with a mocked AAA analysis result.
+ * @param analysis Mocked analysis returned from `analyzeTestBlock`.
+ * @returns Captured report calls issued by the rule.
+ * @example
+ * ```typescript
+ * const calls = await runRuleWithMockedAnalysis({ sectionComments: [], statements: [] });
+ * void calls;
+ * ```
+ */
+declare function runRuleWithMockedAnalysis(analysis: MockedAnalysisInput): Promise<unknown[][]>;
+export { runRule, runRuleWithMockedAnalysis };
+//# sourceMappingURL=rule-test-helpers.d.ts.map

package/dist/domain/testing/enforce-aaa-phase-purity/rule-test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-test-helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/rule-test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAKhC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAIhD,gEAAgE;AAChE,UAAU,mBAAmB;IAC3B,wDAAwD;IACxD,eAAe,EAAE;QACf,qDAAqD;QACrD,MAAM,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC;KAChE,EAAE,CAAC;IACJ,0DAA0D;IAC1D,UAAU,EAAE;QACV,qDAAqD;QACrD,IAAI,EAAE,MAAM,CAAC,SAAS,CAAC;QAEvB,+CAA+C;QAC/C,MAAM,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC;KAC3D,EAAE,CAAC;CACL;AAyJD;;;;;;;;;GASG;AACH,iBAAS,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,WAAW,EAAE,CA2BnD;AAED;;;;;;;;;GASG;AACH,iBAAe,yBAAyB,CACtC,QAAQ,EAAE,mBAAmB,GAC5B,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,CAUtB;AAED,OAAO,EAAE,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/domain/testing/enforce-aaa-phase-purity/rule-test-helpers.js

@@ -0,0 +1,188 @@
+import { Linter } from "eslint";
+import { parser } from "typescript-eslint";
+import { vi } from "vitest";
+import { enforceAaaPhasePurityRule } from "./rule.js";
+/**
+ * Creates the mocked AAA module used by the rule test helper.
+ * @param mockedAnalysis Mocked analysis returned by the helper.
+ * @returns Partial AAA module used for Vitest mocking.
+ * @example
+ * ```typescript
+ * const module = createMockedAaaModule(createMockedAnalysis({ sectionComments: [], statements: [] }));
+ * void module;
+ * ```
+ */
+function createMockedAaaModule(mockedAnalysis) {
+    return {
+        analyzeTestBlock: () => mockedAnalysis,
+        hasAssertion: () => false,
+        hasAsyncLogic: () => false,
+        hasAwait: () => false,
+        hasCapturableActResult: () => false,
+        hasMutation: () => false,
+        isMeaningfulActStatement: () => false,
+        isSetupLikeStatement: () => false,
+        isValidAssertStatement: () => false,
+    };
+}
+/**
+ * Creates a full analysis object from the minimal fields used in tests.
+ * @param analysis Minimal analysis input used by tests.
+ * @returns Complete analysis object consumed by the rule.
+ * @example
+ * ```typescript
+ * const result = createMockedAnalysis({ sectionComments: [], statements: [] });
+ * void result;
+ * ```
+ */
+function createMockedAnalysis(analysis) {
+    return {
+        body: createMockedBody(),
+        bodyLineCount: 0,
+        callExpression: createMockedCallExpression(),
+        newline: "\n",
+        sectionComments: analysis.sectionComments.map((sectionComment) => ({
+            comment: {
+                loc: {
+                    end: { column: 0, line: 1 },
+                    start: { column: 0, line: 1 },
+                },
+                range: [0, 0],
+                type: "Line",
+                value: ` ${sectionComment.phases.join(" / ")}`,
+            },
+            phases: sectionComment.phases,
+        })),
+        sourceText: "",
+        statements: analysis.statements.map((statement) => ({
+            node: statement.node,
+            phase: statement.phases.at(-1),
+            phases: statement.phases,
+        })),
+    };
+}
+/**
+ * Creates a minimal located block statement for mocked AAA analysis.
+ * @returns Minimal located block statement.
+ * @example
+ * ```typescript
+ * const body = createMockedBody();
+ * ```
+ */
+function createMockedBody() {
+    return {
+        body: [],
+        loc: {
+            end: { column: 0, line: 1 },
+            start: { column: 0, line: 1 },
+        },
+        range: [0, 0],
+        type: "BlockStatement",
+    };
+}
+/**
+ * Creates a minimal located call expression for mocked AAA analysis.
+ * @returns Minimal located call expression.
+ * @example
+ * ```typescript
+ * const callExpression = createMockedCallExpression();
+ * ```
+ */
+function createMockedCallExpression() {
+    return {
+        arguments: [],
+        callee: { name: "it", type: "Identifier" },
+        loc: {
+            end: { column: 0, line: 1 },
+            start: { column: 0, line: 1 },
+        },
+        optional: false,
+        range: [0, 0],
+        type: "CallExpression",
+    };
+}
+/**
+ * Creates the mocked rule listener used by the helper.
+ * @param analysis Mocked analysis returned from `analyzeTestBlock`.
+ * @param report Report spy passed into the mocked rule context.
+ * @returns Call-expression listener produced by the mocked rule.
+ * @example
+ * ```typescript
+ * const listener = await loadMockedListener({ sectionComments: [], statements: [] }, vi.fn());
+ * void listener;
+ * ```
+ */
+async function loadMockedListener(analysis, report) {
+    vi.resetModules();
+    vi.doMock("../aaa", () => createMockedAaaModule(createMockedAnalysis(analysis)));
+    const ruleModule = await import("./rule.js");
+    return ruleModule.enforceAaaPhasePurityRule.create({ report })
+        .CallExpression;
+}
+/**
+ * Resets the mocked AAA module state between test runs.
+ * @example
+ * ```typescript
+ * resetMockedAaaModule();
+ * ```
+ */
+function resetMockedAaaModule() {
+    vi.doUnmock("../aaa");
+    vi.resetModules();
+}
+/**
+ * Runs the rule against one source snippet.
+ * @param code Source code passed to the linter.
+ * @returns Lint messages produced by the rule.
+ * @example
+ * ```typescript
+ * const messages = runRule('it("works", () => {});');
+ * void messages;
+ * ```
+ */
+function runRule(code) {
+    const linter = new Linter({ configType: "flat" });
+    return linter.verify(code, [
+        {
+            files: ["**/*.ts"],
+            languageOptions: {
+                ecmaVersion: 2022,
+                parser,
+                sourceType: "module",
+            },
+            plugins: {
+                codeperfect: {
+                    rules: {
+                        "enforce-aaa-phase-purity": enforceAaaPhasePurityRule,
+                    },
+                },
+            },
+            rules: {
+                "codeperfect/enforce-aaa-phase-purity": "error",
+            },
+        },
+    ], "example.spec.ts");
+}
+/**
+ * Runs the rule with a mocked AAA analysis result.
+ * @param analysis Mocked analysis returned from `analyzeTestBlock`.
+ * @returns Captured report calls issued by the rule.
+ * @example
+ * ```typescript
+ * const calls = await runRuleWithMockedAnalysis({ sectionComments: [], statements: [] });
+ * void calls;
+ * ```
+ */
+async function runRuleWithMockedAnalysis(analysis) {
+    const report = vi.fn();
+    const listener = await loadMockedListener(analysis, report);
+    try {
+        listener?.({ type: "CallExpression" });
+        return report.mock.calls;
+    }
+    finally {
+        resetMockedAaaModule();
+    }
+}
+export { runRule, runRuleWithMockedAnalysis };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule-test-helpers.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/rule-test-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as ESTree from \"estree\";\r\n\r\nimport { Linter } from \"eslint\";\r\nimport { parser } from \"typescript-eslint\";\r\nimport { vi } from \"vitest\";\r\n\r\nimport type * as AaaModule from \"../aaa\";\r\nimport type { TestBlockAnalysis } from \"../aaa\";\r\n\r\nimport { enforceAaaPhasePurityRule } from \"./rule\";\r\n\r\n/** Minimal analysis input accepted by the mocked AAA helper. */\r\ninterface MockedAnalysisInput {\r\n  /** Section comments relevant to the rule under test. */\r\n  sectionComments: {\r\n    /** Phase names declared by the synthetic comment. */\r\n    phases: TestBlockAnalysis[\"sectionComments\"][number][\"phases\"];\r\n  }[];\r\n  /** Statement metadata relevant to the rule under test. */\r\n  statements: {\r\n    /** Synthetic statement node provided to the rule. */\r\n    node: ESTree.Statement;\r\n\r\n    /** Active phases assigned to the statement. */\r\n    phases: TestBlockAnalysis[\"statements\"][number][\"phases\"];\r\n  }[];\r\n}\r\n\r\n/** Module shape returned when the rule is loaded after mocking the AAA helpers. */\r\ninterface MockedRuleModule {\r\n  /** Rule implementation under test. */\r\n  enforceAaaPhasePurityRule: typeof enforceAaaPhasePurityRule;\r\n}\r\n\r\n/**\r\n * Creates the mocked AAA module used by the rule test helper.\r\n * @param mockedAnalysis Mocked analysis returned by the helper.\r\n * @returns Partial AAA module used for Vitest mocking.\r\n * @example\r\n * ```typescript\r\n * const module = createMockedAaaModule(createMockedAnalysis({ sectionComments: [], statements: [] }));\r\n * void module;\r\n * ```\r\n */\r\nfunction createMockedAaaModule(\r\n  mockedAnalysis: TestBlockAnalysis,\r\n): Partial<typeof AaaModule> {\r\n  return {\r\n    analyzeTestBlock: (): TestBlockAnalysis => mockedAnalysis,\r\n    hasAssertion: (): boolean => false,\r\n    hasAsyncLogic: (): boolean => false,\r\n    hasAwait: (): boolean => false,\r\n    hasCapturableActResult: (): boolean => false,\r\n    hasMutation: (): boolean => false,\r\n    isMeaningfulActStatement: (): boolean => false,\r\n    isSetupLikeStatement: (): boolean => false,\r\n    isValidAssertStatement: (): boolean => false,\r\n  };\r\n}\r\n\r\n/**\r\n * Creates a full analysis object from the minimal fields used in tests.\r\n * @param analysis Minimal analysis input used by tests.\r\n * @returns Complete analysis object consumed by the rule.\r\n * @example\r\n * ```typescript\r\n * const result = createMockedAnalysis({ sectionComments: [], statements: [] });\r\n * void result;\r\n * ```\r\n */\r\nfunction createMockedAnalysis(\r\n  analysis: MockedAnalysisInput,\r\n): TestBlockAnalysis {\r\n  return {\r\n    body: createMockedBody(),\r\n    bodyLineCount: 0,\r\n    callExpression: createMockedCallExpression(),\r\n    newline: \"\\n\",\r\n    sectionComments: analysis.sectionComments.map((sectionComment) => ({\r\n      comment: {\r\n        loc: {\r\n          end: { column: 0, line: 1 },\r\n          start: { column: 0, line: 1 },\r\n        },\r\n        range: [0, 0],\r\n        type: \"Line\",\r\n        value: ` ${sectionComment.phases.join(\" / \")}`,\r\n      },\r\n      phases: sectionComment.phases,\r\n    })),\r\n    sourceText: \"\",\r\n    statements: analysis.statements.map((statement) => ({\r\n      node: statement.node as TestBlockAnalysis[\"statements\"][number][\"node\"],\r\n      phase: statement.phases.at(-1),\r\n      phases: statement.phases,\r\n    })),\r\n  };\r\n}\r\n\r\n/**\r\n * Creates a minimal located block statement for mocked AAA analysis.\r\n * @returns Minimal located block statement.\r\n * @example\r\n * ```typescript\r\n * const body = createMockedBody();\r\n * ```\r\n */\r\nfunction createMockedBody(): TestBlockAnalysis[\"body\"] {\r\n  return {\r\n    body: [],\r\n    loc: {\r\n      end: { column: 0, line: 1 },\r\n      start: { column: 0, line: 1 },\r\n    },\r\n    range: [0, 0],\r\n    type: \"BlockStatement\",\r\n  };\r\n}\r\n\r\n/**\r\n * Creates a minimal located call expression for mocked AAA analysis.\r\n * @returns Minimal located call expression.\r\n * @example\r\n * ```typescript\r\n * const callExpression = createMockedCallExpression();\r\n * ```\r\n */\r\nfunction createMockedCallExpression(): TestBlockAnalysis[\"callExpression\"] {\r\n  return {\r\n    arguments: [],\r\n    callee: { name: \"it\", type: \"Identifier\" } as ESTree.Identifier,\r\n    loc: {\r\n      end: { column: 0, line: 1 },\r\n      start: { column: 0, line: 1 },\r\n    },\r\n    optional: false,\r\n    range: [0, 0],\r\n    type: \"CallExpression\",\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the mocked rule listener used by the helper.\r\n * @param analysis Mocked analysis returned from `analyzeTestBlock`.\r\n * @param report Report spy passed into the mocked rule context.\r\n * @returns Call-expression listener produced by the mocked rule.\r\n * @example\r\n * ```typescript\r\n * const listener = await loadMockedListener({ sectionComments: [], statements: [] }, vi.fn());\r\n * void listener;\r\n * ```\r\n */\r\nasync function loadMockedListener(\r\n  analysis: MockedAnalysisInput,\r\n  report: ReturnType<typeof vi.fn>,\r\n): Promise<((node: ESTree.CallExpression) => void) | undefined> {\r\n  vi.resetModules();\r\n  vi.doMock(\"../aaa\", () =>\r\n    createMockedAaaModule(createMockedAnalysis(analysis)),\r\n  );\r\n\r\n  const ruleModule: MockedRuleModule = await import(\"./rule\");\r\n\r\n  return ruleModule.enforceAaaPhasePurityRule.create({ report } as never)\r\n    .CallExpression as ((node: ESTree.CallExpression) => void) | undefined;\r\n}\r\n\r\n/**\r\n * Resets the mocked AAA module state between test runs.\r\n * @example\r\n * ```typescript\r\n * resetMockedAaaModule();\r\n * ```\r\n */\r\nfunction resetMockedAaaModule(): void {\r\n  vi.doUnmock(\"../aaa\");\r\n  vi.resetModules();\r\n}\r\n\r\n/**\r\n * Runs the rule against one source snippet.\r\n * @param code Source code passed to the linter.\r\n * @returns Lint messages produced by the rule.\r\n * @example\r\n * ```typescript\r\n * const messages = runRule('it(\"works\", () => {});');\r\n * void messages;\r\n * ```\r\n */\r\nfunction runRule(code: string): Linter.LintMessage[] {\r\n  const linter = new Linter({ configType: \"flat\" });\r\n\r\n  return linter.verify(\r\n    code,\r\n    [\r\n      {\r\n        files: [\"**/*.ts\"],\r\n        languageOptions: {\r\n          ecmaVersion: 2022,\r\n          parser,\r\n          sourceType: \"module\",\r\n        },\r\n        plugins: {\r\n          codeperfect: {\r\n            rules: {\r\n              \"enforce-aaa-phase-purity\": enforceAaaPhasePurityRule,\r\n            },\r\n          },\r\n        },\r\n        rules: {\r\n          \"codeperfect/enforce-aaa-phase-purity\": \"error\",\r\n        },\r\n      },\r\n    ],\r\n    \"example.spec.ts\",\r\n  );\r\n}\r\n\r\n/**\r\n * Runs the rule with a mocked AAA analysis result.\r\n * @param analysis Mocked analysis returned from `analyzeTestBlock`.\r\n * @returns Captured report calls issued by the rule.\r\n * @example\r\n * ```typescript\r\n * const calls = await runRuleWithMockedAnalysis({ sectionComments: [], statements: [] });\r\n * void calls;\r\n * ```\r\n */\r\nasync function runRuleWithMockedAnalysis(\r\n  analysis: MockedAnalysisInput,\r\n): Promise<unknown[][]> {\r\n  const report = vi.fn();\r\n  const listener = await loadMockedListener(analysis, report);\r\n\r\n  try {\r\n    listener?.({ type: \"CallExpression\" } as ESTree.CallExpression);\r\n    return report.mock.calls as unknown[][];\r\n  } finally {\r\n    resetMockedAaaModule();\r\n  }\r\n}\r\n\r\nexport { runRule, runRuleWithMockedAnalysis };\r\n"]}

package/dist/{testing → domain/testing}/enforce-aaa-phase-purity/rule.d.ts

@@ -1,4 +1,5 @@
 import type { Rule } from "eslint";
+/** Enforces pure Arrange, Act, and Assert behavior inside AAA-marked tests. */
 declare const enforceAaaPhasePurityRule: Rule.RuleModule;
 export { enforceAaaPhasePurityRule };
 //# sourceMappingURL=rule.d.ts.map

package/dist/domain/testing/enforce-aaa-phase-purity/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAKnC,+EAA+E;AAC/E,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UAsCrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/domain/testing/enforce-aaa-phase-purity/rule.js

@@ -0,0 +1,37 @@
+import { analyzeTestBlock } from "../aaa/index.js";
+import { reportPhasePurityViolations } from "./phase-purity-reporting.js";
+/** Enforces pure Arrange, Act, and Assert behavior inside AAA-marked tests. */
+const enforceAaaPhasePurityRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                reportPhasePurityViolations(context, analysis);
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: "Keep setup, action, and assertions inside their intended AAA phases.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/enforce-aaa-phase-purity.md",
+        },
+        messages: {
+            actionInArrange: "Keep the function under test out of Arrange; reserve Arrange for setup only.",
+            assertionOutsideAssert: "Move assertions into the // Assert section so test logic does not leak earlier.",
+            asyncInArrange: "Do not trigger async behavior in Arrange.",
+            awaitOutsideAct: "Use await only inside the // Act section.",
+            missingMeaningfulAct: "The // Act section must contain a meaningful SUT interaction, not only utility or setup calls.",
+            mutationAfterAct: "Do not mutate test data after the // Act section has run.",
+            nonAssertionInAssert: "Keep the // Assert section focused on assertions and assertion-local values.",
+            setupAfterAct: "Do not continue arranging test data after the // Act section has started.",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+export { enforceAaaPhasePurityRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/testing/enforce-aaa-structure/index.d.ts

@@ -0,0 +1,2 @@
+export { enforceAaaStructureRule } from "./rule.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/testing/enforce-aaa-structure/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/testing/enforce-aaa-structure/index.js

@@ -0,0 +1,2 @@
+export { enforceAaaStructureRule } from "./rule.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvZW5mb3JjZS1hYWEtc3RydWN0dXJlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGVuZm9yY2VBYWFTdHJ1Y3R1cmVSdWxlIH0gZnJvbSBcIi4vcnVsZVwiO1xuIl19

package/dist/{testing → domain/testing}/enforce-aaa-structure/rule.d.ts

@@ -1,4 +1,5 @@
 import type { Rule } from "eslint";
+/** Enforces a single Arrange/Act/Assert sequence inside supported test blocks. */
 declare const enforceAaaStructureRule: Rule.RuleModule;
 export { enforceAaaStructureRule };
 //# sourceMappingURL=rule.d.ts.map

package/dist/domain/testing/enforce-aaa-structure/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAqFnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAwCnC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/domain/testing/enforce-aaa-structure/rule.js

@@ -0,0 +1,88 @@
+import { aaaPhaseOrder, analyzeTestBlock, getFlattenedSections } from "../aaa/index.js";
+/**
+ * Reports a duplicate or out-of-order AAA section comment.
+ * @param input Composite reporting input for the current section.
+ * @example
+ * ```typescript
+ * reportSectionIssue({
+ *   context: {} as Rule.RuleContext,
+ *   messageId: "duplicateSection",
+ *   section: {} as ReturnType<typeof getFlattenedSections>[number],
+ * });
+ * ```
+ */
+const reportSectionIssue = (input) => {
+    const { context, messageId, section } = input;
+    context.report({
+        data: { section: section.phase },
+        messageId,
+        node: section.comment,
+    });
+};
+/**
+ * Tracks the current AAA ordering state for one flattened section.
+ * @param input Composite ordering state for the current section.
+ * @returns Updated phase order watermark.
+ * @example
+ * ```typescript
+ * const nextOrder = updateSectionOrder({
+ *   context: {} as Rule.RuleContext,
+ *   lastPhaseOrder: -1,
+ *   section: {} as ReturnType<typeof getFlattenedSections>[number],
+ *   seenPhases: new Set(),
+ * });
+ * void nextOrder;
+ * ```
+ */
+const updateSectionOrder = (input) => {
+    const { context, lastPhaseOrder, section, seenPhases } = input;
+    if (seenPhases.has(section.phase)) {
+        reportSectionIssue({ context, messageId: "duplicateSection", section });
+        return lastPhaseOrder;
+    }
+    const currentPhaseOrder = aaaPhaseOrder[section.phase];
+    if (currentPhaseOrder < lastPhaseOrder) {
+        reportSectionIssue({ context, messageId: "invalidOrder", section });
+    }
+    seenPhases.add(section.phase);
+    return Math.max(lastPhaseOrder, currentPhaseOrder);
+};
+/** Enforces a single Arrange/Act/Assert sequence inside supported test blocks. */
+const enforceAaaStructureRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                const flattenedSections = getFlattenedSections(analysis);
+                const seenPhases = new Set();
+                let lastPhaseOrder = -1;
+                for (const section of flattenedSections) {
+                    lastPhaseOrder = updateSectionOrder({
+                        context,
+                        lastPhaseOrder,
+                        section,
+                        seenPhases,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: "Require AAA sections to appear once and in Arrange, Act, Assert order.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/enforce-aaa-structure.md",
+        },
+        messages: {
+            duplicateSection: "Use the // {{section}} section comment only once per test.",
+            invalidOrder: "Move the // {{section}} section comment so AAA phases stay in Arrange, Act, Assert order.",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+export { enforceAaaStructureRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/{testing → domain/testing}/index.d.ts

@@ -1,9 +1,10 @@
-export { assertActualExpectedNamesRule } from "./assert-actual-expected-names";
-export { enforceAaaPhasePurityRule } from "./enforce-aaa-phase-purity";
-export { enforceAaaStructureRule } from "./enforce-aaa-structure";
-export { preferViMockedImportRule } from "./prefer-vi-mocked-import";
-export { requireAaaSectionsRule } from "./require-aaa-sections";
-export { requireActResultCaptureRule } from "./require-act-result-capture";
-export { requireTestCompanionRule } from "./require-test-companion";
-export { singleActStatementRule } from "./single-act-statement";
+export { assertActualExpectedNamesRule } from "./assert-actual-expected-names/index.js";
+export { enforceAaaPhasePurityRule } from "./enforce-aaa-phase-purity/index.js";
+export { enforceAaaStructureRule } from "./enforce-aaa-structure/index.js";
+export { preferViMockedImportRule } from "./prefer-vi-mocked-import/index.js";
+export { preferVitestIncrementalCastsRule } from "./prefer-vitest-incremental-casts/index.js";
+export { requireAaaSectionsRule } from "./require-aaa-sections/index.js";
+export { requireActResultCaptureRule } from "./require-act-result-capture/index.js";
+export { requireTestCompanionRule } from "./require-test-companion/index.js";
+export { singleActStatementRule } from "./single-act-statement/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/domain/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/testing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,OAAO,EAAE,gCAAgC,EAAE,MAAM,mCAAmC,CAAC;AACrF,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,2BAA2B,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/domain/testing/index.js

@@ -0,0 +1,10 @@
+export { assertActualExpectedNamesRule } from "./assert-actual-expected-names/index.js";
+export { enforceAaaPhasePurityRule } from "./enforce-aaa-phase-purity/index.js";
+export { enforceAaaStructureRule } from "./enforce-aaa-structure/index.js";
+export { preferViMockedImportRule } from "./prefer-vi-mocked-import/index.js";
+export { preferVitestIncrementalCastsRule } from "./prefer-vitest-incremental-casts/index.js";
+export { requireAaaSectionsRule } from "./require-aaa-sections/index.js";
+export { requireActResultCaptureRule } from "./require-act-result-capture/index.js";
+export { requireTestCompanionRule } from "./require-test-companion/index.js";
+export { singleActStatementRule } from "./single-act-statement/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDL0UsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDdkUsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDbEUsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDckUsT0FBTyxFQUFFLGdDQUFnQyxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFDckYsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDaEUsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDM0UsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDcEUsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBhc3NlcnRBY3R1YWxFeHBlY3RlZE5hbWVzUnVsZSB9IGZyb20gXCIuL2Fzc2VydC1hY3R1YWwtZXhwZWN0ZWQtbmFtZXNcIjtcbmV4cG9ydCB7IGVuZm9yY2VBYWFQaGFzZVB1cml0eVJ1bGUgfSBmcm9tIFwiLi9lbmZvcmNlLWFhYS1waGFzZS1wdXJpdHlcIjtcbmV4cG9ydCB7IGVuZm9yY2VBYWFTdHJ1Y3R1cmVSdWxlIH0gZnJvbSBcIi4vZW5mb3JjZS1hYWEtc3RydWN0dXJlXCI7XG5leHBvcnQgeyBwcmVmZXJWaU1vY2tlZEltcG9ydFJ1bGUgfSBmcm9tIFwiLi9wcmVmZXItdmktbW9ja2VkLWltcG9ydFwiO1xuZXhwb3J0IHsgcHJlZmVyVml0ZXN0SW5jcmVtZW50YWxDYXN0c1J1bGUgfSBmcm9tIFwiLi9wcmVmZXItdml0ZXN0LWluY3JlbWVudGFsLWNhc3RzXCI7XG5leHBvcnQgeyByZXF1aXJlQWFhU2VjdGlvbnNSdWxlIH0gZnJvbSBcIi4vcmVxdWlyZS1hYWEtc2VjdGlvbnNcIjtcbmV4cG9ydCB7IHJlcXVpcmVBY3RSZXN1bHRDYXB0dXJlUnVsZSB9IGZyb20gXCIuL3JlcXVpcmUtYWN0LXJlc3VsdC1jYXB0dXJlXCI7XG5leHBvcnQgeyByZXF1aXJlVGVzdENvbXBhbmlvblJ1bGUgfSBmcm9tIFwiLi9yZXF1aXJlLXRlc3QtY29tcGFuaW9uXCI7XG5leHBvcnQgeyBzaW5nbGVBY3RTdGF0ZW1lbnRSdWxlIH0gZnJvbSBcIi4vc2luZ2xlLWFjdC1zdGF0ZW1lbnRcIjtcbiJdfQ==

package/dist/domain/testing/prefer-vi-mocked-import/fix-import-statements.d.ts

@@ -0,0 +1,29 @@
+import type { Rule } from "eslint";
+import type { RuleMatch } from "./types.js";
+/**
+ * Builds fixes for adding or updating imports.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Import fixes for one match.
+ * @example
+ * ```typescript
+ * const fixes = buildImportFixes({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+declare function buildImportFixes(match: RuleMatch, fixer: Rule.RuleFixer): Rule.Fix[];
+/**
+ * Creates an import statement string from import parts.
+ * @param moduleSpecifier Module path used in the generated statement.
+ * @param defaultImportName Existing default-import local identifier, when present.
+ * @param names Named imports to include in braces.
+ * @returns Fully formatted import statement text.
+ * @example
+ * ```typescript
+ * const text = buildImportStatement("./x", void 0, ["a"]);
+ * void text;
+ * ```
+ */
+declare function buildImportStatement(moduleSpecifier: string, defaultImportName: string | undefined, names: readonly string[]): string;
+export { buildImportFixes, buildImportStatement };
+//# sourceMappingURL=fix-import-statements.d.ts.map

package/dist/domain/testing/prefer-vi-mocked-import/fix-import-statements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix-import-statements.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix-import-statements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,iBAAS,gBAAgB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAa7E;AAyCD;;;;;;;;;;;GAWG;AACH,iBAAS,oBAAoB,CAC3B,eAAe,EAAE,MAAM,EACvB,iBAAiB,EAAE,MAAM,GAAG,SAAS,EACrC,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,MAAM,CAOR;AAsCD,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/domain/testing/prefer-vi-mocked-import/fix-import-statements.js

@@ -0,0 +1,90 @@
+/**
+ * Builds fixes for adding or updating imports.
+ * @param match Autofix context produced by the matcher.
+ * @param fixer ESLint fixer.
+ * @returns Import fixes for one match.
+ * @example
+ * ```typescript
+ * const fixes = buildImportFixes({} as never, {} as never);
+ * void fixes;
+ * ```
+ */
+function buildImportFixes(match, fixer) {
+    const { names } = match.importPlan;
+    if (names.length === 0) {
+        return [];
+    }
+    const sortedNames = [...names].toSorted();
+    const updateFix = buildImportUpdateFix(match, sortedNames, fixer);
+    return updateFix === void 0
+        ? buildImportInsertFixes(match, sortedNames, fixer)
+        : [updateFix];
+}
+/**
+ * Builds import insertion fixes when no compatible import exists.
+ * @param match Autofix context produced by the matcher.
+ * @param sortedNames Sorted names that must be imported.
+ * @param fixer ESLint fixer.
+ * @returns Import insertion fixes for one match.
+ * @example
+ * ```typescript
+ * const fixes = buildImportInsertFixes({ importPlan: { moduleSpecifier: "./x", names: [] }, newline: "\n" } as never, [], {} as never);
+ * void fixes;
+ * ```
+ */
+function buildImportInsertFixes(match, sortedNames, fixer) {
+    const statementText = buildImportStatement(match.importPlan.moduleSpecifier, void 0, sortedNames);
+    const { afterRange } = match.importPlan.insert ?? {};
+    return afterRange === void 0
+        ? [
+            fixer.insertTextBeforeRange([0, 0], `${statementText}${match.newline}${match.newline}`),
+        ]
+        : [
+            fixer.insertTextAfterRange(afterRange, `${match.newline}${statementText}`),
+        ];
+}
+/**
+ * Creates an import statement string from import parts.
+ * @param moduleSpecifier Module path used in the generated statement.
+ * @param defaultImportName Existing default-import local identifier, when present.
+ * @param names Named imports to include in braces.
+ * @returns Fully formatted import statement text.
+ * @example
+ * ```typescript
+ * const text = buildImportStatement("./x", void 0, ["a"]);
+ * void text;
+ * ```
+ */
+function buildImportStatement(moduleSpecifier, defaultImportName, names) {
+    const moduleText = JSON.stringify(moduleSpecifier);
+    const namedText = `{ ${names.join(", ")} }`;
+    return defaultImportName === void 0
+        ? `import ${namedText} from ${moduleText};`
+        : `import ${defaultImportName}, ${namedText} from ${moduleText};`;
+}
+/**
+ * Builds an import update fix when an existing import is compatible.
+ * @param match Autofix context produced by the matcher.
+ * @param sortedNames Sorted names that must be imported.
+ * @param fixer ESLint fixer.
+ * @returns Replacement fix when an import can be updated.
+ * @example
+ * ```typescript
+ * const fix = buildImportUpdateFix({ importPlan: { moduleSpecifier: "./x", names: [] } } as never, [], {} as never);
+ * void fix;
+ * ```
+ */
+function buildImportUpdateFix(match, sortedNames, fixer) {
+    const { moduleSpecifier, update } = match.importPlan;
+    if (update === void 0) {
+        return void 0;
+    }
+    const { defaultImportName, existingNamedImports, range } = update;
+    const mergedNames = [
+        ...new Set([...sortedNames, ...existingNamedImports]),
+    ].toSorted();
+    const statementText = buildImportStatement(moduleSpecifier, defaultImportName, mergedNames);
+    return fixer.replaceTextRange(range, statementText);
+}
+export { buildImportFixes, buildImportStatement };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fix-import-statements.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix-import-statements.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,SAAS,gBAAgB,CAAC,KAAgB,EAAE,KAAqB;IAC/D,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC,UAAU,CAAC;IAEnC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,WAAW,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC;IAC1C,MAAM,SAAS,GAAG,oBAAoB,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;IAElE,OAAO,SAAS,KAAK,KAAK,CAAC;QACzB,CAAC,CAAC,sBAAsB,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC;QACnD,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,sBAAsB,CAC7B,KAAgB,EAChB,WAAqB,EACrB,KAAqB;IAErB,MAAM,aAAa,GAAG,oBAAoB,CACxC,KAAK,CAAC,UAAU,CAAC,eAAe,EAChC,KAAK,CAAC,EACN,WAAW,CACZ,CAAC;IACF,MAAM,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM,IAAI,EAAE,CAAC;IAErD,OAAO,UAAU,KAAK,KAAK,CAAC;QAC1B,CAAC,CAAC;YACE,KAAK,CAAC,qBAAqB,CACzB,CAAC,CAAC,EAAE,CAAC,CAAC,EACN,GAAG,aAAa,GAAG,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,EAAE,CACnD;SACF;QACH,CAAC,CAAC;YACE,KAAK,CAAC,oBAAoB,CACxB,UAAU,EACV,GAAG,KAAK,CAAC,OAAO,GAAG,aAAa,EAAE,CACnC;SACF,CAAC;AACR,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,oBAAoB,CAC3B,eAAuB,EACvB,iBAAqC,EACrC,KAAwB;IAExB,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;IACnD,MAAM,SAAS,GAAG,KAAK,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IAE5C,OAAO,iBAAiB,KAAK,KAAK,CAAC;QACjC,CAAC,CAAC,UAAU,SAAS,SAAS,UAAU,GAAG;QAC3C,CAAC,CAAC,UAAU,iBAAiB,KAAK,SAAS,SAAS,UAAU,GAAG,CAAC;AACtE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAS,oBAAoB,CAC3B,KAAgB,EAChB,WAAqB,EACrB,KAAqB;IAErB,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,UAAU,CAAC;IAErD,IAAI,MAAM,KAAK,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;IAClE,MAAM,WAAW,GAAG;QAClB,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,WAAW,EAAE,GAAG,oBAAoB,CAAC,CAAC;KACtD,CAAC,QAAQ,EAAE,CAAC;IACb,MAAM,aAAa,GAAG,oBAAoB,CACxC,eAAe,EACf,iBAAiB,EACjB,WAAW,CACZ,CAAC;IAEF,OAAO,KAAK,CAAC,gBAAgB,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;AACtD,CAAC;AAED,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\r\n\r\nimport type { RuleMatch } from \"./types\";\r\n\r\n/**\r\n * Builds fixes for adding or updating imports.\r\n * @param match Autofix context produced by the matcher.\r\n * @param fixer ESLint fixer.\r\n * @returns Import fixes for one match.\r\n * @example\r\n * ```typescript\r\n * const fixes = buildImportFixes({} as never, {} as never);\r\n * void fixes;\r\n * ```\r\n */\r\nfunction buildImportFixes(match: RuleMatch, fixer: Rule.RuleFixer): Rule.Fix[] {\r\n  const { names } = match.importPlan;\r\n\r\n  if (names.length === 0) {\r\n    return [];\r\n  }\r\n\r\n  const sortedNames = [...names].toSorted();\r\n  const updateFix = buildImportUpdateFix(match, sortedNames, fixer);\r\n\r\n  return updateFix === void 0\r\n    ? buildImportInsertFixes(match, sortedNames, fixer)\r\n    : [updateFix];\r\n}\r\n\r\n/**\r\n * Builds import insertion fixes when no compatible import exists.\r\n * @param match Autofix context produced by the matcher.\r\n * @param sortedNames Sorted names that must be imported.\r\n * @param fixer ESLint fixer.\r\n * @returns Import insertion fixes for one match.\r\n * @example\r\n * ```typescript\r\n * const fixes = buildImportInsertFixes({ importPlan: { moduleSpecifier: \"./x\", names: [] }, newline: \"\\n\" } as never, [], {} as never);\r\n * void fixes;\r\n * ```\r\n */\r\nfunction buildImportInsertFixes(\r\n  match: RuleMatch,\r\n  sortedNames: string[],\r\n  fixer: Rule.RuleFixer,\r\n): Rule.Fix[] {\r\n  const statementText = buildImportStatement(\r\n    match.importPlan.moduleSpecifier,\r\n    void 0,\r\n    sortedNames,\r\n  );\r\n  const { afterRange } = match.importPlan.insert ?? {};\r\n\r\n  return afterRange === void 0\r\n    ? [\r\n        fixer.insertTextBeforeRange(\r\n          [0, 0],\r\n          `${statementText}${match.newline}${match.newline}`,\r\n        ),\r\n      ]\r\n    : [\r\n        fixer.insertTextAfterRange(\r\n          afterRange,\r\n          `${match.newline}${statementText}`,\r\n        ),\r\n      ];\r\n}\r\n\r\n/**\r\n * Creates an import statement string from import parts.\r\n * @param moduleSpecifier Module path used in the generated statement.\r\n * @param defaultImportName Existing default-import local identifier, when present.\r\n * @param names Named imports to include in braces.\r\n * @returns Fully formatted import statement text.\r\n * @example\r\n * ```typescript\r\n * const text = buildImportStatement(\"./x\", void 0, [\"a\"]);\r\n * void text;\r\n * ```\r\n */\r\nfunction buildImportStatement(\r\n  moduleSpecifier: string,\r\n  defaultImportName: string | undefined,\r\n  names: readonly string[],\r\n): string {\r\n  const moduleText = JSON.stringify(moduleSpecifier);\r\n  const namedText = `{ ${names.join(\", \")} }`;\r\n\r\n  return defaultImportName === void 0\r\n    ? `import ${namedText} from ${moduleText};`\r\n    : `import ${defaultImportName}, ${namedText} from ${moduleText};`;\r\n}\r\n\r\n/**\r\n * Builds an import update fix when an existing import is compatible.\r\n * @param match Autofix context produced by the matcher.\r\n * @param sortedNames Sorted names that must be imported.\r\n * @param fixer ESLint fixer.\r\n * @returns Replacement fix when an import can be updated.\r\n * @example\r\n * ```typescript\r\n * const fix = buildImportUpdateFix({ importPlan: { moduleSpecifier: \"./x\", names: [] } } as never, [], {} as never);\r\n * void fix;\r\n * ```\r\n */\r\nfunction buildImportUpdateFix(\r\n  match: RuleMatch,\r\n  sortedNames: string[],\r\n  fixer: Rule.RuleFixer,\r\n): Rule.Fix | undefined {\r\n  const { moduleSpecifier, update } = match.importPlan;\r\n\r\n  if (update === void 0) {\r\n    return void 0;\r\n  }\r\n\r\n  const { defaultImportName, existingNamedImports, range } = update;\r\n  const mergedNames = [\r\n    ...new Set([...sortedNames, ...existingNamedImports]),\r\n  ].toSorted();\r\n  const statementText = buildImportStatement(\r\n    moduleSpecifier,\r\n    defaultImportName,\r\n    mergedNames,\r\n  );\r\n\r\n  return fixer.replaceTextRange(range, statementText);\r\n}\r\n\r\nexport { buildImportFixes, buildImportStatement };\r\n"]}