@codeperfect/eslint-plugin 2.0.0 → 2.2.0

package/dist/domain/testing/enforce-aaa-structure/missing-section-fixes.js

@@ -0,0 +1,150 @@
+import { aaaPhaseOrder, getLineStartRange, } from "../aaa/analyzer.analysis.helpers.js";
+/**
+ * Groups missing phases by insertion offset.
+ * @param anchors Anchor statements available for insertion.
+ * @param missingSections Missing AAA phases to insert.
+ * @returns Map of source offsets to phases that should be inserted there.
+ * @example
+ * ```typescript
+ * const anchorMap = buildAnchorMap({ firstStatement: { range: [0, 1] } as never, lastStatement: { range: [2, 3] } as never, middleStatement: { range: [1, 2] } as never }, ["Arrange"]);
+ * void anchorMap;
+ * ```
+ */
+function buildAnchorMap(anchors, missingSections) {
+    const anchorMap = new Map();
+    for (const phase of missingSections) {
+        const anchorNode = getAnchorNode(anchors, phase);
+        const existing = anchorMap.get(anchorNode.range[0]) ?? [];
+        existing.push(phase);
+        anchorMap.set(anchorNode.range[0], existing);
+    }
+    return anchorMap;
+}
+/**
+ * Builds one autofix that inserts missing section markers before a statement.
+ * @param input Composite input for one missing-section fix.
+ * @returns Fix that inserts the missing section marker text.
+ * @example
+ * ```typescript
+ * const fix = buildMissingSectionFix({ analysis: { newline: "\n", sourceText: "value" } as never, fixer: {} as never, offset: 0, phases: ["Arrange"] });
+ * void fix;
+ * ```
+ */
+function buildMissingSectionFix(input) {
+    const { analysis, fixer, offset, phases } = input;
+    const sourceLines = analysis.sourceText.split(/\r\n|\n/u);
+    const sortedPhases = phases.toSorted((left, right) => aaaPhaseOrder[left] - aaaPhaseOrder[right]);
+    const statementLine = analysis.sourceText
+        .slice(0, offset)
+        .split(/\r\n|\n/u).length;
+    const lineStartRange = getLineStartRange(analysis.sourceText, statementLine);
+    const [previousLine = ""] = statementLine > 1
+        ? sourceLines.slice(statementLine - 2, statementLine - 1)
+        : [];
+    const needsLeadingBlankLine = shouldInsertLeadingBlankLine(sortedPhases, previousLine);
+    const [currentLine = ""] = sourceLines.slice(statementLine - 1, statementLine);
+    const indentation = getLineIndentation(currentLine);
+    return fixer.insertTextBeforeRange(lineStartRange, `${needsLeadingBlankLine ? analysis.newline : ""}${indentation}// ${sortedPhases.join(" & ")}${analysis.newline}`);
+}
+/**
+ * Builds autofix edits for each missing AAA section marker.
+ * @param analysis Parsed test-block analysis.
+ * @param missingSections Missing AAA phases to insert.
+ * @param fixer ESLint fixer instance.
+ * @returns Fixes that add the missing section comments.
+ * @example
+ * ```typescript
+ * const fixes = buildMissingSectionFixes({ newline: "\n", sourceText: "value" } as never, ["Arrange"], {} as never);
+ * void fixes;
+ * ```
+ */
+function buildMissingSectionFixes(analysis, missingSections, fixer) {
+    const anchors = getSectionAnchors(analysis);
+    if (anchors === void 0) {
+        return [];
+    }
+    return [...buildAnchorMap(anchors, missingSections).entries()].map(([offset, phases]) => buildMissingSectionFix({ analysis, fixer, offset, phases }));
+}
+/**
+ * Selects the anchor statement used for one missing AAA phase.
+ * @param anchors Anchor statements available for insertion.
+ * @param phase Missing phase being inserted.
+ * @returns Statement node used as the insertion anchor.
+ * @example
+ * ```typescript
+ * const anchor = getAnchorNode({ firstStatement: {} as never, lastStatement: {} as never, middleStatement: {} as never }, "Arrange");
+ * void anchor;
+ * ```
+ */
+function getAnchorNode(anchors, phase) {
+    switch (phase) {
+        case "Act": {
+            return anchors.middleStatement;
+        }
+        case "Arrange": {
+            return anchors.firstStatement;
+        }
+        case "Assert": {
+            return anchors.lastStatement;
+        }
+        default: {
+            return anchors.lastStatement;
+        }
+    }
+}
+/**
+ * Reads the indentation prefix from a source line.
+ * @param lineText Source line text.
+ * @returns Leading whitespace for the line.
+ * @example
+ * ```typescript
+ * const indentation = getLineIndentation("  value");
+ * void indentation;
+ * ```
+ */
+function getLineIndentation(lineText) {
+    const trimmedLine = lineText.trimStart();
+    return lineText.slice(0, lineText.length - trimmedLine.length);
+}
+/**
+ * Selects the statement nodes used as insertion anchors for missing sections.
+ * @param analysis Parsed test-block analysis.
+ * @returns Anchor statements for Arrange, Act, and Assert insertion.
+ * @example
+ * ```typescript
+ * const anchors = getSectionAnchors({ statements: [] } as never);
+ * void anchors;
+ * ```
+ */
+function getSectionAnchors(analysis) {
+    const [firstStatementEntry] = analysis.statements;
+    const middleStatementEntry = analysis.statements[Math.min(analysis.statements.length - 1, Math.floor(analysis.statements.length / 2))];
+    const lastStatementEntry = analysis.statements.at(-1);
+    if (firstStatementEntry === void 0 ||
+        middleStatementEntry === void 0 ||
+        lastStatementEntry === void 0) {
+        return void 0;
+    }
+    return {
+        firstStatement: firstStatementEntry.node,
+        lastStatement: lastStatementEntry.node,
+        middleStatement: middleStatementEntry.node,
+    };
+}
+/**
+ * Determines whether a missing section insertion needs a blank line prefix.
+ * @param phases Missing phases inserted at the same offset.
+ * @param previousLine Source line immediately above the insertion point.
+ * @returns Whether the inserted marker should start with a blank line.
+ * @example
+ * ```typescript
+ * const actual = shouldInsertLeadingBlankLine(["Act"], "run();");
+ * void actual;
+ * ```
+ */
+function shouldInsertLeadingBlankLine(phases, previousLine) {
+    return (phases.some((phase) => phase !== "Arrange") &&
+        previousLine.trim().length > 0);
+}
+export { buildMissingSectionFixes };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"missing-section-fixes.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/missing-section-fixes.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { AaaPhase, TestBlockAnalysis } from \"../aaa/types\";\n\nimport {\n  aaaPhaseOrder,\n  getLineStartRange,\n} from \"../aaa/analyzer.analysis.helpers\";\n\n/** Composite input for building one missing-section fix. */\ninterface MissingSectionFixInput {\n  /** Parsed test-block analysis. */\n  analysis: TestBlockAnalysis;\n\n  /** ESLint fixer instance. */\n  fixer: Rule.RuleFixer;\n\n  /** Source offset where the section marker should be inserted. */\n  offset: number;\n\n  /** Missing phases that share the same insertion offset. */\n  phases: readonly AaaPhase[];\n}\n\n/** Anchor statements used to place missing AAA section comments. */\ninterface StatementAnchors {\n  /** First statement available for an Arrange insertion. */\n  firstStatement: TestBlockAnalysis[\"statements\"][number][\"node\"];\n\n  /** Last statement available for an Assert insertion. */\n  lastStatement: TestBlockAnalysis[\"statements\"][number][\"node\"];\n\n  /** Middle statement available for an Act insertion. */\n  middleStatement: TestBlockAnalysis[\"statements\"][number][\"node\"];\n}\n\n/**\n * Groups missing phases by insertion offset.\n * @param anchors Anchor statements available for insertion.\n * @param missingSections Missing AAA phases to insert.\n * @returns Map of source offsets to phases that should be inserted there.\n * @example\n * ```typescript\n * const anchorMap = buildAnchorMap({ firstStatement: { range: [0, 1] } as never, lastStatement: { range: [2, 3] } as never, middleStatement: { range: [1, 2] } as never }, [\"Arrange\"]);\n * void anchorMap;\n * ```\n */\nfunction buildAnchorMap(\n  anchors: StatementAnchors,\n  missingSections: readonly AaaPhase[],\n): Map<number, AaaPhase[]> {\n  const anchorMap = new Map<number, AaaPhase[]>();\n\n  for (const phase of missingSections) {\n    const anchorNode = getAnchorNode(anchors, phase);\n    const existing = anchorMap.get(anchorNode.range[0]) ?? [];\n\n    existing.push(phase);\n    anchorMap.set(anchorNode.range[0], existing);\n  }\n\n  return anchorMap;\n}\n\n/**\n * Builds one autofix that inserts missing section markers before a statement.\n * @param input Composite input for one missing-section fix.\n * @returns Fix that inserts the missing section marker text.\n * @example\n * ```typescript\n * const fix = buildMissingSectionFix({ analysis: { newline: \"\\n\", sourceText: \"value\" } as never, fixer: {} as never, offset: 0, phases: [\"Arrange\"] });\n * void fix;\n * ```\n */\nfunction buildMissingSectionFix(input: MissingSectionFixInput): Rule.Fix {\n  const { analysis, fixer, offset, phases } = input;\n  const sourceLines = analysis.sourceText.split(/\\r\\n|\\n/u);\n  const sortedPhases = phases.toSorted(\n    (left, right) => aaaPhaseOrder[left] - aaaPhaseOrder[right],\n  );\n  const statementLine = analysis.sourceText\n    .slice(0, offset)\n    .split(/\\r\\n|\\n/u).length;\n  const lineStartRange = getLineStartRange(analysis.sourceText, statementLine);\n  const [previousLine = \"\"] =\n    statementLine > 1\n      ? sourceLines.slice(statementLine - 2, statementLine - 1)\n      : [];\n  const needsLeadingBlankLine = shouldInsertLeadingBlankLine(\n    sortedPhases,\n    previousLine,\n  );\n  const [currentLine = \"\"] = sourceLines.slice(\n    statementLine - 1,\n    statementLine,\n  );\n  const indentation = getLineIndentation(currentLine);\n\n  return fixer.insertTextBeforeRange(\n    lineStartRange,\n    `${needsLeadingBlankLine ? analysis.newline : \"\"}${indentation}// ${sortedPhases.join(\" & \")}${analysis.newline}`,\n  );\n}\n\n/**\n * Builds autofix edits for each missing AAA section marker.\n * @param analysis Parsed test-block analysis.\n * @param missingSections Missing AAA phases to insert.\n * @param fixer ESLint fixer instance.\n * @returns Fixes that add the missing section comments.\n * @example\n * ```typescript\n * const fixes = buildMissingSectionFixes({ newline: \"\\n\", sourceText: \"value\" } as never, [\"Arrange\"], {} as never);\n * void fixes;\n * ```\n */\nfunction buildMissingSectionFixes(\n  analysis: TestBlockAnalysis,\n  missingSections: readonly AaaPhase[],\n  fixer: Rule.RuleFixer,\n): Rule.Fix[] {\n  const anchors = getSectionAnchors(analysis);\n\n  if (anchors === void 0) {\n    return [];\n  }\n\n  return [...buildAnchorMap(anchors, missingSections).entries()].map(\n    ([offset, phases]) =>\n      buildMissingSectionFix({ analysis, fixer, offset, phases }),\n  );\n}\n\n/**\n * Selects the anchor statement used for one missing AAA phase.\n * @param anchors Anchor statements available for insertion.\n * @param phase Missing phase being inserted.\n * @returns Statement node used as the insertion anchor.\n * @example\n * ```typescript\n * const anchor = getAnchorNode({ firstStatement: {} as never, lastStatement: {} as never, middleStatement: {} as never }, \"Arrange\");\n * void anchor;\n * ```\n */\nfunction getAnchorNode(\n  anchors: StatementAnchors,\n  phase: AaaPhase,\n): StatementAnchors[keyof StatementAnchors] {\n  switch (phase) {\n    case \"Act\": {\n      return anchors.middleStatement;\n    }\n    case \"Arrange\": {\n      return anchors.firstStatement;\n    }\n    case \"Assert\": {\n      return anchors.lastStatement;\n    }\n    default: {\n      return anchors.lastStatement;\n    }\n  }\n}\n\n/**\n * Reads the indentation prefix from a source line.\n * @param lineText Source line text.\n * @returns Leading whitespace for the line.\n * @example\n * ```typescript\n * const indentation = getLineIndentation(\"  value\");\n * void indentation;\n * ```\n */\nfunction getLineIndentation(lineText: string): string {\n  const trimmedLine = lineText.trimStart();\n\n  return lineText.slice(0, lineText.length - trimmedLine.length);\n}\n\n/**\n * Selects the statement nodes used as insertion anchors for missing sections.\n * @param analysis Parsed test-block analysis.\n * @returns Anchor statements for Arrange, Act, and Assert insertion.\n * @example\n * ```typescript\n * const anchors = getSectionAnchors({ statements: [] } as never);\n * void anchors;\n * ```\n */\nfunction getSectionAnchors(\n  analysis: TestBlockAnalysis,\n): StatementAnchors | undefined {\n  const [firstStatementEntry] = analysis.statements;\n  const middleStatementEntry =\n    analysis.statements[\n      Math.min(\n        analysis.statements.length - 1,\n        Math.floor(analysis.statements.length / 2),\n      )\n    ];\n  const lastStatementEntry = analysis.statements.at(-1);\n\n  if (\n    firstStatementEntry === void 0 ||\n    middleStatementEntry === void 0 ||\n    lastStatementEntry === void 0\n  ) {\n    return void 0;\n  }\n\n  return {\n    firstStatement: firstStatementEntry.node,\n    lastStatement: lastStatementEntry.node,\n    middleStatement: middleStatementEntry.node,\n  };\n}\n\n/**\n * Determines whether a missing section insertion needs a blank line prefix.\n * @param phases Missing phases inserted at the same offset.\n * @param previousLine Source line immediately above the insertion point.\n * @returns Whether the inserted marker should start with a blank line.\n * @example\n * ```typescript\n * const actual = shouldInsertLeadingBlankLine([\"Act\"], \"run();\");\n * void actual;\n * ```\n */\nfunction shouldInsertLeadingBlankLine(\n  phases: readonly AaaPhase[],\n  previousLine: string,\n): boolean {\n  return (\n    phases.some((phase) => phase !== \"Arrange\") &&\n    previousLine.trim().length > 0\n  );\n}\n\nexport { buildMissingSectionFixes };\n"]}

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

