@codeperfect/eslint-plugin 2.4.0 → 2.6.0

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

@@ -0,0 +1,81 @@
+import type { Rule } from "eslint";
+import type { getFlattenedSections } from "../aaa/analyzer.analysis.helpers.js";
+import type { TestBlockAnalysis } from "../aaa/types.js";
+/** Flattened section entry emitted by the AAA analyzer helper. */
+type FlattenedSection = ReturnType<typeof getFlattenedSections>[number];
+/** Union of valid AAA phase labels emitted for flattened sections. */
+type FlattenedSectionPhase = FlattenedSection["phase"];
+/** Composite input for advancing the AAA section ordering state. */
+interface UpdateSectionOrderInput {
+    /** Active ESLint rule context. */
+    context: Rule.RuleContext;
+    /** Highest phase order seen so far. */
+    lastPhaseOrder: number;
+    /** Section comment and phase metadata under inspection. */
+    section: FlattenedSection;
+    /** Set of phases already seen in the current test block. */
+    seenPhases: Set<FlattenedSectionPhase>;
+}
+/**
+ * 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);
+ * ```
+ */
+declare function reportBlankLineSeparators(context: Rule.RuleContext, analysis: TestBlockAnalysis): void;
+/**
+ * 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);
+ * ```
+ */
+declare function reportCodeBeforeArrange(context: Rule.RuleContext, analysis: TestBlockAnalysis): void;
+/**
+ * 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);
+ * ```
+ */
+declare function reportEmptySections(context: Rule.RuleContext, analysis: TestBlockAnalysis): void;
+/**
+ * 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);
+ * ```
+ */
+declare function reportMissingSections(context: Rule.RuleContext, analysis: TestBlockAnalysis): void;
+/**
+ * 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);
+ * ```
+ */
+declare function reportOutOfOrderSections(context: Rule.RuleContext, analysis: TestBlockAnalysis): void;
+/**
+ * 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 never, seenPhases: new Set() });
+ * ```
+ */
+declare const updateSectionOrder: (input: UpdateSectionOrderInput) => number;
+export type { FlattenedSectionPhase };
+export { reportBlankLineSeparators, reportCodeBeforeArrange, reportEmptySections, reportMissingSections, reportOutOfOrderSections, updateSectionOrder, };
+//# sourceMappingURL=rule-section-reporting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule-section-reporting.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/rule-section-reporting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAC7E,OAAO,KAAK,EAAkB,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAUtE,kEAAkE;AAClE,KAAK,gBAAgB,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AAExE,sEAAsE;AACtE,KAAK,qBAAqB,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;AAcvD,oEAAoE;AACpE,UAAU,uBAAuB;IAC/B,kCAAkC;IAClC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC;IAE1B,uCAAuC;IACvC,cAAc,EAAE,MAAM,CAAC;IAEvB,2DAA2D;IAC3D,OAAO,EAAE,gBAAgB,CAAC;IAE1B,4DAA4D;IAC5D,UAAU,EAAE,GAAG,CAAC,qBAAqB,CAAC,CAAC;CACxC;AAED;;;;;;;;GAQG;AACH,iBAAS,yBAAyB,CAChC,OAAO,EAAE,IAAI,CAAC,WAAW,EACzB,QAAQ,EAAE,iBAAiB,GAC1B,IAAI,CAuBN;AAED;;;;;;;;GAQG;AACH,iBAAS,uBAAuB,CAC9B,OAAO,EAAE,IAAI,CAAC,WAAW,EACzB,QAAQ,EAAE,iBAAiB,GAC1B,IAAI,CAmBN;AAED;;;;;;;;GAQG;AACH,iBAAS,mBAAmB,CAC1B,OAAO,EAAE,IAAI,CAAC,WAAW,EACzB,QAAQ,EAAE,iBAAiB,GAC1B,IAAI,CAqBN;AAiCD;;;;;;;;GAQG;AACH,iBAAS,qBAAqB,CAC5B,OAAO,EAAE,IAAI,CAAC,WAAW,EACzB,QAAQ,EAAE,iBAAiB,GAC1B,IAAI,CA2BN;AAED;;;;;;;;GAQG;AACH,iBAAS,wBAAwB,CAC/B,OAAO,EAAE,IAAI,CAAC,WAAW,EACzB,QAAQ,EAAE,iBAAiB,GAC1B,IAAI,CAUN;AAoBD;;;;;;;;GAQG;AACH,QAAA,MAAM,kBAAkB,GAAI,OAAO,uBAAuB,KAAG,MAe5D,CAAC;AAEF,YAAY,EAAE,qBAAqB,EAAE,CAAC;AACtC,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,mBAAmB,EACnB,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,GACnB,CAAC"}

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

