@codeperfect/eslint-plugin 1.0.0 → 2.1.0

package/dist/domain/testing/require-aaa-sections/rule.reporting.d.ts

@@ -0,0 +1,104 @@
+import type { Rule } from "eslint";
+import type { TestBlockAnalysis } from "../aaa/index.js";
+/** Mocked AAA helper exports consumed by the rule. */
+interface AaaModuleMock {
+    /** Mocked analyzer entry point. */
+    analyzeTestBlock: () => TestBlockAnalysis;
+    /** Mocked line-start helper. */
+    getLineStartRange: () => [number, number];
+    /** Mocked boundary-comment helper. */
+    getPhaseBoundaryComments: (analysis: TestBlockAnalysis) => TestBlockAnalysis["sectionComments"];
+    /** Mocked blank-line helper. */
+    hasBlankLineBeforeComment: () => false;
+}
+/** Mocked missing-section-fixes module. */
+interface MissingSectionFixesModule {
+    /** Mocked fix builder. */
+    buildMissingSectionFixes: () => Rule.Fix[];
+}
+/** Message identifiers emitted by the rule under test. */
+type RequireAaaSectionsMessageId = "blankLineBeforeSection" | "codeBeforeArrange" | "emptySection" | "missingSections";
+/** Captured result from the mocked reporting scenario. */
+interface ScenarioResult {
+    /** Fix emitted for the blank-line report. */
+    blankLineFix: Rule.Fix | Rule.Fix[] | undefined;
+    /** Fixes recorded by the synthetic fixer. */
+    insertedFixes: Rule.Fix[];
+    /** Message identifiers emitted in report order. */
+    messageIds: (RequireAaaSectionsMessageId | undefined)[];
+    /** Fix emitted for the missing-sections report. */
+    missingSectionsFix: Rule.Fix | Rule.Fix[] | undefined;
+}
+/**
+ * Creates the mocked AAA helper module.
+ * @returns Mocked exports consumed by the rule module.
+ * @example
+ * ```typescript
+ * const mockModule = createAaaModuleMock(); void mockModule;
+ * ```
+ */
+declare function createAaaModuleMock(): AaaModuleMock;
+/**
+ * Creates the mocked missing-section-fixes module.
+ * @param buildMissingSectionFixes Mocked fix builder.
+ * @returns Mocked module exposing the provided fix builder.
+ * @example
+ * ```typescript
+ * const mockModule = createMissingSectionFixesModule(() => []); void mockModule;
+ * ```
+ */
+declare function createMissingSectionFixesModule(buildMissingSectionFixes: () => Rule.Fix[]): MissingSectionFixesModule;
+/**
+ * Creates a fixer that records inserted text edits.
+ * @param insertedFixes Collection updated when the fixer inserts text.
+ * @returns Rule fixer that records inserted edits.
+ * @example
+ * ```typescript
+ * const fixer = createRecordedFixer([]); void fixer;
+ * ```
+ */
+declare function createRecordedFixer(insertedFixes: Rule.Fix[]): Rule.RuleFixer;
+/**
+ * Creates the minimal rule context used by the mocked scenario.
+ * @param reports Report descriptors captured during rule execution.
+ * @returns Rule context that records emitted reports.
+ * @example
+ * ```typescript
+ * const context = createRuleContext([]); void context;
+ * ```
+ */
+declare function createRuleContext(reports: Rule.ReportDescriptor[]): Rule.RuleContext;
+/**
+ * Reads the fix emitted by a report descriptor.
+ * @param descriptor Report descriptor to evaluate.
+ * @param fixer Synthetic fixer passed into the descriptor callback.
+ * @returns Fix output produced by the descriptor.
+ * @example
+ * ```typescript
+ * const fix = getDescriptorFix(void 0, {} as never); void fix;
+ * ```
+ */
+declare function getDescriptorFix(descriptor: Rule.ReportDescriptor | undefined, fixer: Rule.RuleFixer): Rule.Fix | Rule.Fix[] | undefined;
+/**
+ * Reads the message identifier from a report descriptor when present.
+ * @param descriptor Report descriptor emitted by the rule.
+ * @returns Supported message identifier when present.
+ * @example
+ * ```typescript
+ * const messageId = getReportMessageId({ messageId: "missingSections" } as Rule.ReportDescriptor);
+ * void messageId;
+ * ```
+ */
+declare function getReportMessageId(descriptor: Rule.ReportDescriptor): RequireAaaSectionsMessageId | undefined;
+/**
+ * Loads the rule module after test mocks have been applied.
+ * @returns The rule module under test.
+ * @example
+ * ```typescript
+ * const rule = await loadRequireAaaSectionsRule(); void rule;
+ * ```
+ */
+declare function loadRequireAaaSectionsRule(): Promise<Rule.RuleModule>;
+export { createAaaModuleMock, createMissingSectionFixesModule, createRecordedFixer, createRuleContext, getDescriptorFix, getReportMessageId, loadRequireAaaSectionsRule, };
+export type { ScenarioResult };
+//# sourceMappingURL=rule.reporting.d.ts.map

package/dist/domain/testing/require-aaa-sections/rule.reporting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.reporting.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/require-aaa-sections/rule.reporting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAEhD,sDAAsD;AACtD,UAAU,aAAa;IACrB,mCAAmC;IACnC,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;IAC1C,gCAAgC;IAChC,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,sCAAsC;IACtC,wBAAwB,EAAE,CACxB,QAAQ,EAAE,iBAAiB,KACxB,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;IAC1C,gCAAgC;IAChC,yBAAyB,EAAE,MAAM,KAAK,CAAC;CACxC;AAED,2CAA2C;AAC3C,UAAU,yBAAyB;IACjC,0BAA0B;IAC1B,wBAAwB,EAAE,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC;CAC5C;AAED,0DAA0D;AAC1D,KAAK,2BAA2B,GAC5B,wBAAwB,GACxB,mBAAmB,GACnB,cAAc,GACd,iBAAiB,CAAC;AAEtB,0DAA0D;AAC1D,UAAU,cAAc;IACtB,6CAA6C;IAC7C,YAAY,EAAE,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;IAChD,6CAA6C;IAC7C,aAAa,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC;IAC1B,mDAAmD;IACnD,UAAU,EAAE,CAAC,2BAA2B,GAAG,SAAS,CAAC,EAAE,CAAC;IACxD,mDAAmD;IACnD,kBAAkB,EAAE,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;CACvD;AAcD;;;;;;;GAOG;AACH,iBAAS,mBAAmB,IAAI,aAAa,CAO5C;AAED;;;;;;;;GAQG;AACH,iBAAS,+BAA+B,CACtC,wBAAwB,EAAE,MAAM,IAAI,CAAC,GAAG,EAAE,GACzC,yBAAyB,CAE3B;AAsDD;;;;;;;;GAQG;AACH,iBAAS,mBAAmB,CAAC,aAAa,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAQtE;AAED;;;;;;;;GAQG;AACH,iBAAS,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,GAAG,IAAI,CAAC,WAAW,CAM7E;AAED;;;;;;;;;GASG;AACH,iBAAS,gBAAgB,CACvB,UAAU,EAAE,IAAI,CAAC,gBAAgB,GAAG,SAAS,EAC7C,KAAK,EAAE,IAAI,CAAC,SAAS,GACpB,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAcnC;AA8BD;;;;;;;;;GASG;AACH,iBAAS,kBAAkB,CACzB,UAAU,EAAE,IAAI,CAAC,gBAAgB,GAChC,2BAA2B,GAAG,SAAS,CAQzC;AAuBD;;;;;;;GAOG;AACH,iBAAe,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,CAGpE;AAED,OAAO,EACL,mBAAmB,EACnB,+BAA+B,EAC/B,mBAAmB,EACnB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,GAC3B,CAAC;AAEF,YAAY,EAAE,cAAc,EAAE,CAAC"}

package/dist/domain/testing/require-aaa-sections/rule.reporting.js

@@ -0,0 +1,216 @@
+/**
+ * Returns false so the mocked rule path always reports a missing blank line.
+ * @returns False for every invocation.
+ * @example
+ * ```typescript
+ * const actual = alwaysReturnFalse(); void actual;
+ * ```
+ */
+function alwaysReturnFalse() {
+    return false;
+}
+/**
+ * Creates the mocked AAA helper module.
+ * @returns Mocked exports consumed by the rule module.
+ * @example
+ * ```typescript
+ * const mockModule = createAaaModuleMock(); void mockModule;
+ * ```
+ */
+function createAaaModuleMock() {
+    return {
+        analyzeTestBlock: createMockAnalysis,
+        getLineStartRange: getMockLineStartRange,
+        getPhaseBoundaryComments: getMockPhaseBoundaryComments,
+        hasBlankLineBeforeComment: alwaysReturnFalse,
+    };
+}
+/**
+ * Creates the mocked missing-section-fixes module.
+ * @param buildMissingSectionFixes Mocked fix builder.
+ * @returns Mocked module exposing the provided fix builder.
+ * @example
+ * ```typescript
+ * const mockModule = createMissingSectionFixesModule(() => []); void mockModule;
+ * ```
+ */
+function createMissingSectionFixesModule(buildMissingSectionFixes) {
+    return { buildMissingSectionFixes };
+}
+/**
+ * Builds the synthetic analysis returned by the mocked AAA helpers.
+ * @returns Minimal test-block analysis used by the regression scenario.
+ * @example
+ * ```typescript
+ * const analysis = createMockAnalysis(); void analysis;
+ * ```
+ */
+function createMockAnalysis() {
+    return {
+        bodyLineCount: 4,
+        callExpression: { type: "CallExpression" },
+        newline: "\n",
+        sectionComments: [
+            {
+                comment: {
+                    loc: { end: { line: 2 }, start: { line: 2 } },
+                    type: "Line",
+                },
+                phases: ["Arrange"],
+            },
+            {
+                comment: {
+                    loc: { end: { line: 4 }, start: { line: 4 } },
+                    type: "Line",
+                },
+                phases: ["Act"],
+            },
+        ],
+        sourceText: [
+            "const setup = createSetup();",
+            "// Arrange",
+            "run();",
+            "// Act",
+        ].join("\n"),
+        statements: [
+            {
+                node: {
+                    loc: { end: { line: 1 }, start: { line: 1 } },
+                    type: "ExpressionStatement",
+                },
+            },
+            {
+                node: {
+                    loc: { end: { line: 3 }, start: { line: 3 } },
+                    type: "ExpressionStatement",
+                },
+            },
+        ],
+    };
+}
+/**
+ * Creates a fixer that records inserted text edits.
+ * @param insertedFixes Collection updated when the fixer inserts text.
+ * @returns Rule fixer that records inserted edits.
+ * @example
+ * ```typescript
+ * const fixer = createRecordedFixer([]); void fixer;
+ * ```
+ */
+function createRecordedFixer(insertedFixes) {
+    return {
+        insertTextBeforeRange(range, text) {
+            const fix = { range, text };
+            insertedFixes.push(fix);
+            return fix;
+        },
+    };
+}
+/**
+ * Creates the minimal rule context used by the mocked scenario.
+ * @param reports Report descriptors captured during rule execution.
+ * @returns Rule context that records emitted reports.
+ * @example
+ * ```typescript
+ * const context = createRuleContext([]); void context;
+ * ```
+ */
+function createRuleContext(reports) {
+    return {
+        report(descriptor) {
+            reports.push(descriptor);
+        },
+    };
+}
+/**
+ * Reads the fix emitted by a report descriptor.
+ * @param descriptor Report descriptor to evaluate.
+ * @param fixer Synthetic fixer passed into the descriptor callback.
+ * @returns Fix output produced by the descriptor.
+ * @example
+ * ```typescript
+ * const fix = getDescriptorFix(void 0, {} as never); void fix;
+ * ```
+ */
+function getDescriptorFix(descriptor, fixer) {
+    const actual = descriptor?.fix?.(fixer);
+    if (!(actual instanceof Object)) {
+        return void 0;
+    }
+    if (Array.isArray(actual) || "range" in actual) {
+        return actual;
+    }
+    const iterableFixes = actual;
+    return [...iterableFixes];
+}
+/**
+ * Reads the mocked line-start range for the blank-line fix.
+ * @returns Synthetic range used by the rule fix.
+ * @example
+ * ```typescript
+ * const range = getMockLineStartRange(); void range;
+ * ```
+ */
+function getMockLineStartRange() {
+    return [7, 7];
+}
+/**
+ * Returns the phase-boundary comments from the mocked analysis.
+ * @param analysis Parsed analysis used by the mocked rule helpers.
+ * @returns Only comments that begin a later AAA phase.
+ * @example
+ * ```typescript
+ * const comments = getMockPhaseBoundaryComments(createMockAnalysis());
+ * void comments;
+ * ```
+ */
+function getMockPhaseBoundaryComments(analysis) {
+    return analysis.sectionComments.slice(1);
+}
+/**
+ * Reads the message identifier from a report descriptor when present.
+ * @param descriptor Report descriptor emitted by the rule.
+ * @returns Supported message identifier when present.
+ * @example
+ * ```typescript
+ * const messageId = getReportMessageId({ messageId: "missingSections" } as Rule.ReportDescriptor);
+ * void messageId;
+ * ```
+ */
+function getReportMessageId(descriptor) {
+    if (!("messageId" in descriptor) ||
+        !isRequireAaaSectionsMessageId(descriptor.messageId)) {
+        return void 0;
+    }
+    return descriptor.messageId;
+}
+/**
+ * Checks whether an unknown value is a valid rule message identifier.
+ * @param value Value to validate.
+ * @returns Whether the value is a supported message identifier.
+ * @example
+ * ```typescript
+ * const actual = isRequireAaaSectionsMessageId("missingSections");
+ * void actual;
+ * ```
+ */
+function isRequireAaaSectionsMessageId(value) {
+    return (value === "blankLineBeforeSection" ||
+        value === "codeBeforeArrange" ||
+        value === "emptySection" ||
+        value === "missingSections");
+}
+/**
+ * Loads the rule module after test mocks have been applied.
+ * @returns The rule module under test.
+ * @example
+ * ```typescript
+ * const rule = await loadRequireAaaSectionsRule(); void rule;
+ * ```
+ */
+async function loadRequireAaaSectionsRule() {
+    const { requireAaaSectionsRule } = await import("./rule.js");
+    return requireAaaSectionsRule;
+}
+export { createAaaModuleMock, createMissingSectionFixesModule, createRecordedFixer, createRuleContext, getDescriptorFix, getReportMessageId, loadRequireAaaSectionsRule, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.reporting.js","sourceRoot":"","sources":["../../../../src/domain/testing/require-aaa-sections/rule.reporting.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\r\n\r\nimport type { TestBlockAnalysis } from \"../aaa\";\r\n\r\n/** Mocked AAA helper exports consumed by the rule. */\r\ninterface AaaModuleMock {\r\n  /** Mocked analyzer entry point. */\r\n  analyzeTestBlock: () => TestBlockAnalysis;\r\n  /** Mocked line-start helper. */\r\n  getLineStartRange: () => [number, number];\r\n  /** Mocked boundary-comment helper. */\r\n  getPhaseBoundaryComments: (\r\n    analysis: TestBlockAnalysis,\r\n  ) => TestBlockAnalysis[\"sectionComments\"];\r\n  /** Mocked blank-line helper. */\r\n  hasBlankLineBeforeComment: () => false;\r\n}\r\n\r\n/** Mocked missing-section-fixes module. */\r\ninterface MissingSectionFixesModule {\r\n  /** Mocked fix builder. */\r\n  buildMissingSectionFixes: () => Rule.Fix[];\r\n}\r\n\r\n/** Message identifiers emitted by the rule under test. */\r\ntype RequireAaaSectionsMessageId =\r\n  | \"blankLineBeforeSection\"\r\n  | \"codeBeforeArrange\"\r\n  | \"emptySection\"\r\n  | \"missingSections\";\r\n\r\n/** Captured result from the mocked reporting scenario. */\r\ninterface ScenarioResult {\r\n  /** Fix emitted for the blank-line report. */\r\n  blankLineFix: Rule.Fix | Rule.Fix[] | undefined;\r\n  /** Fixes recorded by the synthetic fixer. */\r\n  insertedFixes: Rule.Fix[];\r\n  /** Message identifiers emitted in report order. */\r\n  messageIds: (RequireAaaSectionsMessageId | undefined)[];\r\n  /** Fix emitted for the missing-sections report. */\r\n  missingSectionsFix: Rule.Fix | Rule.Fix[] | undefined;\r\n}\r\n\r\n/**\r\n * Returns false so the mocked rule path always reports a missing blank line.\r\n * @returns False for every invocation.\r\n * @example\r\n * ```typescript\r\n * const actual = alwaysReturnFalse(); void actual;\r\n * ```\r\n */\r\nfunction alwaysReturnFalse(): false {\r\n  return false;\r\n}\r\n\r\n/**\r\n * Creates the mocked AAA helper module.\r\n * @returns Mocked exports consumed by the rule module.\r\n * @example\r\n * ```typescript\r\n * const mockModule = createAaaModuleMock(); void mockModule;\r\n * ```\r\n */\r\nfunction createAaaModuleMock(): AaaModuleMock {\r\n  return {\r\n    analyzeTestBlock: createMockAnalysis,\r\n    getLineStartRange: getMockLineStartRange,\r\n    getPhaseBoundaryComments: getMockPhaseBoundaryComments,\r\n    hasBlankLineBeforeComment: alwaysReturnFalse,\r\n  };\r\n}\r\n\r\n/**\r\n * Creates the mocked missing-section-fixes module.\r\n * @param buildMissingSectionFixes Mocked fix builder.\r\n * @returns Mocked module exposing the provided fix builder.\r\n * @example\r\n * ```typescript\r\n * const mockModule = createMissingSectionFixesModule(() => []); void mockModule;\r\n * ```\r\n */\r\nfunction createMissingSectionFixesModule(\r\n  buildMissingSectionFixes: () => Rule.Fix[],\r\n): MissingSectionFixesModule {\r\n  return { buildMissingSectionFixes };\r\n}\r\n\r\n/**\r\n * Builds the synthetic analysis returned by the mocked AAA helpers.\r\n * @returns Minimal test-block analysis used by the regression scenario.\r\n * @example\r\n * ```typescript\r\n * const analysis = createMockAnalysis(); void analysis;\r\n * ```\r\n */\r\nfunction createMockAnalysis(): TestBlockAnalysis {\r\n  return {\r\n    bodyLineCount: 4,\r\n    callExpression: { type: \"CallExpression\" },\r\n    newline: \"\\n\",\r\n    sectionComments: [\r\n      {\r\n        comment: {\r\n          loc: { end: { line: 2 }, start: { line: 2 } },\r\n          type: \"Line\",\r\n        },\r\n        phases: [\"Arrange\"],\r\n      },\r\n      {\r\n        comment: {\r\n          loc: { end: { line: 4 }, start: { line: 4 } },\r\n          type: \"Line\",\r\n        },\r\n        phases: [\"Act\"],\r\n      },\r\n    ],\r\n    sourceText: [\r\n      \"const setup = createSetup();\",\r\n      \"// Arrange\",\r\n      \"run();\",\r\n      \"// Act\",\r\n    ].join(\"\\n\"),\r\n    statements: [\r\n      {\r\n        node: {\r\n          loc: { end: { line: 1 }, start: { line: 1 } },\r\n          type: \"ExpressionStatement\",\r\n        },\r\n      },\r\n      {\r\n        node: {\r\n          loc: { end: { line: 3 }, start: { line: 3 } },\r\n          type: \"ExpressionStatement\",\r\n        },\r\n      },\r\n    ],\r\n  } as TestBlockAnalysis;\r\n}\r\n\r\n/**\r\n * Creates a fixer that records inserted text edits.\r\n * @param insertedFixes Collection updated when the fixer inserts text.\r\n * @returns Rule fixer that records inserted edits.\r\n * @example\r\n * ```typescript\r\n * const fixer = createRecordedFixer([]); void fixer;\r\n * ```\r\n */\r\nfunction createRecordedFixer(insertedFixes: Rule.Fix[]): Rule.RuleFixer {\r\n  return {\r\n    insertTextBeforeRange(range: [number, number], text: string): Rule.Fix {\r\n      const fix: Rule.Fix = { range, text };\r\n      insertedFixes.push(fix);\r\n      return fix;\r\n    },\r\n  } as Rule.RuleFixer;\r\n}\r\n\r\n/**\r\n * Creates the minimal rule context used by the mocked scenario.\r\n * @param reports Report descriptors captured during rule execution.\r\n * @returns Rule context that records emitted reports.\r\n * @example\r\n * ```typescript\r\n * const context = createRuleContext([]); void context;\r\n * ```\r\n */\r\nfunction createRuleContext(reports: Rule.ReportDescriptor[]): Rule.RuleContext {\r\n  return {\r\n    report(descriptor: Rule.ReportDescriptor): void {\r\n      reports.push(descriptor);\r\n    },\r\n  } as Rule.RuleContext;\r\n}\r\n\r\n/**\r\n * Reads the fix emitted by a report descriptor.\r\n * @param descriptor Report descriptor to evaluate.\r\n * @param fixer Synthetic fixer passed into the descriptor callback.\r\n * @returns Fix output produced by the descriptor.\r\n * @example\r\n * ```typescript\r\n * const fix = getDescriptorFix(void 0, {} as never); void fix;\r\n * ```\r\n */\r\nfunction getDescriptorFix(\r\n  descriptor: Rule.ReportDescriptor | undefined,\r\n  fixer: Rule.RuleFixer,\r\n): Rule.Fix | Rule.Fix[] | undefined {\r\n  const actual = descriptor?.fix?.(fixer);\r\n\r\n  if (!(actual instanceof Object)) {\r\n    return void 0;\r\n  }\r\n\r\n  if (Array.isArray(actual) || \"range\" in actual) {\r\n    return actual;\r\n  }\r\n\r\n  const iterableFixes: Iterable<Rule.Fix> = actual;\r\n\r\n  return [...iterableFixes];\r\n}\r\n\r\n/**\r\n * Reads the mocked line-start range for the blank-line fix.\r\n * @returns Synthetic range used by the rule fix.\r\n * @example\r\n * ```typescript\r\n * const range = getMockLineStartRange(); void range;\r\n * ```\r\n */\r\nfunction getMockLineStartRange(): [number, number] {\r\n  return [7, 7];\r\n}\r\n\r\n/**\r\n * Returns the phase-boundary comments from the mocked analysis.\r\n * @param analysis Parsed analysis used by the mocked rule helpers.\r\n * @returns Only comments that begin a later AAA phase.\r\n * @example\r\n * ```typescript\r\n * const comments = getMockPhaseBoundaryComments(createMockAnalysis());\r\n * void comments;\r\n * ```\r\n */\r\nfunction getMockPhaseBoundaryComments(\r\n  analysis: TestBlockAnalysis,\r\n): TestBlockAnalysis[\"sectionComments\"] {\r\n  return analysis.sectionComments.slice(1);\r\n}\r\n\r\n/**\r\n * Reads the message identifier from a report descriptor when present.\r\n * @param descriptor Report descriptor emitted by the rule.\r\n * @returns Supported message identifier when present.\r\n * @example\r\n * ```typescript\r\n * const messageId = getReportMessageId({ messageId: \"missingSections\" } as Rule.ReportDescriptor);\r\n * void messageId;\r\n * ```\r\n */\r\nfunction getReportMessageId(\r\n  descriptor: Rule.ReportDescriptor,\r\n): RequireAaaSectionsMessageId | undefined {\r\n  if (\r\n    !(\"messageId\" in descriptor) ||\r\n    !isRequireAaaSectionsMessageId(descriptor.messageId)\r\n  ) {\r\n    return void 0;\r\n  }\r\n  return descriptor.messageId;\r\n}\r\n\r\n/**\r\n * Checks whether an unknown value is a valid rule message identifier.\r\n * @param value Value to validate.\r\n * @returns Whether the value is a supported message identifier.\r\n * @example\r\n * ```typescript\r\n * const actual = isRequireAaaSectionsMessageId(\"missingSections\");\r\n * void actual;\r\n * ```\r\n */\r\nfunction isRequireAaaSectionsMessageId(\r\n  value: unknown,\r\n): value is RequireAaaSectionsMessageId {\r\n  return (\r\n    value === \"blankLineBeforeSection\" ||\r\n    value === \"codeBeforeArrange\" ||\r\n    value === \"emptySection\" ||\r\n    value === \"missingSections\"\r\n  );\r\n}\r\n\r\n/**\r\n * Loads the rule module after test mocks have been applied.\r\n * @returns The rule module under test.\r\n * @example\r\n * ```typescript\r\n * const rule = await loadRequireAaaSectionsRule(); void rule;\r\n * ```\r\n */\r\nasync function loadRequireAaaSectionsRule(): Promise<Rule.RuleModule> {\r\n  const { requireAaaSectionsRule } = await import(\"./rule\");\r\n  return requireAaaSectionsRule;\r\n}\r\n\r\nexport {\r\n  createAaaModuleMock,\r\n  createMissingSectionFixesModule,\r\n  createRecordedFixer,\r\n  createRuleContext,\r\n  getDescriptorFix,\r\n  getReportMessageId,\r\n  loadRequireAaaSectionsRule,\r\n};\r\n\r\nexport type { ScenarioResult };\r\n"]}

package/dist/domain/testing/require-act-result-capture/index.d.ts

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

package/dist/domain/testing/require-act-result-capture/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/require-act-result-capture/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/testing/require-act-result-capture/index.js

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

package/dist/{testing → domain/testing}/require-act-result-capture/rule.d.ts

@@ -1,4 +1,5 @@
 import type { Rule } from "eslint";
+/** Requires Act-phase expressions to capture non-void results before asserting. */
 declare const requireActResultCaptureRule: Rule.RuleModule;
 export { requireActResultCaptureRule };
 //# sourceMappingURL=rule.d.ts.map

package/dist/domain/testing/require-act-result-capture/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/require-act-result-capture/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AA2FnC,mFAAmF;AACnF,QAAA,MAAM,2BAA2B,EAAE,IAAI,CAAC,UAuCvC,CAAC;AAEF,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/domain/testing/require-act-result-capture/rule.js

@@ -0,0 +1,109 @@
+import { analyzeTestBlock, hasCapturableActResult } from "../aaa/index.js";
+/**
+ * Checks whether a call reports through `context.report(...)`.
+ * @param expression Call expression to inspect.
+ * @returns True when the call targets `context.report`.
+ * @example
+ * ```typescript
+ * const matches = isContextReportCall({} as ESTree.CallExpression);
+ * void matches;
+ * ```
+ */
+function isContextReportCall(expression) {
+    return (expression.callee.type === "MemberExpression" &&
+        expression.callee.object.type === "Identifier" &&
+        expression.callee.object.name === "context" &&
+        expression.callee.property.type === "Identifier" &&
+        expression.callee.property.name === "report");
+}
+/**
+ * Checks whether an Act statement is already delegated to a known helper.
+ * @param statement Statement to inspect.
+ * @returns True when the statement is handled by a helper wrapper.
+ * @example
+ * ```typescript
+ * const handled = isHelperDrivenAct({} as ESTree.Statement);
+ * void handled;
+ * ```
+ */
+function isHelperDrivenAct(statement) {
+    if (statement.type !== "ExpressionStatement") {
+        return false;
+    }
+    const { expression } = statement;
+    if (expression.type !== "CallExpression") {
+        return false;
+    }
+    return (isContextReportCall(expression) ||
+        isNamedHelperCall(expression) ||
+        isRuleCreateCall(expression));
+}
+/**
+ * Checks whether a call targets one of the known Act helper wrappers.
+ * @param expression Call expression to inspect.
+ * @returns True when the helper name matches the allowlist.
+ * @example
+ * ```typescript
+ * const matches = isNamedHelperCall({} as ESTree.CallExpression);
+ * void matches;
+ * ```
+ */
+function isNamedHelperCall(expression) {
+    return (expression.callee.type === "Identifier" &&
+        /^(?:report[A-Z]\w*|run(?:FunctionListener|Listener|Rule))$/u.test(expression.callee.name));
+}
+/**
+ * Checks whether a call targets `*.Rule.create(...)`.
+ * @param expression Call expression to inspect.
+ * @returns True when the call targets a rule factory create method.
+ * @example
+ * ```typescript
+ * const matches = isRuleCreateCall({} as ESTree.CallExpression);
+ * void matches;
+ * ```
+ */
+function isRuleCreateCall(expression) {
+    return (expression.callee.type === "MemberExpression" &&
+        expression.callee.object.type === "Identifier" &&
+        expression.callee.object.name.endsWith("Rule") &&
+        expression.callee.property.type === "Identifier" &&
+        expression.callee.property.name === "create");
+}
+/** Requires Act-phase expressions to capture non-void results before asserting. */
+const requireActResultCaptureRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                for (const statement of analysis.statements) {
+                    if (statement.phases.includes("Act") &&
+                        !statement.phases.includes("Assert") &&
+                        !isHelperDrivenAct(statement.node) &&
+                        hasCapturableActResult(statement.node)) {
+                        context.report({
+                            messageId: "captureActResult",
+                            node: statement.node,
+                        });
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: "Require non-void Act expressions to store the observed result before assertions.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/require-act-result-capture.md",
+        },
+        messages: {
+            captureActResult: "Capture the // Act result in a named variable before asserting on it.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+export { requireActResultCaptureRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/testing/require-act-result-capture/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\nimport { analyzeTestBlock, hasCapturableActResult } from \"../aaa\";\n\n/**\n * Checks whether a call reports through `context.report(...)`.\n * @param expression Call expression to inspect.\n * @returns True when the call targets `context.report`.\n * @example\n * ```typescript\n * const matches = isContextReportCall({} as ESTree.CallExpression);\n * void matches;\n * ```\n */\nfunction isContextReportCall(expression: ESTree.CallExpression): boolean {\n  return (\n    expression.callee.type === \"MemberExpression\" &&\n    expression.callee.object.type === \"Identifier\" &&\n    expression.callee.object.name === \"context\" &&\n    expression.callee.property.type === \"Identifier\" &&\n    expression.callee.property.name === \"report\"\n  );\n}\n\n/**\n * Checks whether an Act statement is already delegated to a known helper.\n * @param statement Statement to inspect.\n * @returns True when the statement is handled by a helper wrapper.\n * @example\n * ```typescript\n * const handled = isHelperDrivenAct({} as ESTree.Statement);\n * void handled;\n * ```\n */\nfunction isHelperDrivenAct(statement: ESTree.Statement): boolean {\n  if (statement.type !== \"ExpressionStatement\") {\n    return false;\n  }\n\n  const { expression } = statement;\n  if (expression.type !== \"CallExpression\") {\n    return false;\n  }\n\n  return (\n    isContextReportCall(expression) ||\n    isNamedHelperCall(expression) ||\n    isRuleCreateCall(expression)\n  );\n}\n\n/**\n * Checks whether a call targets one of the known Act helper wrappers.\n * @param expression Call expression to inspect.\n * @returns True when the helper name matches the allowlist.\n * @example\n * ```typescript\n * const matches = isNamedHelperCall({} as ESTree.CallExpression);\n * void matches;\n * ```\n */\nfunction isNamedHelperCall(expression: ESTree.CallExpression): boolean {\n  return (\n    expression.callee.type === \"Identifier\" &&\n    /^(?:report[A-Z]\\w*|run(?:FunctionListener|Listener|Rule))$/u.test(\n      expression.callee.name,\n    )\n  );\n}\n\n/**\n * Checks whether a call targets `*.Rule.create(...)`.\n * @param expression Call expression to inspect.\n * @returns True when the call targets a rule factory create method.\n * @example\n * ```typescript\n * const matches = isRuleCreateCall({} as ESTree.CallExpression);\n * void matches;\n * ```\n */\nfunction isRuleCreateCall(expression: ESTree.CallExpression): boolean {\n  return (\n    expression.callee.type === \"MemberExpression\" &&\n    expression.callee.object.type === \"Identifier\" &&\n    expression.callee.object.name.endsWith(\"Rule\") &&\n    expression.callee.property.type === \"Identifier\" &&\n    expression.callee.property.name === \"create\"\n  );\n}\n\n/** Requires Act-phase expressions to capture non-void results before asserting. */\nconst requireActResultCaptureRule: 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        for (const statement of analysis.statements) {\n          if (\n            statement.phases.includes(\"Act\") &&\n            !statement.phases.includes(\"Assert\") &&\n            !isHelperDrivenAct(statement.node) &&\n            hasCapturableActResult(statement.node)\n          ) {\n            context.report({\n              messageId: \"captureActResult\",\n              node: statement.node,\n            });\n          }\n        }\n      },\n    } satisfies Rule.RuleListener;\n  },\n  meta: {\n    docs: {\n      description:\n        \"Require non-void Act expressions to store the observed result before assertions.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/require-act-result-capture.md\",\n    },\n    messages: {\n      captureActResult:\n        \"Capture the // Act result in a named variable before asserting on it.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { requireActResultCaptureRule };\n"]}

package/dist/domain/testing/require-test-companion/index.d.ts

@@ -0,0 +1,3 @@
+export { buildListenerForFilename, getOptions, } from "./require-test-companion-utilities.js";
+export { requireTestCompanionRule } from "./rule.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/testing/require-test-companion/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/require-test-companion/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,UAAU,GACX,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/testing/require-test-companion/index.js

@@ -0,0 +1,3 @@
+export { buildListenerForFilename, getOptions, } from "./require-test-companion-utilities.js";
+export { requireTestCompanionRule } from "./rule.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvcmVxdWlyZS10ZXN0LWNvbXBhbmlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsd0JBQXdCLEVBQ3hCLFVBQVUsR0FDWCxNQUFNLG9DQUFvQyxDQUFDO0FBQzVDLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7XG4gIGJ1aWxkTGlzdGVuZXJGb3JGaWxlbmFtZSxcbiAgZ2V0T3B0aW9ucyxcbn0gZnJvbSBcIi4vcmVxdWlyZS10ZXN0LWNvbXBhbmlvbi11dGlsaXRpZXNcIjtcbmV4cG9ydCB7IHJlcXVpcmVUZXN0Q29tcGFuaW9uUnVsZSB9IGZyb20gXCIuL3J1bGVcIjtcbiJdfQ==

package/dist/{testing → domain/testing}/require-test-companion/require-test-companion-listeners.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from "eslint";
-import type { RequireTestCompanionState } from "./require-test-companion-options";
+import type { RequireTestCompanionState } from "./require-test-companion-options.js";
 /**
  * Builds a listener for a specific filename.
  * @param context Input context value.

package/dist/domain/testing/require-test-companion/require-test-companion-listeners.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-test-companion-listeners.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/require-test-companion/require-test-companion-listeners.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAKnC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,kCAAkC,CAAC;AAuLlF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,wBAAwB,GAC5B,SAAS,IAAI,CAAC,WAAW,EACzB,UAAU,MAAM,EAChB,SAAS,yBAAyB,KACjC,IAAI,CAAC,YAuBP,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}