@@ -1 +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;AAsFnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAsCnC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}
+{"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;AAuGnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAqEnC,CAAC;AA2MF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

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

@@ -1,5 +1,9 @@
 import { createRuleDocumentation } from "../../custom-rule-documentation.js";
-import { aaaPhaseOrder, analyzeTestBlock, getFlattenedSections } from "../aaa/index.js";
+import { analyzeTestBlock } from "../aaa/analyzer.analysis.js";
+import { aaaPhaseOrder, getFlattenedSections, getLineStartRange, getPhaseBoundaryComments, } from "../aaa/analyzer.analysis.helpers.js";
+import { hasBlankLineBeforeComment } from "../aaa/analyzer.classification.helpers.js";
+import { reportPhasePurityViolations } from "../enforce-aaa-phase-purity/phase-purity-reporting.js";
+import { buildMissingSectionFixes } from "./missing-section-fixes.js";
 /**
  * Reports a duplicate or out-of-order AAA section comment.
  * @param input Composite reporting input for the current section.
@@ -68,18 +72,176 @@ const enforceAaaStructureRule = {
                         seenPhases,
                     });
                 }
+                reportMissingSections(context, analysis);
+                reportEmptySections(context, analysis);
+                reportOutOfOrderSections(context, analysis);
+                reportCodeBeforeArrange(context, analysis);
+                reportBlankLineSeparators(context, analysis);
+                reportPhasePurityViolations(context, analysis);
             },
         };
     },
     meta: {
-        docs: createRuleDocumentation("enforce-aaa-structure", "Require AAA sections to appear once and in Arrange, Act, Assert order."),
+        docs: createRuleDocumentation("enforce-aaa-structure", "Require explicit AAA markers, enforce section order and uniqueness, and keep setup, action, and assertions in their intended phases."),
+        fixable: "code",
         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.",
+            blankLineBeforeSection: "Insert a blank line before the // {{section}} section comment.",
+            codeBeforeArrange: "Move setup statements below the first // Arrange section comment.",
             duplicateSection: "Use the // {{section}} section comment only once per test.",
+            emptySection: "The // {{section}} section must contain code; comments alone do not count.",
             invalidOrder: "Move the // {{section}} section comment so AAA phases stay in Arrange, Act, Assert order.",
+            missingMeaningfulAct: "The // Act section must contain a meaningful SUT interaction, not only utility or setup calls.",
+            missingSections: "Add the missing AAA section comments: {{sections}}.",
+            mutationAfterAct: "Do not mutate test data after the // Act section has run.",
+            nonAssertionInAssert: "Keep the // Assert section focused on assertions and assertion-local values.",
+            outOfOrderSection: "The // {{section}} section comment appears out of order.",
+            setupAfterAct: "Do not continue arranging test data after the // Act section has started.",
         },
         schema: [],
         type: "problem",
     },
 };
+/**
+ * Reports section comments that are missing a blank line above them.
+ * @param context ESLint rule context.
+ * @param analysis Parsed test-block analysis.
+ * @example
+ * ```typescript
+ * reportBlankLineSeparators({ report() {} } as never, { sectionComments: [], sourceText: "" } as never);
+ * ```
+ */
+function reportBlankLineSeparators(context, analysis) {
+    const firstSectionComment = analysis.sectionComments[0]?.comment;
+    for (const sectionComment of getPhaseBoundaryComments(analysis)) {
+        if (sectionComment.comment !== firstSectionComment &&
+            !hasBlankLineBeforeComment(analysis.sourceText, sectionComment.comment)) {
+            context.report({
+                data: { section: sectionComment.phases.join(" & ") },
+                fix: (fixer) => fixer.insertTextBeforeRange(getLineStartRange(analysis.sourceText, sectionComment.comment.loc.start.line), analysis.newline),
+                messageId: "blankLineBeforeSection",
+                node: sectionComment.comment,
+            });
+        }
+    }
+}
+/**
+ * Reports executable statements that appear before the first Arrange section.
+ * @param context ESLint rule context.
+ * @param analysis Parsed test-block analysis.
+ * @example
+ * ```typescript
+ * reportCodeBeforeArrange({ report() {} } as never, { sectionComments: [], statements: [] } as never);
+ * ```
+ */
+function reportCodeBeforeArrange(context, analysis) {
+    const firstArrangeLine = analysis.sectionComments.find((sectionComment) => sectionComment.phases.includes("Arrange"))?.comment.loc.start.line;
+    if (firstArrangeLine === void 0) {
+        return;
+    }
+    const statementBeforeArrange = analysis.statements.find((statement) => statement.node.loc.start.line < firstArrangeLine);
+    if (statementBeforeArrange === void 0) {
+        return;
+    }
+    context.report({
+        messageId: "codeBeforeArrange",
+        node: statementBeforeArrange.node,
+    });
+}
+/**
+ * Reports sections that contain only comments or whitespace.
+ * @param context ESLint rule context.
+ * @param analysis Parsed test-block analysis.
+ * @example
+ * ```typescript
+ * reportEmptySections({ report() {} } as never, { sectionComments: [], statements: [] } as never);
+ * ```
+ */
+function reportEmptySections(context, analysis) {
+    for (const [index, sectionComment] of analysis.sectionComments.entries()) {
+        const nextSectionLine = analysis.sectionComments[index + 1]?.comment.loc.start.line;
+        const hasCodeInSection = analysis.statements.some((statement) => {
+            const statementLine = statement.node.loc.start.line;
+            return (statementLine > sectionComment.comment.loc.start.line &&
+                (nextSectionLine === void 0 || statementLine < nextSectionLine));
+        });
+        if (!hasCodeInSection) {
+            context.report({
+                data: { section: sectionComment.phases.join(" & ") },
+                messageId: "emptySection",
+                node: sectionComment.comment,
+            });
+        }
+    }
+}
+/**
+ * Reports a single out-of-order section pair.
+ * @param context ESLint rule context.
+ * @param previous Previous section comment.
+ * @param current Current section comment.
+ * @example
+ * ```typescript
+ * reportIfOutOfOrder({ report() {} } as never, { comment: {} as never, phases: [] }, { comment: {} as never, phases: [] });
+ * ```
+ */
+function reportIfOutOfOrder(context, previous, current) {
+    const maxPreviousOrder = Math.max(...previous.phases.map((phase) => aaaPhaseOrder[phase]));
+    const minCurrentOrder = Math.min(...current.phases.map((phase) => aaaPhaseOrder[phase]));
+    if (minCurrentOrder <= maxPreviousOrder) {
+        context.report({
+            data: { section: current.phases.join(" & ") },
+            messageId: "outOfOrderSection",
+            node: current.comment,
+        });
+    }
+}
+/**
+ * Reports any AAA section markers that are missing from a supported test block.
+ * @param context ESLint rule context.
+ * @param analysis Parsed test-block analysis.
+ * @example
+ * ```typescript
+ * reportMissingSections({ report() {} } as never, { sectionComments: [] } as never);
+ * ```
+ */
+function reportMissingSections(context, analysis) {
+    const presentSections = new Set(analysis.sectionComments.flatMap((sectionComment) => sectionComment.phases));
+    const hasPreSectionStatements = analysis.statements.some((statement) => statement.phases.length === 0);
+    const missingSections = ["Arrange", "Act", "Assert"].filter((phase) => !presentSections.has(phase) &&
+        (phase !== "Arrange" || hasPreSectionStatements));
+    if (missingSections.length === 0) {
+        return;
+    }
+    context.report({
+        data: { sections: missingSections.join(", ") },
+        fix: analysis.bodyLineCount >= 3
+            ? (fixer) => buildMissingSectionFixes(analysis, missingSections, fixer)
+            : void 0,
+        messageId: "missingSections",
+        node: analysis.callExpression,
+    });
+}
+/**
+ * Reports section comments that appear out of canonical Arrange -> Act -> Assert order.
+ * @param context ESLint rule context.
+ * @param analysis Parsed test-block analysis.
+ * @example
+ * ```typescript
+ * reportOutOfOrderSections({ report() {} } as never, { sectionComments: [] } as never);
+ * ```
+ */
+function reportOutOfOrderSections(context, analysis) {
+    const comments = analysis.sectionComments;
+    const lastIndex = comments.length - 1;
+    for (let index = 0; index < lastIndex; index += 1) {
+        const previous = comments[index];
+        const current = comments[index + 1];
+        if (previous && current)
+            reportIfOutOfOrder(context, previous, current);
+    }
+}
 export { enforceAaaStructureRule };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kb21haW4vdGVzdGluZy9lbmZvcmNlLWFhYS1zdHJ1Y3R1cmUvcnVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUMxRSxPQUFPLEVBQUUsYUFBYSxFQUFFLGdCQUFnQixFQUFFLG9CQUFvQixFQUFFLE1BQU0sUUFBUSxDQUFDO0FBNkIvRTs7Ozs7Ozs7Ozs7R0FXRztBQUNILE1BQU0sa0JBQWtCLEdBQUcsQ0FBQyxLQUE4QixFQUFRLEVBQUU7SUFDbEUsTUFBTSxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLEdBQUcsS0FBSyxDQUFDO0lBRTlDLE9BQU8sQ0FBQyxNQUFNLENBQUM7UUFDYixJQUFJLEVBQUUsRUFBRSxPQUFPLEVBQUUsT0FBTyxDQUFDLEtBQUssRUFBRTtRQUNoQyxTQUFTO1FBQ1QsSUFBSSxFQUFFLE9BQU8sQ0FBQyxPQUFPO0tBQ3RCLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQztBQUVGOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gsTUFBTSxrQkFBa0IsR0FBRyxDQUFDLEtBQThCLEVBQVUsRUFBRTtJQUNwRSxNQUFNLEVBQUUsT0FBTyxFQUFFLGNBQWMsRUFBRSxPQUFPLEVBQUUsVUFBVSxFQUFFLEdBQUcsS0FBSyxDQUFDO0lBRS9ELElBQUksVUFBVSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUNsQyxrQkFBa0IsQ0FBQyxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsa0JBQWtCLEVBQUUsT0FBTyxFQUFFLENBQUMsQ0FBQztRQUN4RSxPQUFPLGNBQWMsQ0FBQztJQUN4QixDQUFDO0lBRUQsTUFBTSxpQkFBaUIsR0FBRyxhQUFhLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3ZELElBQUksaUJBQWlCLEdBQUcsY0FBYyxFQUFFLENBQUM7UUFDdkMsa0JBQWtCLENBQUMsRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUFFLGNBQWMsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDO0lBQ3RFLENBQUM7SUFFRCxVQUFVLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM5QixPQUFPLElBQUksQ0FBQyxHQUFHLENBQUMsY0FBYyxFQUFFLGlCQUFpQixDQUFDLENBQUM7QUFDckQsQ0FBQyxDQUFDO0FBRUYsa0ZBQWtGO0FBQ2xGLE1BQU0sdUJBQXVCLEdBQW9CO0lBQy9DLE1BQU0sQ0FBQyxPQUF5QjtRQUM5QixPQUFPO1lBQ0wsY0FBYyxDQUFDLElBQUk7Z0JBQ2pCLE1BQU0sUUFBUSxHQUFHLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxJQUFJLENBQUMsQ0FBQztnQkFDakQsSUFBSSxRQUFRLEtBQUssS0FBSyxDQUFDLEVBQUUsQ0FBQztvQkFDeEIsT0FBTztnQkFDVCxDQUFDO2dCQUVELE1BQU0saUJBQWlCLEdBQUcsb0JBQW9CLENBQUMsUUFBUSxDQUFDLENBQUM7Z0JBQ3pELE1BQU0sVUFBVSxHQUFHLElBQUksR0FBRyxFQUFVLENBQUM7Z0JBQ3JDLElBQUksY0FBYyxHQUFHLENBQUMsQ0FBQyxDQUFDO2dCQUV4QixLQUFLLE1BQU0sT0FBTyxJQUFJLGlCQUFpQixFQUFFLENBQUM7b0JBQ3hDLGNBQWMsR0FBRyxrQkFBa0IsQ0FBQzt3QkFDbEMsT0FBTzt3QkFDUCxjQUFjO3dCQUNkLE9BQU87d0JBQ1AsVUFBVTtxQkFDWCxDQUFDLENBQUM7Z0JBQ0wsQ0FBQztZQUNILENBQUM7U0FDMEIsQ0FBQztJQUNoQyxDQUFDO0lBQ0QsSUFBSSxFQUFFO1FBQ0osSUFBSSxFQUFFLHVCQUF1QixDQUMzQix1QkFBdUIsRUFDdkIsd0VBQXdFLENBQ3pFO1FBQ0QsUUFBUSxFQUFFO1lBQ1IsZ0JBQWdCLEVBQ2QsNERBQTREO1lBQzlELFlBQVksRUFDViwyRkFBMkY7U0FDOUY7UUFDRCxNQUFNLEVBQUUsRUFBRTtRQUNWLElBQUksRUFBRSxTQUFTO0tBQ2hCO0NBQ0YsQ0FBQztBQUVGLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBSdWxlIH0gZnJvbSBcImVzbGludFwiO1xuXG5pbXBvcnQgeyBjcmVhdGVSdWxlRG9jdW1lbnRhdGlvbiB9IGZyb20gXCIuLi8uLi9jdXN0b20tcnVsZS1kb2N1bWVudGF0aW9uXCI7XG5pbXBvcnQgeyBhYWFQaGFzZU9yZGVyLCBhbmFseXplVGVzdEJsb2NrLCBnZXRGbGF0dGVuZWRTZWN0aW9ucyB9IGZyb20gXCIuLi9hYWFcIjtcblxuLyoqIENvbXBvc2l0ZSBpbnB1dCBmb3IgcmVwb3J0aW5nIG9uZSBBQUEgc2VjdGlvbiBpc3N1ZS4gKi9cbmludGVyZmFjZSBSZXBvcnRTZWN0aW9uSXNzdWVJbnB1dCB7XG4gIC8qKiBBY3RpdmUgRVNMaW50IHJ1bGUgY29udGV4dC4gKi9cbiAgY29udGV4dDogUnVsZS5SdWxlQ29udGV4dDtcblxuICAvKiogTWVzc2FnZSBpZGVudGlmaWVyIHRvIHJlcG9ydCBmb3IgdGhlIHNlY3Rpb24uICovXG4gIG1lc3NhZ2VJZDogXCJkdXBsaWNhdGVTZWN0aW9uXCIgfCBcImludmFsaWRPcmRlclwiO1xuXG4gIC8qKiBTZWN0aW9uIGNvbW1lbnQgYW5kIHBoYXNlIG1ldGFkYXRhIHVuZGVyIGluc3BlY3Rpb24uICovXG4gIHNlY3Rpb246IFJldHVyblR5cGU8dHlwZW9mIGdldEZsYXR0ZW5lZFNlY3Rpb25zPltudW1iZXJdO1xufVxuXG4vKiogQ29tcG9zaXRlIGlucHV0IGZvciBhZHZhbmNpbmcgdGhlIEFBQSBzZWN0aW9uIG9yZGVyaW5nIHN0YXRlLiAqL1xuaW50ZXJmYWNlIFVwZGF0ZVNlY3Rpb25PcmRlcklucHV0IHtcbiAgLyoqIEFjdGl2ZSBFU0xpbnQgcnVsZSBjb250ZXh0LiAqL1xuICBjb250ZXh0OiBSdWxlLlJ1bGVDb250ZXh0O1xuXG4gIC8qKiBIaWdoZXN0IHBoYXNlIG9yZGVyIHNlZW4gc28gZmFyLiAqL1xuICBsYXN0UGhhc2VPcmRlcjogbnVtYmVyO1xuXG4gIC8qKiBTZWN0aW9uIGNvbW1lbnQgYW5kIHBoYXNlIG1ldGFkYXRhIHVuZGVyIGluc3BlY3Rpb24uICovXG4gIHNlY3Rpb246IFJldHVyblR5cGU8dHlwZW9mIGdldEZsYXR0ZW5lZFNlY3Rpb25zPltudW1iZXJdO1xuXG4gIC8qKiBTZXQgb2YgcGhhc2VzIGFscmVhZHkgc2VlbiBpbiB0aGUgY3VycmVudCB0ZXN0IGJsb2NrLiAqL1xuICBzZWVuUGhhc2VzOiBTZXQ8c3RyaW5nPjtcbn1cblxuLyoqXG4gKiBSZXBvcnRzIGEgZHVwbGljYXRlIG9yIG91dC1vZi1vcmRlciBBQUEgc2VjdGlvbiBjb21tZW50LlxuICogQHBhcmFtIGlucHV0IENvbXBvc2l0ZSByZXBvcnRpbmcgaW5wdXQgZm9yIHRoZSBjdXJyZW50IHNlY3Rpb24uXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogcmVwb3J0U2VjdGlvbklzc3VlKHtcbiAqICAgY29udGV4dDoge30gYXMgUnVsZS5SdWxlQ29udGV4dCxcbiAqICAgbWVzc2FnZUlkOiBcImR1cGxpY2F0ZVNlY3Rpb25cIixcbiAqICAgc2VjdGlvbjoge30gYXMgUmV0dXJuVHlwZTx0eXBlb2YgZ2V0RmxhdHRlbmVkU2VjdGlvbnM+W251bWJlcl0sXG4gKiB9KTtcbiAqIGBgYFxuICovXG5jb25zdCByZXBvcnRTZWN0aW9uSXNzdWUgPSAoaW5wdXQ6IFJlcG9ydFNlY3Rpb25Jc3N1ZUlucHV0KTogdm9pZCA9PiB7XG4gIGNvbnN0IHsgY29udGV4dCwgbWVzc2FnZUlkLCBzZWN0aW9uIH0gPSBpbnB1dDtcblxuICBjb250ZXh0LnJlcG9ydCh7XG4gICAgZGF0YTogeyBzZWN0aW9uOiBzZWN0aW9uLnBoYXNlIH0sXG4gICAgbWVzc2FnZUlkLFxuICAgIG5vZGU6IHNlY3Rpb24uY29tbWVudCxcbiAgfSk7XG59O1xuXG4vKipcbiAqIFRyYWNrcyB0aGUgY3VycmVudCBBQUEgb3JkZXJpbmcgc3RhdGUgZm9yIG9uZSBmbGF0dGVuZWQgc2VjdGlvbi5cbiAqIEBwYXJhbSBpbnB1dCBDb21wb3NpdGUgb3JkZXJpbmcgc3RhdGUgZm9yIHRoZSBjdXJyZW50IHNlY3Rpb24uXG4gKiBAcmV0dXJucyBVcGRhdGVkIHBoYXNlIG9yZGVyIHdhdGVybWFyay5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBjb25zdCBuZXh0T3JkZXIgPSB1cGRhdGVTZWN0aW9uT3JkZXIoe1xuICogICBjb250ZXh0OiB7fSBhcyBSdWxlLlJ1bGVDb250ZXh0LFxuICogICBsYXN0UGhhc2VPcmRlcjogLTEsXG4gKiAgIHNlY3Rpb246IHt9IGFzIFJldHVyblR5cGU8dHlwZW9mIGdldEZsYXR0ZW5lZFNlY3Rpb25zPltudW1iZXJdLFxuICogICBzZWVuUGhhc2VzOiBuZXcgU2V0KCksXG4gKiB9KTtcbiAqIHZvaWQgbmV4dE9yZGVyO1xuICogYGBgXG4gKi9cbmNvbnN0IHVwZGF0ZVNlY3Rpb25PcmRlciA9IChpbnB1dDogVXBkYXRlU2VjdGlvbk9yZGVySW5wdXQpOiBudW1iZXIgPT4ge1xuICBjb25zdCB7IGNvbnRleHQsIGxhc3RQaGFzZU9yZGVyLCBzZWN0aW9uLCBzZWVuUGhhc2VzIH0gPSBpbnB1dDtcblxuICBpZiAoc2VlblBoYXNlcy5oYXMoc2VjdGlvbi5waGFzZSkpIHtcbiAgICByZXBvcnRTZWN0aW9uSXNzdWUoeyBjb250ZXh0LCBtZXNzYWdlSWQ6IFwiZHVwbGljYXRlU2VjdGlvblwiLCBzZWN0aW9uIH0pO1xuICAgIHJldHVybiBsYXN0UGhhc2VPcmRlcjtcbiAgfVxuXG4gIGNvbnN0IGN1cnJlbnRQaGFzZU9yZGVyID0gYWFhUGhhc2VPcmRlcltzZWN0aW9uLnBoYXNlXTtcbiAgaWYgKGN1cnJlbnRQaGFzZU9yZGVyIDwgbGFzdFBoYXNlT3JkZXIpIHtcbiAgICByZXBvcnRTZWN0aW9uSXNzdWUoeyBjb250ZXh0LCBtZXNzYWdlSWQ6IFwiaW52YWxpZE9yZGVyXCIsIHNlY3Rpb24gfSk7XG4gIH1cblxuICBzZWVuUGhhc2VzLmFkZChzZWN0aW9uLnBoYXNlKTtcbiAgcmV0dXJuIE1hdGgubWF4KGxhc3RQaGFzZU9yZGVyLCBjdXJyZW50UGhhc2VPcmRlcik7XG59O1xuXG4vKiogRW5mb3JjZXMgYSBzaW5nbGUgQXJyYW5nZS9BY3QvQXNzZXJ0IHNlcXVlbmNlIGluc2lkZSBzdXBwb3J0ZWQgdGVzdCBibG9ja3MuICovXG5jb25zdCBlbmZvcmNlQWFhU3RydWN0dXJlUnVsZTogUnVsZS5SdWxlTW9kdWxlID0ge1xuICBjcmVhdGUoY29udGV4dDogUnVsZS5SdWxlQ29udGV4dCk6IFJ1bGUuUnVsZUxpc3RlbmVyIHtcbiAgICByZXR1cm4ge1xuICAgICAgQ2FsbEV4cHJlc3Npb24obm9kZSk6IHZvaWQge1xuICAgICAgICBjb25zdCBhbmFseXNpcyA9IGFuYWx5emVUZXN0QmxvY2soY29udGV4dCwgbm9kZSk7XG4gICAgICAgIGlmIChhbmFseXNpcyA9PT0gdm9pZCAwKSB7XG4gICAgICAgICAgcmV0dXJuO1xuICAgICAgICB9XG5cbiAgICAgICAgY29uc3QgZmxhdHRlbmVkU2VjdGlvbnMgPSBnZXRGbGF0dGVuZWRTZWN0aW9ucyhhbmFseXNpcyk7XG4gICAgICAgIGNvbnN0IHNlZW5QaGFzZXMgPSBuZXcgU2V0PHN0cmluZz4oKTtcbiAgICAgICAgbGV0IGxhc3RQaGFzZU9yZGVyID0gLTE7XG5cbiAgICAgICAgZm9yIChjb25zdCBzZWN0aW9uIG9mIGZsYXR0ZW5lZFNlY3Rpb25zKSB7XG4gICAgICAgICAgbGFzdFBoYXNlT3JkZXIgPSB1cGRhdGVTZWN0aW9uT3JkZXIoe1xuICAgICAgICAgICAgY29udGV4dCxcbiAgICAgICAgICAgIGxhc3RQaGFzZU9yZGVyLFxuICAgICAgICAgICAgc2VjdGlvbixcbiAgICAgICAgICAgIHNlZW5QaGFzZXMsXG4gICAgICAgICAgfSk7XG4gICAgICAgIH1cbiAgICAgIH0sXG4gICAgfSBzYXRpc2ZpZXMgUnVsZS5SdWxlTGlzdGVuZXI7XG4gIH0sXG4gIG1ldGE6IHtcbiAgICBkb2NzOiBjcmVhdGVSdWxlRG9jdW1lbnRhdGlvbihcbiAgICAgIFwiZW5mb3JjZS1hYWEtc3RydWN0dXJlXCIsXG4gICAgICBcIlJlcXVpcmUgQUFBIHNlY3Rpb25zIHRvIGFwcGVhciBvbmNlIGFuZCBpbiBBcnJhbmdlLCBBY3QsIEFzc2VydCBvcmRlci5cIixcbiAgICApLFxuICAgIG1lc3NhZ2VzOiB7XG4gICAgICBkdXBsaWNhdGVTZWN0aW9uOlxuICAgICAgICBcIlVzZSB0aGUgLy8ge3tzZWN0aW9ufX0gc2VjdGlvbiBjb21tZW50IG9ubHkgb25jZSBwZXIgdGVzdC5cIixcbiAgICAgIGludmFsaWRPcmRlcjpcbiAgICAgICAgXCJNb3ZlIHRoZSAvLyB7e3NlY3Rpb259fSBzZWN0aW9uIGNvbW1lbnQgc28gQUFBIHBoYXNlcyBzdGF5IGluIEFycmFuZ2UsIEFjdCwgQXNzZXJ0IG9yZGVyLlwiLFxuICAgIH0sXG4gICAgc2NoZW1hOiBbXSxcbiAgICB0eXBlOiBcInByb2JsZW1cIixcbiAgfSxcbn07XG5cbmV4cG9ydCB7IGVuZm9yY2VBYWFTdHJ1Y3R1cmVSdWxlIH07XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { SectionComment, TestBlockAnalysis } from \"../aaa/types\";\n\nimport { createRuleDocumentation } from \"../../custom-rule-documentation\";\nimport { analyzeTestBlock } from \"../aaa/analyzer.analysis\";\nimport {\n  aaaPhaseOrder,\n  getFlattenedSections,\n  getLineStartRange,\n  getPhaseBoundaryComments,\n} from \"../aaa/analyzer.analysis.helpers\";\nimport { hasBlankLineBeforeComment } from \"../aaa/analyzer.classification.helpers\";\nimport { reportPhasePurityViolations } from \"../enforce-aaa-phase-purity/phase-purity-reporting\";\nimport { buildMissingSectionFixes } from \"./missing-section-fixes\";\n\n/** Flattened section entry emitted by the AAA analyzer helper. */\ntype FlattenedSection = ReturnType<typeof getFlattenedSections>[number];\n\n/** Union of valid AAA phase labels emitted for flattened sections. */\ntype FlattenedSectionPhase = FlattenedSection[\"phase\"];\n\n/** Composite input for reporting one AAA section issue. */\ninterface ReportSectionIssueInput {\n  /** Active ESLint rule context. */\n  context: Rule.RuleContext;\n\n  /** Message identifier to report for the section. */\n  messageId: \"duplicateSection\" | \"invalidOrder\";\n\n  /** Section comment and phase metadata under inspection. */\n  section: FlattenedSection;\n}\n\n/** Composite input for advancing the AAA section ordering state. */\ninterface UpdateSectionOrderInput {\n  /** Active ESLint rule context. */\n  context: Rule.RuleContext;\n\n  /** Highest phase order seen so far. */\n  lastPhaseOrder: number;\n\n  /** Section comment and phase metadata under inspection. */\n  section: FlattenedSection;\n\n  /** Set of phases already seen in the current test block. */\n  seenPhases: Set<FlattenedSectionPhase>;\n}\n\n/**\n * Reports a duplicate or out-of-order AAA section comment.\n * @param input Composite reporting input for the current section.\n * @example\n * ```typescript\n * reportSectionIssue({\n *   context: {} as Rule.RuleContext,\n *   messageId: \"duplicateSection\",\n *   section: {} as ReturnType<typeof getFlattenedSections>[number],\n * });\n * ```\n */\nconst reportSectionIssue = (input: ReportSectionIssueInput): void => {\n  const { context, messageId, section } = input;\n\n  context.report({\n    data: { section: section.phase },\n    messageId,\n    node: section.comment,\n  });\n};\n\n/**\n * Tracks the current AAA ordering state for one flattened section.\n * @param input Composite ordering state for the current section.\n * @returns Updated phase order watermark.\n * @example\n * ```typescript\n * const nextOrder = updateSectionOrder({\n *   context: {} as Rule.RuleContext,\n *   lastPhaseOrder: -1,\n *   section: {} as ReturnType<typeof getFlattenedSections>[number],\n *   seenPhases: new Set(),\n * });\n * void nextOrder;\n * ```\n */\nconst updateSectionOrder = (input: UpdateSectionOrderInput): number => {\n  const { context, lastPhaseOrder, section, seenPhases } = input;\n\n  if (seenPhases.has(section.phase)) {\n    reportSectionIssue({ context, messageId: \"duplicateSection\", section });\n    return lastPhaseOrder;\n  }\n\n  const currentPhaseOrder = aaaPhaseOrder[section.phase];\n  if (currentPhaseOrder < lastPhaseOrder) {\n    reportSectionIssue({ context, messageId: \"invalidOrder\", section });\n  }\n\n  seenPhases.add(section.phase);\n  return Math.max(lastPhaseOrder, currentPhaseOrder);\n};\n\n/** Enforces a single Arrange/Act/Assert sequence inside supported test blocks. */\nconst enforceAaaStructureRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    return {\n      CallExpression(node): void {\n        const analysis = analyzeTestBlock(context, node);\n        if (analysis === void 0) {\n          return;\n        }\n\n        const flattenedSections = getFlattenedSections(analysis);\n        const seenPhases = new Set<FlattenedSectionPhase>();\n        let lastPhaseOrder = -1;\n\n        for (const section of flattenedSections) {\n          lastPhaseOrder = updateSectionOrder({\n            context,\n            lastPhaseOrder,\n            section,\n            seenPhases,\n          });\n        }\n\n        reportMissingSections(context, analysis);\n        reportEmptySections(context, analysis);\n        reportOutOfOrderSections(context, analysis);\n        reportCodeBeforeArrange(context, analysis);\n        reportBlankLineSeparators(context, analysis);\n        reportPhasePurityViolations(context, analysis);\n      },\n    } satisfies Rule.RuleListener;\n  },\n  meta: {\n    docs: createRuleDocumentation(\n      \"enforce-aaa-structure\",\n      \"Require explicit AAA markers, enforce section order and uniqueness, and keep setup, action, and assertions in their intended phases.\",\n    ),\n    fixable: \"code\",\n    messages: {\n      actionInArrange:\n        \"Keep the function under test out of Arrange; reserve Arrange for setup only.\",\n      assertionOutsideAssert:\n        \"Move assertions into the // Assert section so test logic does not leak earlier.\",\n      asyncInArrange: \"Do not trigger async behavior in Arrange.\",\n      awaitOutsideAct: \"Use await only inside the // Act section.\",\n      blankLineBeforeSection:\n        \"Insert a blank line before the // {{section}} section comment.\",\n      codeBeforeArrange:\n        \"Move setup statements below the first // Arrange section comment.\",\n      duplicateSection:\n        \"Use the // {{section}} section comment only once per test.\",\n      emptySection:\n        \"The // {{section}} section must contain code; comments alone do not count.\",\n      invalidOrder:\n        \"Move the // {{section}} section comment so AAA phases stay in Arrange, Act, Assert order.\",\n      missingMeaningfulAct:\n        \"The // Act section must contain a meaningful SUT interaction, not only utility or setup calls.\",\n      missingSections: \"Add the missing AAA section comments: {{sections}}.\",\n      mutationAfterAct:\n        \"Do not mutate test data after the // Act section has run.\",\n      nonAssertionInAssert:\n        \"Keep the // Assert section focused on assertions and assertion-local values.\",\n      outOfOrderSection:\n        \"The // {{section}} section comment appears out of order.\",\n      setupAfterAct:\n        \"Do not continue arranging test data after the // Act section has started.\",\n    },\n    schema: [],\n    type: \"problem\",\n  },\n};\n\n/**\n * Reports section comments that are missing a blank line above them.\n * @param context ESLint rule context.\n * @param analysis Parsed test-block analysis.\n * @example\n * ```typescript\n * reportBlankLineSeparators({ report() {} } as never, { sectionComments: [], sourceText: \"\" } as never);\n * ```\n */\nfunction reportBlankLineSeparators(\n  context: Rule.RuleContext,\n  analysis: TestBlockAnalysis,\n): void {\n  const firstSectionComment = analysis.sectionComments[0]?.comment;\n\n  for (const sectionComment of getPhaseBoundaryComments(analysis)) {\n    if (\n      sectionComment.comment !== firstSectionComment &&\n      !hasBlankLineBeforeComment(analysis.sourceText, sectionComment.comment)\n    ) {\n      context.report({\n        data: { section: sectionComment.phases.join(\" & \") },\n        fix: (fixer) =>\n          fixer.insertTextBeforeRange(\n            getLineStartRange(\n              analysis.sourceText,\n              sectionComment.comment.loc.start.line,\n            ),\n            analysis.newline,\n          ),\n        messageId: \"blankLineBeforeSection\",\n        node: sectionComment.comment,\n      });\n    }\n  }\n}\n\n/**\n * Reports executable statements that appear before the first Arrange section.\n * @param context ESLint rule context.\n * @param analysis Parsed test-block analysis.\n * @example\n * ```typescript\n * reportCodeBeforeArrange({ report() {} } as never, { sectionComments: [], statements: [] } as never);\n * ```\n */\nfunction reportCodeBeforeArrange(\n  context: Rule.RuleContext,\n  analysis: TestBlockAnalysis,\n): void {\n  const firstArrangeLine = analysis.sectionComments.find((sectionComment) =>\n    sectionComment.phases.includes(\"Arrange\"),\n  )?.comment.loc.start.line;\n  if (firstArrangeLine === void 0) {\n    return;\n  }\n\n  const statementBeforeArrange = analysis.statements.find(\n    (statement) => statement.node.loc.start.line < firstArrangeLine,\n  );\n  if (statementBeforeArrange === void 0) {\n    return;\n  }\n\n  context.report({\n    messageId: \"codeBeforeArrange\",\n    node: statementBeforeArrange.node,\n  });\n}\n\n/**\n * Reports sections that contain only comments or whitespace.\n * @param context ESLint rule context.\n * @param analysis Parsed test-block analysis.\n * @example\n * ```typescript\n * reportEmptySections({ report() {} } as never, { sectionComments: [], statements: [] } as never);\n * ```\n */\nfunction reportEmptySections(\n  context: Rule.RuleContext,\n  analysis: TestBlockAnalysis,\n): void {\n  for (const [index, sectionComment] of analysis.sectionComments.entries()) {\n    const nextSectionLine =\n      analysis.sectionComments[index + 1]?.comment.loc.start.line;\n    const hasCodeInSection = analysis.statements.some((statement) => {\n      const statementLine = statement.node.loc.start.line;\n\n      return (\n        statementLine > sectionComment.comment.loc.start.line &&\n        (nextSectionLine === void 0 || statementLine < nextSectionLine)\n      );\n    });\n\n    if (!hasCodeInSection) {\n      context.report({\n        data: { section: sectionComment.phases.join(\" & \") },\n        messageId: \"emptySection\",\n        node: sectionComment.comment,\n      });\n    }\n  }\n}\n\n/**\n * Reports a single out-of-order section pair.\n * @param context ESLint rule context.\n * @param previous Previous section comment.\n * @param current Current section comment.\n * @example\n * ```typescript\n * reportIfOutOfOrder({ report() {} } as never, { comment: {} as never, phases: [] }, { comment: {} as never, phases: [] });\n * ```\n */\nfunction reportIfOutOfOrder(\n  context: Rule.RuleContext,\n  previous: SectionComment,\n  current: SectionComment,\n): void {\n  const maxPreviousOrder = Math.max(\n    ...previous.phases.map((phase) => aaaPhaseOrder[phase]),\n  );\n  const minCurrentOrder = Math.min(\n    ...current.phases.map((phase) => aaaPhaseOrder[phase]),\n  );\n\n  if (minCurrentOrder <= maxPreviousOrder) {\n    context.report({\n      data: { section: current.phases.join(\" & \") },\n      messageId: \"outOfOrderSection\",\n      node: current.comment,\n    });\n  }\n}\n\n/**\n * Reports any AAA section markers that are missing from a supported test block.\n * @param context ESLint rule context.\n * @param analysis Parsed test-block analysis.\n * @example\n * ```typescript\n * reportMissingSections({ report() {} } as never, { sectionComments: [] } as never);\n * ```\n */\nfunction reportMissingSections(\n  context: Rule.RuleContext,\n  analysis: TestBlockAnalysis,\n): void {\n  const presentSections = new Set(\n    analysis.sectionComments.flatMap((sectionComment) => sectionComment.phases),\n  );\n  const hasPreSectionStatements = analysis.statements.some(\n    (statement) => statement.phases.length === 0,\n  );\n  const missingSections = ([\"Arrange\", \"Act\", \"Assert\"] as const).filter(\n    (phase) =>\n      !presentSections.has(phase) &&\n      (phase !== \"Arrange\" || hasPreSectionStatements),\n  );\n\n  if (missingSections.length === 0) {\n    return;\n  }\n\n  context.report({\n    data: { sections: missingSections.join(\", \") },\n    fix:\n      analysis.bodyLineCount >= 3\n        ? (fixer: Rule.RuleFixer): Rule.Fix[] =>\n            buildMissingSectionFixes(analysis, missingSections, fixer)\n        : void 0,\n    messageId: \"missingSections\",\n    node: analysis.callExpression,\n  });\n}\n\n/**\n * Reports section comments that appear out of canonical Arrange -> Act -> Assert order.\n * @param context ESLint rule context.\n * @param analysis Parsed test-block analysis.\n * @example\n * ```typescript\n * reportOutOfOrderSections({ report() {} } as never, { sectionComments: [] } as never);\n * ```\n */\nfunction reportOutOfOrderSections(\n  context: Rule.RuleContext,\n  analysis: TestBlockAnalysis,\n): void {\n  const comments = analysis.sectionComments;\n  const lastIndex = comments.length - 1;\n\n  for (let index = 0; index < lastIndex; index += 1) {\n    const previous = comments[index];\n    const current = comments[index + 1];\n\n    if (previous && current) reportIfOutOfOrder(context, previous, current);\n  }\n}\n\nexport { enforceAaaStructureRule };\n"]}

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

@@ -1,9 +1,6 @@
 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";

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

@@ -1 +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"}
+{"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,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AACrE,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

@@ -1,10 +1,7 @@
 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==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLDZCQUE2QixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDL0UsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDbEUsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDckUsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDM0UsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDcEUsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sd0JBQXdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBhc3NlcnRBY3R1YWxFeHBlY3RlZE5hbWVzUnVsZSB9IGZyb20gXCIuL2Fzc2VydC1hY3R1YWwtZXhwZWN0ZWQtbmFtZXNcIjtcbmV4cG9ydCB7IGVuZm9yY2VBYWFTdHJ1Y3R1cmVSdWxlIH0gZnJvbSBcIi4vZW5mb3JjZS1hYWEtc3RydWN0dXJlXCI7XG5leHBvcnQgeyBwcmVmZXJWaU1vY2tlZEltcG9ydFJ1bGUgfSBmcm9tIFwiLi9wcmVmZXItdmktbW9ja2VkLWltcG9ydFwiO1xuZXhwb3J0IHsgcmVxdWlyZUFjdFJlc3VsdENhcHR1cmVSdWxlIH0gZnJvbSBcIi4vcmVxdWlyZS1hY3QtcmVzdWx0LWNhcHR1cmVcIjtcbmV4cG9ydCB7IHJlcXVpcmVUZXN0Q29tcGFuaW9uUnVsZSB9IGZyb20gXCIuL3JlcXVpcmUtdGVzdC1jb21wYW5pb25cIjtcbmV4cG9ydCB7IHNpbmdsZUFjdFN0YXRlbWVudFJ1bGUgfSBmcm9tIFwiLi9zaW5nbGUtYWN0LXN0YXRlbWVudFwiO1xuIl19

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

@@ -1,17 +1,3 @@
-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.
@@ -25,5 +11,5 @@ declare function buildImportFixes(match: RuleMatch, fixer: Rule.RuleFixer): Rule
  * ```
  */
 declare function buildImportStatement(moduleSpecifier: string, defaultImportName: string | undefined, names: readonly string[]): string;
-export { buildImportFixes, buildImportStatement };
+export { buildImportStatement };
 //# sourceMappingURL=fix-import-statements.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"fix-import-statements.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix-import-statements.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,iBAAS,oBAAoB,CAC3B,eAAe,EAAE,MAAM,EACvB,iBAAiB,EAAE,MAAM,GAAG,SAAS,EACrC,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,MAAM,CAOR;AAED,OAAO,EAAE,oBAAoB,EAAE,CAAC"}

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

@@ -1,48 +1,3 @@
-/**
- * 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.
@@ -62,29 +17,5 @@ function buildImportStatement(moduleSpecifier, defaultImportName, names) {
         ? `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"]}
+export { buildImportStatement };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"fix-imports.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix-imports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAsDzC;;;;;;;;;;GAUG;AACH,iBAAS,wBAAwB,CAC/B,OAAO,EAAE,SAAS,EAAE,EACpB,KAAK,EAAE,IAAI,CAAC,SAAS,GACpB,IAAI,CAAC,GAAG,EAAE,CASZ;AAoND,OAAO,EAAE,wBAAwB,EAAE,CAAC"}
+{"version":3,"file":"fix-imports.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vi-mocked-import/fix-imports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAGnC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAsDzC;;;;;;;;;;GAUG;AACH,iBAAS,wBAAwB,CAC/B,OAAO,EAAE,SAAS,EAAE,EACpB,KAAK,EAAE,IAAI,CAAC,SAAS,GACpB,IAAI,CAAC,GAAG,EAAE,CASZ;AAsND,OAAO,EAAE,wBAAwB,EAAE,CAAC"}