@@ -0,0 +1,181 @@
+import { aaaPhaseOrder, getLineStartRange, getPhaseBoundaryComments, } from "../aaa/analyzer.analysis.helpers.js";
+import { hasBlankLineBeforeComment } from "../aaa/analyzer.classification.helpers.js";
+import { buildMissingSectionFixes } from "./missing-section-fixes.js";
+/**
+ * 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);
+    }
+}
+/**
+ * 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 never });
+ * ```
+ */
+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 never, seenPhases: new Set() });
+ * ```
+ */
+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);
+};
+export { reportBlankLineSeparators, reportCodeBeforeArrange, reportEmptySections, reportMissingSections, reportOutOfOrderSections, updateSectionOrder, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule-section-reporting.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/rule-section-reporting.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { getFlattenedSections } from \"../aaa/analyzer.analysis.helpers\";\nimport type { SectionComment, TestBlockAnalysis } from \"../aaa/types\";\n\nimport {\n  aaaPhaseOrder,\n  getLineStartRange,\n  getPhaseBoundaryComments,\n} from \"../aaa/analyzer.analysis.helpers\";\nimport { hasBlankLineBeforeComment } from \"../aaa/analyzer.classification.helpers\";\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 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\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({ context: {} as Rule.RuleContext, messageId: \"duplicateSection\", section: {} as never });\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({ context: {} as Rule.RuleContext, lastPhaseOrder: -1, section: {} as never, seenPhases: new Set() });\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\nexport type { FlattenedSectionPhase };\nexport {\n  reportBlankLineSeparators,\n  reportCodeBeforeArrange,\n  reportEmptySections,\n  reportMissingSections,\n  reportOutOfOrderSections,\n  updateSectionOrder,\n};\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;AAuGnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAqEnC,CAAC;AA2MF,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;AAiBnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAoEnC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

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

@@ -1,86 +1,35 @@
 import { createRuleDocumentation } from "../../custom-rule-documentation.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 { getFlattenedSections } from "../aaa/analyzer.analysis.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.
- * @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);
-};
+import { reportBlankLineSeparators, reportCodeBeforeArrange, reportEmptySections, reportMissingSections, reportOutOfOrderSections, updateSectionOrder, } from "./rule-section-reporting.js";
 /** 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,
-                    });
-                }
-                reportMissingSections(context, analysis);
-                reportEmptySections(context, analysis);
-                reportOutOfOrderSections(context, analysis);
-                reportCodeBeforeArrange(context, analysis);
-                reportBlankLineSeparators(context, analysis);
-                reportPhasePurityViolations(context, analysis);
-            },
-        };
-    },
+    create: (context) => ({
+        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,
+                });
+            }
+            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 explicit AAA markers, enforce section order and uniqueness, and keep setup, action, and assertions in their intended phases."),
         fixable: "code",
@@ -105,143 +54,5 @@ const enforceAaaStructureRule = {
         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,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-structure/rule.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EACL,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,EAAE,2BAA2B,EAAE,MAAM,oDAAoD,CAAC;AACjG,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAmCnE;;;;;;;;;;;GAWG;AACH,MAAM,kBAAkB,GAAG,CAAC,KAA8B,EAAQ,EAAE;IAClE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,GAAG,KAAK,CAAC;IAE9C,OAAO,CAAC,MAAM,CAAC;QACb,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE;QAChC,SAAS;QACT,IAAI,EAAE,OAAO,CAAC,OAAO;KACtB,CAAC,CAAC;AACL,CAAC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,kBAAkB,GAAG,CAAC,KAA8B,EAAU,EAAE;IACpE,MAAM,EAAE,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,KAAK,CAAC;IAE/D,IAAI,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAClC,kBAAkB,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,OAAO,EAAE,CAAC,CAAC;QACxE,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,MAAM,iBAAiB,GAAG,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACvD,IAAI,iBAAiB,GAAG,cAAc,EAAE,CAAC;QACvC,kBAAkB,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,CAAC,CAAC;IACtE,CAAC;IAED,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC9B,OAAO,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,iBAAiB,CAAC,CAAC;AACrD,CAAC,CAAC;AAEF,kFAAkF;AAClF,MAAM,uBAAuB,GAAoB;IAC/C,MAAM,CAAC,OAAyB;QAC9B,OAAO;YACL,cAAc,CAAC,IAAI;gBACjB,MAAM,QAAQ,GAAG,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;gBACjD,IAAI,QAAQ,KAAK,KAAK,CAAC,EAAE,CAAC;oBACxB,OAAO;gBACT,CAAC;gBAED,MAAM,iBAAiB,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;gBACzD,MAAM,UAAU,GAAG,IAAI,GAAG,EAAyB,CAAC;gBACpD,IAAI,cAAc,GAAG,CAAC,CAAC,CAAC;gBAExB,KAAK,MAAM,OAAO,IAAI,iBAAiB,EAAE,CAAC;oBACxC,cAAc,GAAG,kBAAkB,CAAC;wBAClC,OAAO;wBACP,cAAc;wBACd,OAAO;wBACP,UAAU;qBACX,CAAC,CAAC;gBACL,CAAC;gBAED,qBAAqB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;gBACzC,mBAAmB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;gBACvC,wBAAwB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;gBAC5C,uBAAuB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;gBAC3C,yBAAyB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;gBAC7C,2BAA2B,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YACjD,CAAC;SAC0B,CAAC;IAChC,CAAC;IACD,IAAI,EAAE;QACJ,IAAI,EAAE,uBAAuB,CAC3B,uBAAuB,EACvB,sIAAsI,CACvI;QACD,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACR,eAAe,EACb,8EAA8E;YAChF,sBAAsB,EACpB,iFAAiF;YACnF,cAAc,EAAE,2CAA2C;YAC3D,eAAe,EAAE,2CAA2C;YAC5D,sBAAsB,EACpB,gEAAgE;YAClE,iBAAiB,EACf,mEAAmE;YACrE,gBAAgB,EACd,4DAA4D;YAC9D,YAAY,EACV,4EAA4E;YAC9E,YAAY,EACV,2FAA2F;YAC7F,oBAAoB,EAClB,gGAAgG;YAClG,eAAe,EAAE,qDAAqD;YACtE,gBAAgB,EACd,2DAA2D;YAC7D,oBAAoB,EAClB,8EAA8E;YAChF,iBAAiB,EACf,0DAA0D;YAC5D,aAAa,EACX,2EAA2E;SAC9E;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,SAAS;KAChB;CACF,CAAC;AAEF;;;;;;;;GAQG;AACH,SAAS,yBAAyB,CAChC,OAAyB,EACzB,QAA2B;IAE3B,MAAM,mBAAmB,GAAG,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC;IAEjE,KAAK,MAAM,cAAc,IAAI,wBAAwB,CAAC,QAAQ,CAAC,EAAE,CAAC;QAChE,IACE,cAAc,CAAC,OAAO,KAAK,mBAAmB;YAC9C,CAAC,yBAAyB,CAAC,QAAQ,CAAC,UAAU,EAAE,cAAc,CAAC,OAAO,CAAC,EACvE,CAAC;YACD,OAAO,CAAC,MAAM,CAAC;gBACb,IAAI,EAAE,EAAE,OAAO,EAAE,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;gBACpD,GAAG,EAAE,CAAC,KAAK,EAAE,EAAE,CACb,KAAK,CAAC,qBAAqB,CACzB,iBAAiB,CACf,QAAQ,CAAC,UAAU,EACnB,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CACtC,EACD,QAAQ,CAAC,OAAO,CACjB;gBACH,SAAS,EAAE,wBAAwB;gBACnC,IAAI,EAAE,cAAc,CAAC,OAAO;aAC7B,CAAC,CAAC;QACL,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,uBAAuB,CAC9B,OAAyB,EACzB,QAA2B;IAE3B,MAAM,gBAAgB,GAAG,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,cAAc,EAAE,EAAE,CACxE,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAC1C,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;IAC1B,IAAI,gBAAgB,KAAK,KAAK,CAAC,EAAE,CAAC;QAChC,OAAO;IACT,CAAC;IAED,MAAM,sBAAsB,GAAG,QAAQ,CAAC,UAAU,CAAC,IAAI,CACrD,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,GAAG,gBAAgB,CAChE,CAAC;IACF,IAAI,sBAAsB,KAAK,KAAK,CAAC,EAAE,CAAC;QACtC,OAAO;IACT,CAAC;IAED,OAAO,CAAC,MAAM,CAAC;QACb,SAAS,EAAE,mBAAmB;QAC9B,IAAI,EAAE,sBAAsB,CAAC,IAAI;KAClC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,mBAAmB,CAC1B,OAAyB,EACzB,QAA2B;IAE3B,KAAK,MAAM,CAAC,KAAK,EAAE,cAAc,CAAC,IAAI,QAAQ,CAAC,eAAe,CAAC,OAAO,EAAE,EAAE,CAAC;QACzE,MAAM,eAAe,GACnB,QAAQ,CAAC,eAAe,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;QAC9D,MAAM,gBAAgB,GAAG,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE;YAC9D,MAAM,aAAa,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;YAEpD,OAAO,CACL,aAAa,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI;gBACrD,CAAC,eAAe,KAAK,KAAK,CAAC,IAAI,aAAa,GAAG,eAAe,CAAC,CAChE,CAAC;QACJ,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,OAAO,CAAC,MAAM,CAAC;gBACb,IAAI,EAAE,EAAE,OAAO,EAAE,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;gBACpD,SAAS,EAAE,cAAc;gBACzB,IAAI,EAAE,cAAc,CAAC,OAAO;aAC7B,CAAC,CAAC;QACL,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,kBAAkB,CACzB,OAAyB,EACzB,QAAwB,EACxB,OAAuB;IAEvB,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,CAC/B,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CACxD,CAAC;IACF,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,CAC9B,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CACvD,CAAC;IAEF,IAAI,eAAe,IAAI,gBAAgB,EAAE,CAAC;QACxC,OAAO,CAAC,MAAM,CAAC;YACb,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;YAC7C,SAAS,EAAE,mBAAmB;YAC9B,IAAI,EAAE,OAAO,CAAC,OAAO;SACtB,CAAC,CAAC;IACL,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,qBAAqB,CAC5B,OAAyB,EACzB,QAA2B;IAE3B,MAAM,eAAe,GAAG,IAAI,GAAG,CAC7B,QAAQ,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,cAAc,EAAE,EAAE,CAAC,cAAc,CAAC,MAAM,CAAC,CAC5E,CAAC;IACF,MAAM,uBAAuB,GAAG,QAAQ,CAAC,UAAU,CAAC,IAAI,CACtD,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,CAC7C,CAAC;IACF,MAAM,eAAe,GAAI,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAW,CAAC,MAAM,CACpE,CAAC,KAAK,EAAE,EAAE,CACR,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC;QAC3B,CAAC,KAAK,KAAK,SAAS,IAAI,uBAAuB,CAAC,CACnD,CAAC;IAEF,IAAI,eAAe,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACjC,OAAO;IACT,CAAC;IAED,OAAO,CAAC,MAAM,CAAC;QACb,IAAI,EAAE,EAAE,QAAQ,EAAE,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;QAC9C,GAAG,EACD,QAAQ,CAAC,aAAa,IAAI,CAAC;YACzB,CAAC,CAAC,CAAC,KAAqB,EAAc,EAAE,CACpC,wBAAwB,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,CAAC;YAC9D,CAAC,CAAC,KAAK,CAAC;QACZ,SAAS,EAAE,iBAAiB;QAC5B,IAAI,EAAE,QAAQ,CAAC,cAAc;KAC9B,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,wBAAwB,CAC/B,OAAyB,EACzB,QAA2B;IAE3B,MAAM,QAAQ,GAAG,QAAQ,CAAC,eAAe,CAAC;IAC1C,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;IAEtC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,SAAS,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QAClD,MAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;QACjC,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QAEpC,IAAI,QAAQ,IAAI,OAAO;YAAE,kBAAkB,CAAC,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC1E,CAAC;AACH,CAAC;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAC","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"]}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kb21haW4vdGVzdGluZy9lbmZvcmNlLWFhYS1zdHJ1Y3R1cmUvcnVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUMxRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUN4RSxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvREFBb0QsQ0FBQztBQUNqRyxPQUFPLEVBQ0wseUJBQXlCLEVBQ3pCLHVCQUF1QixFQUN2QixtQkFBbUIsRUFDbkIscUJBQXFCLEVBQ3JCLHdCQUF3QixFQUN4QixrQkFBa0IsR0FDbkIsTUFBTSwwQkFBMEIsQ0FBQztBQUVsQyxrRkFBa0Y7QUFDbEYsTUFBTSx1QkFBdUIsR0FBb0I7SUFDL0MsTUFBTSxFQUFFLENBQUMsT0FBeUIsRUFBcUIsRUFBRSxDQUN2RCxDQUFDO1FBQ0MsY0FBYyxDQUFDLElBQUk7WUFDakIsTUFBTSxRQUFRLEdBQUcsZ0JBQWdCLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxDQUFDO1lBQ2pELElBQUksUUFBUSxLQUFLLEtBQUssQ0FBQyxFQUFFLENBQUM7Z0JBQ3hCLE9BQU87WUFDVCxDQUFDO1lBRUQsTUFBTSxpQkFBaUIsR0FBRyxvQkFBb0IsQ0FBQyxRQUFRLENBQUMsQ0FBQztZQUN6RCxNQUFNLFVBQVUsR0FBRyxJQUFJLEdBQUcsRUFBeUIsQ0FBQztZQUNwRCxJQUFJLGNBQWMsR0FBRyxDQUFDLENBQUMsQ0FBQztZQUV4QixLQUFLLE1BQU0sT0FBTyxJQUFJLGlCQUFpQixFQUFFLENBQUM7Z0JBQ3hDLGNBQWMsR0FBRyxrQkFBa0IsQ0FBQztvQkFDbEMsT0FBTztvQkFDUCxjQUFjO29CQUNkLE9BQU87b0JBQ1AsVUFBVTtpQkFDWCxDQUFDLENBQUM7WUFDTCxDQUFDO1lBRUQscUJBQXFCLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxDQUFDO1lBQ3pDLG1CQUFtQixDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQztZQUN2Qyx3QkFBd0IsQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUM7WUFDNUMsdUJBQXVCLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxDQUFDO1lBQzNDLHlCQUF5QixDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQztZQUM3QywyQkFBMkIsQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDakQsQ0FBQztLQUNGLENBQTZCO0lBQ2hDLElBQUksRUFBRTtRQUNKLElBQUksRUFBRSx1QkFBdUIsQ0FDM0IsdUJBQXVCLEVBQ3ZCLHNJQUFzSSxDQUN2STtRQUNELE9BQU8sRUFBRSxNQUFNO1FBQ2YsUUFBUSxFQUFFO1lBQ1IsZUFBZSxFQUNiLDhFQUE4RTtZQUNoRixzQkFBc0IsRUFDcEIsaUZBQWlGO1lBQ25GLGNBQWMsRUFBRSwyQ0FBMkM7WUFDM0QsZUFBZSxFQUFFLDJDQUEyQztZQUM1RCxzQkFBc0IsRUFDcEIsZ0VBQWdFO1lBQ2xFLGlCQUFpQixFQUNmLG1FQUFtRTtZQUNyRSxnQkFBZ0IsRUFDZCw0REFBNEQ7WUFDOUQsWUFBWSxFQUNWLDRFQUE0RTtZQUM5RSxZQUFZLEVBQ1YsMkZBQTJGO1lBQzdGLG9CQUFvQixFQUNsQixnR0FBZ0c7WUFDbEcsZUFBZSxFQUFFLHFEQUFxRDtZQUN0RSxnQkFBZ0IsRUFDZCwyREFBMkQ7WUFDN0Qsb0JBQW9CLEVBQ2xCLDhFQUE4RTtZQUNoRixpQkFBaUIsRUFDZiwwREFBMEQ7WUFDNUQsYUFBYSxFQUNYLDJFQUEyRTtTQUM5RTtRQUNELE1BQU0sRUFBRSxFQUFFO1FBQ1YsSUFBSSxFQUFFLFNBQVM7S0FDaEI7Q0FDRixDQUFDO0FBRUYsT0FBTyxFQUFFLHVCQUF1QixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFJ1bGUgfSBmcm9tIFwiZXNsaW50XCI7XG5cbmltcG9ydCB0eXBlIHsgRmxhdHRlbmVkU2VjdGlvblBoYXNlIH0gZnJvbSBcIi4vcnVsZS1zZWN0aW9uLXJlcG9ydGluZ1wiO1xuXG5pbXBvcnQgeyBjcmVhdGVSdWxlRG9jdW1lbnRhdGlvbiB9IGZyb20gXCIuLi8uLi9jdXN0b20tcnVsZS1kb2N1bWVudGF0aW9uXCI7XG5pbXBvcnQgeyBhbmFseXplVGVzdEJsb2NrIH0gZnJvbSBcIi4uL2FhYS9hbmFseXplci5hbmFseXNpc1wiO1xuaW1wb3J0IHsgZ2V0RmxhdHRlbmVkU2VjdGlvbnMgfSBmcm9tIFwiLi4vYWFhL2FuYWx5emVyLmFuYWx5c2lzLmhlbHBlcnNcIjtcbmltcG9ydCB7IHJlcG9ydFBoYXNlUHVyaXR5VmlvbGF0aW9ucyB9IGZyb20gXCIuLi9lbmZvcmNlLWFhYS1waGFzZS1wdXJpdHkvcGhhc2UtcHVyaXR5LXJlcG9ydGluZ1wiO1xuaW1wb3J0IHtcbiAgcmVwb3J0QmxhbmtMaW5lU2VwYXJhdG9ycyxcbiAgcmVwb3J0Q29kZUJlZm9yZUFycmFuZ2UsXG4gIHJlcG9ydEVtcHR5U2VjdGlvbnMsXG4gIHJlcG9ydE1pc3NpbmdTZWN0aW9ucyxcbiAgcmVwb3J0T3V0T2ZPcmRlclNlY3Rpb25zLFxuICB1cGRhdGVTZWN0aW9uT3JkZXIsXG59IGZyb20gXCIuL3J1bGUtc2VjdGlvbi1yZXBvcnRpbmdcIjtcblxuLyoqIEVuZm9yY2VzIGEgc2luZ2xlIEFycmFuZ2UvQWN0L0Fzc2VydCBzZXF1ZW5jZSBpbnNpZGUgc3VwcG9ydGVkIHRlc3QgYmxvY2tzLiAqL1xuY29uc3QgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGU6IFJ1bGUuUnVsZU1vZHVsZSA9IHtcbiAgY3JlYXRlOiAoY29udGV4dDogUnVsZS5SdWxlQ29udGV4dCk6IFJ1bGUuUnVsZUxpc3RlbmVyID0+XG4gICAgKHtcbiAgICAgIENhbGxFeHByZXNzaW9uKG5vZGUpOiB2b2lkIHtcbiAgICAgICAgY29uc3QgYW5hbHlzaXMgPSBhbmFseXplVGVzdEJsb2NrKGNvbnRleHQsIG5vZGUpO1xuICAgICAgICBpZiAoYW5hbHlzaXMgPT09IHZvaWQgMCkge1xuICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuXG4gICAgICAgIGNvbnN0IGZsYXR0ZW5lZFNlY3Rpb25zID0gZ2V0RmxhdHRlbmVkU2VjdGlvbnMoYW5hbHlzaXMpO1xuICAgICAgICBjb25zdCBzZWVuUGhhc2VzID0gbmV3IFNldDxGbGF0dGVuZWRTZWN0aW9uUGhhc2U+KCk7XG4gICAgICAgIGxldCBsYXN0UGhhc2VPcmRlciA9IC0xO1xuXG4gICAgICAgIGZvciAoY29uc3Qgc2VjdGlvbiBvZiBmbGF0dGVuZWRTZWN0aW9ucykge1xuICAgICAgICAgIGxhc3RQaGFzZU9yZGVyID0gdXBkYXRlU2VjdGlvbk9yZGVyKHtcbiAgICAgICAgICAgIGNvbnRleHQsXG4gICAgICAgICAgICBsYXN0UGhhc2VPcmRlcixcbiAgICAgICAgICAgIHNlY3Rpb24sXG4gICAgICAgICAgICBzZWVuUGhhc2VzLFxuICAgICAgICAgIH0pO1xuICAgICAgICB9XG5cbiAgICAgICAgcmVwb3J0TWlzc2luZ1NlY3Rpb25zKGNvbnRleHQsIGFuYWx5c2lzKTtcbiAgICAgICAgcmVwb3J0RW1wdHlTZWN0aW9ucyhjb250ZXh0LCBhbmFseXNpcyk7XG4gICAgICAgIHJlcG9ydE91dE9mT3JkZXJTZWN0aW9ucyhjb250ZXh0LCBhbmFseXNpcyk7XG4gICAgICAgIHJlcG9ydENvZGVCZWZvcmVBcnJhbmdlKGNvbnRleHQsIGFuYWx5c2lzKTtcbiAgICAgICAgcmVwb3J0QmxhbmtMaW5lU2VwYXJhdG9ycyhjb250ZXh0LCBhbmFseXNpcyk7XG4gICAgICAgIHJlcG9ydFBoYXNlUHVyaXR5VmlvbGF0aW9ucyhjb250ZXh0LCBhbmFseXNpcyk7XG4gICAgICB9LFxuICAgIH0pIHNhdGlzZmllcyBSdWxlLlJ1bGVMaXN0ZW5lcixcbiAgbWV0YToge1xuICAgIGRvY3M6IGNyZWF0ZVJ1bGVEb2N1bWVudGF0aW9uKFxuICAgICAgXCJlbmZvcmNlLWFhYS1zdHJ1Y3R1cmVcIixcbiAgICAgIFwiUmVxdWlyZSBleHBsaWNpdCBBQUEgbWFya2VycywgZW5mb3JjZSBzZWN0aW9uIG9yZGVyIGFuZCB1bmlxdWVuZXNzLCBhbmQga2VlcCBzZXR1cCwgYWN0aW9uLCBhbmQgYXNzZXJ0aW9ucyBpbiB0aGVpciBpbnRlbmRlZCBwaGFzZXMuXCIsXG4gICAgKSxcbiAgICBmaXhhYmxlOiBcImNvZGVcIixcbiAgICBtZXNzYWdlczoge1xuICAgICAgYWN0aW9uSW5BcnJhbmdlOlxuICAgICAgICBcIktlZXAgdGhlIGZ1bmN0aW9uIHVuZGVyIHRlc3Qgb3V0IG9mIEFycmFuZ2U7IHJlc2VydmUgQXJyYW5nZSBmb3Igc2V0dXAgb25seS5cIixcbiAgICAgIGFzc2VydGlvbk91dHNpZGVBc3NlcnQ6XG4gICAgICAgIFwiTW92ZSBhc3NlcnRpb25zIGludG8gdGhlIC8vIEFzc2VydCBzZWN0aW9uIHNvIHRlc3QgbG9naWMgZG9lcyBub3QgbGVhayBlYXJsaWVyLlwiLFxuICAgICAgYXN5bmNJbkFycmFuZ2U6IFwiRG8gbm90IHRyaWdnZXIgYXN5bmMgYmVoYXZpb3IgaW4gQXJyYW5nZS5cIixcbiAgICAgIGF3YWl0T3V0c2lkZUFjdDogXCJVc2UgYXdhaXQgb25seSBpbnNpZGUgdGhlIC8vIEFjdCBzZWN0aW9uLlwiLFxuICAgICAgYmxhbmtMaW5lQmVmb3JlU2VjdGlvbjpcbiAgICAgICAgXCJJbnNlcnQgYSBibGFuayBsaW5lIGJlZm9yZSB0aGUgLy8ge3tzZWN0aW9ufX0gc2VjdGlvbiBjb21tZW50LlwiLFxuICAgICAgY29kZUJlZm9yZUFycmFuZ2U6XG4gICAgICAgIFwiTW92ZSBzZXR1cCBzdGF0ZW1lbnRzIGJlbG93IHRoZSBmaXJzdCAvLyBBcnJhbmdlIHNlY3Rpb24gY29tbWVudC5cIixcbiAgICAgIGR1cGxpY2F0ZVNlY3Rpb246XG4gICAgICAgIFwiVXNlIHRoZSAvLyB7e3NlY3Rpb259fSBzZWN0aW9uIGNvbW1lbnQgb25seSBvbmNlIHBlciB0ZXN0LlwiLFxuICAgICAgZW1wdHlTZWN0aW9uOlxuICAgICAgICBcIlRoZSAvLyB7e3NlY3Rpb259fSBzZWN0aW9uIG11c3QgY29udGFpbiBjb2RlOyBjb21tZW50cyBhbG9uZSBkbyBub3QgY291bnQuXCIsXG4gICAgICBpbnZhbGlkT3JkZXI6XG4gICAgICAgIFwiTW92ZSB0aGUgLy8ge3tzZWN0aW9ufX0gc2VjdGlvbiBjb21tZW50IHNvIEFBQSBwaGFzZXMgc3RheSBpbiBBcnJhbmdlLCBBY3QsIEFzc2VydCBvcmRlci5cIixcbiAgICAgIG1pc3NpbmdNZWFuaW5nZnVsQWN0OlxuICAgICAgICBcIlRoZSAvLyBBY3Qgc2VjdGlvbiBtdXN0IGNvbnRhaW4gYSBtZWFuaW5nZnVsIFNVVCBpbnRlcmFjdGlvbiwgbm90IG9ubHkgdXRpbGl0eSBvciBzZXR1cCBjYWxscy5cIixcbiAgICAgIG1pc3NpbmdTZWN0aW9uczogXCJBZGQgdGhlIG1pc3NpbmcgQUFBIHNlY3Rpb24gY29tbWVudHM6IHt7c2VjdGlvbnN9fS5cIixcbiAgICAgIG11dGF0aW9uQWZ0ZXJBY3Q6XG4gICAgICAgIFwiRG8gbm90IG11dGF0ZSB0ZXN0IGRhdGEgYWZ0ZXIgdGhlIC8vIEFjdCBzZWN0aW9uIGhhcyBydW4uXCIsXG4gICAgICBub25Bc3NlcnRpb25JbkFzc2VydDpcbiAgICAgICAgXCJLZWVwIHRoZSAvLyBBc3NlcnQgc2VjdGlvbiBmb2N1c2VkIG9uIGFzc2VydGlvbnMgYW5kIGFzc2VydGlvbi1sb2NhbCB2YWx1ZXMuXCIsXG4gICAgICBvdXRPZk9yZGVyU2VjdGlvbjpcbiAgICAgICAgXCJUaGUgLy8ge3tzZWN0aW9ufX0gc2VjdGlvbiBjb21tZW50IGFwcGVhcnMgb3V0IG9mIG9yZGVyLlwiLFxuICAgICAgc2V0dXBBZnRlckFjdDpcbiAgICAgICAgXCJEbyBub3QgY29udGludWUgYXJyYW5naW5nIHRlc3QgZGF0YSBhZnRlciB0aGUgLy8gQWN0IHNlY3Rpb24gaGFzIHN0YXJ0ZWQuXCIsXG4gICAgfSxcbiAgICBzY2hlbWE6IFtdLFxuICAgIHR5cGU6IFwicHJvYmxlbVwiLFxuICB9LFxufTtcblxuZXhwb3J0IHsgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGUgfTtcbiJdfQ==