@codeperfect/eslint-plugin 1.0.0 → 2.0.0

package/dist/domain/docs/test-helpers.js

@@ -0,0 +1,107 @@
+/**
+ * Creates createFixer.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createFixer();
+ * ```
+ */
+const createFixer = () => ({
+    insertTextAfter: (syntaxElement, text) => {
+        void syntaxElement;
+        return { range: [0, 0], text };
+    },
+    insertTextAfterRange: (range, text) => ({ range, text }),
+    insertTextBefore: (syntaxElement, text) => {
+        void syntaxElement;
+        return { range: [0, 0], text };
+    },
+    insertTextBeforeRange: (range, text) => ({ range, text }),
+    remove: (syntaxElement) => {
+        void syntaxElement;
+        return { range: [0, 0], text: "" };
+    },
+    removeRange: (range) => ({ range, text: "" }),
+    replaceText: (syntaxElement, text) => {
+        void syntaxElement;
+        return { range: [0, 0], text };
+    },
+    replaceTextRange: (range, text) => ({ range, text }),
+});
+/**
+ * Checks isFixIterable.
+ * @param fixResult Input fixResult value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isFixIterable();
+ * ```
+ */
+const isFixIterable = (fixResult) => Symbol.iterator in fixResult;
+/**
+ * Gets getFixText.
+ * @param fixResult Input fixResult value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getFixText();
+ * ```
+ */
+const getFixText = (fixResult) => {
+    if (fixResult === void 0) {
+        return void 0;
+    }
+    if (isFixIterable(fixResult)) {
+        return [...fixResult][0]?.text;
+    }
+    return fixResult.text;
+};
+/**
+ * Gets getFixes.
+ * @param reports Input reports value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getFixes();
+ * ```
+ */
+const getFixes = (reports) => {
+    const fixer = createFixer();
+    const fixes = [];
+    for (const report of reports) {
+        const fixResult = report.fix?.(fixer) ?? void 0;
+        if (fixResult !== void 0) {
+            if (isFixIterable(fixResult)) {
+                fixes.push(...fixResult);
+            }
+            else {
+                fixes.push(fixResult);
+            }
+        }
+    }
+    return fixes;
+};
+/**
+ * Applies applyFixes.
+ * @param sourceText Input sourceText value.
+ * @param fixes Input fixes value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * applyFixes();
+ * ```
+ */
+const applyFixes = (sourceText, fixes) => {
+    const sorted = fixes.toSorted((left, right) => right.range[0] - left.range[0]);
+    let output = sourceText;
+    for (const fix of sorted) {
+        output = [
+            output.slice(0, fix.range[0]),
+            fix.text,
+            output.slice(fix.range[1]),
+        ].join("");
+    }
+    return output;
+};
+export { applyFixes, createFixer, getFixes, getFixText };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/index.d.ts

@@ -0,0 +1,6 @@
+export { barrelFilesExportsOnlyRule, consistentBarrelFilesRule, noReexportsOutsideBarrelsRule, } from "./architecture/index.js";
+export { noMultipleDeclaratorsRule, preferInterfaceTypesRule } from "./core/index.js";
+export { createRuleDocumentation, customRuleDocumentationBaseUrl, getCustomRuleDocumentationUrl, } from "./custom-rule-documentation.js";
+export { noInterfaceMemberDocumentationRule, requireExampleLanguageRule, singleLineJsdocRule, } from "./docs/index.js";
+export { assertActualExpectedNamesRule, enforceAaaPhasePurityRule, enforceAaaStructureRule, preferViMockedImportRule, preferVitestIncrementalCastsRule, requireAaaSectionsRule, requireActResultCaptureRule, requireTestCompanionRule, singleActStatementRule, } from "./testing/index.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/domain/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,6BAA6B,GAC9B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC9B,6BAA6B,GAC9B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,kCAAkC,EAClC,0BAA0B,EAC1B,mBAAmB,GACpB,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,6BAA6B,EAC7B,yBAAyB,EACzB,uBAAuB,EACvB,wBAAwB,EACxB,gCAAgC,EAChC,sBAAsB,EACtB,2BAA2B,EAC3B,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,WAAW,CAAC"}

package/dist/domain/index.js

@@ -0,0 +1,6 @@
+export { barrelFilesExportsOnlyRule, consistentBarrelFilesRule, noReexportsOutsideBarrelsRule, } from "./architecture/index.js";
+export { noMultipleDeclaratorsRule, preferInterfaceTypesRule } from "./core/index.js";
+export { createRuleDocumentation, customRuleDocumentationBaseUrl, getCustomRuleDocumentationUrl, } from "./custom-rule-documentation.js";
+export { noInterfaceMemberDocumentationRule, requireExampleLanguageRule, singleLineJsdocRule, } from "./docs/index.js";
+export { assertActualExpectedNamesRule, enforceAaaPhasePurityRule, enforceAaaStructureRule, preferViMockedImportRule, preferVitestIncrementalCastsRule, requireAaaSectionsRule, requireActResultCaptureRule, requireTestCompanionRule, singleActStatementRule, } from "./testing/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZG9tYWluL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLDZCQUE2QixHQUM5QixNQUFNLGdCQUFnQixDQUFDO0FBQ3hCLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUM3RSxPQUFPLEVBQ0wsdUJBQXVCLEVBQ3ZCLDhCQUE4QixFQUM5Qiw2QkFBNkIsR0FDOUIsTUFBTSw2QkFBNkIsQ0FBQztBQUNyQyxPQUFPLEVBQ0wsa0NBQWtDLEVBQ2xDLDBCQUEwQixFQUMxQixtQkFBbUIsR0FDcEIsTUFBTSxRQUFRLENBQUM7QUFDaEIsT0FBTyxFQUNMLDZCQUE2QixFQUM3Qix5QkFBeUIsRUFDekIsdUJBQXVCLEVBQ3ZCLHdCQUF3QixFQUN4QixnQ0FBZ0MsRUFDaEMsc0JBQXNCLEVBQ3RCLDJCQUEyQixFQUMzQix3QkFBd0IsRUFDeEIsc0JBQXNCLEdBQ3ZCLE1BQU0sV0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcclxuICBiYXJyZWxGaWxlc0V4cG9ydHNPbmx5UnVsZSxcclxuICBjb25zaXN0ZW50QmFycmVsRmlsZXNSdWxlLFxyXG4gIG5vUmVleHBvcnRzT3V0c2lkZUJhcnJlbHNSdWxlLFxyXG59IGZyb20gXCIuL2FyY2hpdGVjdHVyZVwiO1xyXG5leHBvcnQgeyBub011bHRpcGxlRGVjbGFyYXRvcnNSdWxlLCBwcmVmZXJJbnRlcmZhY2VUeXBlc1J1bGUgfSBmcm9tIFwiLi9jb3JlXCI7XHJcbmV4cG9ydCB7XHJcbiAgY3JlYXRlUnVsZURvY3VtZW50YXRpb24sXHJcbiAgY3VzdG9tUnVsZURvY3VtZW50YXRpb25CYXNlVXJsLFxyXG4gIGdldEN1c3RvbVJ1bGVEb2N1bWVudGF0aW9uVXJsLFxyXG59IGZyb20gXCIuL2N1c3RvbS1ydWxlLWRvY3VtZW50YXRpb25cIjtcclxuZXhwb3J0IHtcclxuICBub0ludGVyZmFjZU1lbWJlckRvY3VtZW50YXRpb25SdWxlLFxyXG4gIHJlcXVpcmVFeGFtcGxlTGFuZ3VhZ2VSdWxlLFxyXG4gIHNpbmdsZUxpbmVKc2RvY1J1bGUsXHJcbn0gZnJvbSBcIi4vZG9jc1wiO1xyXG5leHBvcnQge1xyXG4gIGFzc2VydEFjdHVhbEV4cGVjdGVkTmFtZXNSdWxlLFxyXG4gIGVuZm9yY2VBYWFQaGFzZVB1cml0eVJ1bGUsXHJcbiAgZW5mb3JjZUFhYVN0cnVjdHVyZVJ1bGUsXHJcbiAgcHJlZmVyVmlNb2NrZWRJbXBvcnRSdWxlLFxyXG4gIHByZWZlclZpdGVzdEluY3JlbWVudGFsQ2FzdHNSdWxlLFxyXG4gIHJlcXVpcmVBYWFTZWN0aW9uc1J1bGUsXHJcbiAgcmVxdWlyZUFjdFJlc3VsdENhcHR1cmVSdWxlLFxyXG4gIHJlcXVpcmVUZXN0Q29tcGFuaW9uUnVsZSxcclxuICBzaW5nbGVBY3RTdGF0ZW1lbnRSdWxlLFxyXG59IGZyb20gXCIuL3Rlc3RpbmdcIjtcclxuIl19

package/dist/domain/testing/aaa/analyzer.analysis.d.ts

@@ -0,0 +1,92 @@
+import type { Rule } from "eslint";
+import type * as ESTree from "estree";
+import type { AaaPhase, SourceComment, TestBlockAnalysis } from "./types.js";
+/** Canonical ordering used when comparing AAA phases. */
+declare const aaaPhaseOrder: {
+    readonly Act: 1;
+    readonly Arrange: 0;
+    readonly Assert: 2;
+};
+/** Helper state for flattened section comments. */
+interface FlattenedSection {
+    /** Original source comment for the section marker. */
+    comment: SourceComment;
+    /** Phase represented by the flattened section entry. */
+    phase: AaaPhase;
+}
+/**
+ * Analyzes supported AAA test blocks.
+ * @param context Input context value.
+ * @param node Input node value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * analyzeTestBlock(context, node);
+ * ```
+ */
+declare function analyzeTestBlock(context: Rule.RuleContext, node: ESTree.CallExpression): TestBlockAnalysis | undefined;
+/**
+ * Counts Act statements.
+ * @param analysis Input analysis value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * countActStatements(analysis);
+ * ```
+ */
+declare function countActStatements(analysis: TestBlockAnalysis): number;
+/**
+ * Flattens section comments.
+ * @param analysis Input analysis value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getFlattenedSections(analysis);
+ * ```
+ */
+declare function getFlattenedSections(analysis: Pick<TestBlockAnalysis, "sectionComments">): FlattenedSection[];
+/**
+ * Gets indentation at an offset.
+ * @param sourceText Input sourceText value.
+ * @param offset Input offset value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getIndentationAtOffset(sourceText, 4);
+ * ```
+ */
+declare function getIndentationAtOffset(sourceText: string, offset: number): string;
+/**
+ * Gets the start range for a line.
+ * @param sourceText Input sourceText value.
+ * @param line Input line value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getLineStartRange(sourceText, 2);
+ * ```
+ */
+declare function getLineStartRange(sourceText: string, line: number): [number, number];
+/**
+ * Gets phase-boundary comments.
+ * @param analysis Input analysis value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getPhaseBoundaryComments(analysis);
+ * ```
+ */
+declare function getPhaseBoundaryComments(analysis: Pick<TestBlockAnalysis, "sectionComments">): TestBlockAnalysis["sectionComments"];
+/**
+ * Parses AAA phases from a comment.
+ * @param commentValue Input commentValue value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getSectionPhases("Arrange & Act");
+ * ```
+ */
+declare function getSectionPhases(commentValue: string): AaaPhase[];
+export { aaaPhaseOrder, analyzeTestBlock, countActStatements, getFlattenedSections, getIndentationAtOffset, getLineStartRange, getPhaseBoundaryComments, getSectionPhases, };
+export type { FlattenedSection };
+//# sourceMappingURL=analyzer.analysis.d.ts.map

package/dist/domain/testing/aaa/analyzer.analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.analysis.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.analysis.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EACV,QAAQ,EAGR,aAAa,EACb,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAIjB,yDAAyD;AACzD,QAAA,MAAM,aAAa;;;;CAI0B,CAAC;AAS9C,mDAAmD;AACnD,UAAU,gBAAgB;IACxB,sDAAsD;IACtD,OAAO,EAAE,aAAa,CAAC;IACvB,wDAAwD;IACxD,KAAK,EAAE,QAAQ,CAAC;CACjB;AAkBD;;;;;;;;;GASG;AACH,iBAAS,gBAAgB,CACvB,OAAO,EAAE,IAAI,CAAC,WAAW,EACzB,IAAI,EAAE,MAAM,CAAC,cAAc,GAC1B,iBAAiB,GAAG,SAAS,CAuC/B;AAED;;;;;;;;GAQG;AACH,iBAAS,kBAAkB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CAO/D;AAED;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAC3B,QAAQ,EAAE,IAAI,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,GACnD,gBAAgB,EAAE,CAOpB;AAED;;;;;;;;;GASG;AACH,iBAAS,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAM1E;AAED;;;;;;;;;GASG;AACH,iBAAS,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAa7E;AAeD;;;;;;;;GAQG;AACH,iBAAS,wBAAwB,CAC/B,QAAQ,EAAE,IAAI,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,GACnD,iBAAiB,CAAC,iBAAiB,CAAC,CAMtC;AAED;;;;;;;;GAQG;AACH,iBAAS,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,QAAQ,EAAE,CAO1D;AAkGD,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,wBAAwB,EACxB,gBAAgB,GACjB,CAAC;AACF,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/domain/testing/aaa/analyzer.analysis.helpers.d.ts

@@ -0,0 +1,4 @@
+/** Companion marker for the analyzer analysis helpers tests. */
+declare const analyzerAnalysisHelpersCompanion = true;
+export { analyzerAnalysisHelpersCompanion };
+//# sourceMappingURL=analyzer.analysis.helpers.d.ts.map

package/dist/domain/testing/aaa/analyzer.analysis.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.analysis.helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.analysis.helpers.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,QAAA,MAAM,gCAAgC,OAAO,CAAC;AAE9C,OAAO,EAAE,gCAAgC,EAAE,CAAC"}

package/dist/domain/testing/aaa/analyzer.analysis.helpers.js

@@ -0,0 +1,4 @@
+/** Companion marker for the analyzer analysis helpers tests. */
+const analyzerAnalysisHelpersCompanion = true;
+export { analyzerAnalysisHelpersCompanion };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5hbHl6ZXIuYW5hbHlzaXMuaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kb21haW4vdGVzdGluZy9hYWEvYW5hbHl6ZXIuYW5hbHlzaXMuaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxnRUFBZ0U7QUFDaEUsTUFBTSxnQ0FBZ0MsR0FBRyxJQUFJLENBQUM7QUFFOUMsT0FBTyxFQUFFLGdDQUFnQyxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQ29tcGFuaW9uIG1hcmtlciBmb3IgdGhlIGFuYWx5emVyIGFuYWx5c2lzIGhlbHBlcnMgdGVzdHMuICovXHJcbmNvbnN0IGFuYWx5emVyQW5hbHlzaXNIZWxwZXJzQ29tcGFuaW9uID0gdHJ1ZTtcclxuXHJcbmV4cG9ydCB7IGFuYWx5emVyQW5hbHlzaXNIZWxwZXJzQ29tcGFuaW9uIH07XHJcbiJdfQ==

package/dist/domain/testing/aaa/analyzer.analysis.js

@@ -0,0 +1,247 @@
+/* eslint max-lines: ["error", 350] -- Mandatory multiline JSDoc for internal helpers pushes this split file over the default limit. */
+import { isLocatedComment, isRangeWithin } from "./analyzer.super.js";
+/** Canonical ordering used when comparing AAA phases. */
+const aaaPhaseOrder = {
+    Act: 1,
+    Arrange: 0,
+    Assert: 2,
+};
+/** Recognized AAA phase names. */
+const phaseNames = ["Arrange", "Act", "Assert"];
+/**
+ * Analyzes supported AAA test blocks.
+ * @param context Input context value.
+ * @param node Input node value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * analyzeTestBlock(context, node);
+ * ```
+ */
+function analyzeTestBlock(context, node) {
+    const testCall = getSupportedTestCall(node);
+    if (testCall === void 0) {
+        return void 0;
+    }
+    const { callback, callExpression } = testCall;
+    const { sourceCode } = context;
+    const sectionComments = sourceCode
+        .getAllComments()
+        .filter((comment) => isLocatedComment(comment) &&
+        comment.type === "Line" &&
+        isRangeWithin(comment.range, callback.body.range) &&
+        getSectionPhases(comment.value).length > 0)
+        .map((comment) => ({
+        comment: comment,
+        phases: getSectionPhases(comment.value),
+    }));
+    return {
+        body: callback.body,
+        bodyLineCount: callback.body.loc.end.line - callback.body.loc.start.line - 1,
+        callExpression,
+        newline: getNewline(sourceCode.text),
+        sectionComments,
+        sourceText: sourceCode.text,
+        statements: callback.body.body.map((statement) => {
+            const phases = getStatementPhases(statement, sectionComments);
+            return {
+                node: statement,
+                phase: phases.at(-1),
+                phases,
+            };
+        }),
+    };
+}
+/**
+ * Counts Act statements.
+ * @param analysis Input analysis value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * countActStatements(analysis);
+ * ```
+ */
+function countActStatements(analysis) {
+    return analysis.statements.filter((statement) => statement.phases.includes("Act") &&
+        (statement.node.type === "ExpressionStatement" ||
+            statement.node.type === "VariableDeclaration")).length;
+}
+/**
+ * Flattens section comments.
+ * @param analysis Input analysis value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getFlattenedSections(analysis);
+ * ```
+ */
+function getFlattenedSections(analysis) {
+    return analysis.sectionComments.flatMap((sectionComment) => sectionComment.phases.map((phase) => ({
+        comment: sectionComment.comment,
+        phase,
+    })));
+}
+/**
+ * Gets indentation at an offset.
+ * @param sourceText Input sourceText value.
+ * @param offset Input offset value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getIndentationAtOffset(sourceText, 4);
+ * ```
+ */
+function getIndentationAtOffset(sourceText, offset) {
+    const lineStart = sourceText.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
+    const linePrefix = sourceText.slice(lineStart, offset);
+    const trimmedPrefix = linePrefix.trimStart();
+    return linePrefix.slice(0, linePrefix.length - trimmedPrefix.length);
+}
+/**
+ * Gets the start range for a line.
+ * @param sourceText Input sourceText value.
+ * @param line Input line value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getLineStartRange(sourceText, 2);
+ * ```
+ */
+function getLineStartRange(sourceText, line) {
+    let currentLine = 1;
+    let currentOffset = 0;
+    for (const character of sourceText) {
+        if (currentLine === line) {
+            return [currentOffset, currentOffset];
+        }
+        if (character === "\n") {
+            currentLine += 1;
+        }
+        currentOffset += 1;
+    }
+    return [sourceText.length, sourceText.length];
+}
+/**
+ * Gets the newline sequence.
+ * @param text Input text value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getNewline(sourceText);
+ * ```
+ */
+function getNewline(text) {
+    return text.includes("\r\n") ? "\r\n" : "\n";
+}
+/**
+ * Gets phase-boundary comments.
+ * @param analysis Input analysis value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getPhaseBoundaryComments(analysis);
+ * ```
+ */
+function getPhaseBoundaryComments(analysis) {
+    return analysis.sectionComments.filter((sectionComment) => sectionComment.phases.some((phase) => phase === "Act" || phase === "Assert"));
+}
+/**
+ * Parses AAA phases from a comment.
+ * @param commentValue Input commentValue value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getSectionPhases("Arrange & Act");
+ * ```
+ */
+function getSectionPhases(commentValue) {
+    const trimmedComment = commentValue.trim();
+    if (trimmedComment.length === 0) {
+        return [];
+    }
+    const parts = trimmedComment.split(/\s*&\s*/u);
+    return parts.every((part) => isAaaPhase(part)) ? parts : [];
+}
+/**
+ * Gets the active phases for a statement.
+ * @param statement Input statement value.
+ * @param sectionComments Input sectionComments value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getStatementPhases(statement, sectionComments);
+ * ```
+ */
+function getStatementPhases(statement, sectionComments) {
+    const statementLine = statement.loc?.start.line;
+    if (statementLine === void 0) {
+        return [];
+    }
+    let currentPhases = [];
+    for (const sectionComment of sectionComments) {
+        if (sectionComment.comment.loc.start.line > statementLine) {
+            break;
+        }
+        currentPhases = sectionComment.phases;
+    }
+    return currentPhases;
+}
+/**
+ * Gets supported test call metadata.
+ * @param node Input node value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getSupportedTestCall(node);
+ * ```
+ */
+function getSupportedTestCall(node) {
+    const rootName = getTestRootName(node.callee);
+    if (rootName !== "it" && rootName !== "test") {
+        return void 0;
+    }
+    const callbackArgument = node.arguments.at(-1);
+    if (callbackArgument === void 0 ||
+        callbackArgument.type === "SpreadElement" ||
+        (callbackArgument.type !== "ArrowFunctionExpression" &&
+            callbackArgument.type !== "FunctionExpression") ||
+        callbackArgument.body.type !== "BlockStatement") {
+        return void 0;
+    }
+    return {
+        callback: callbackArgument,
+        callExpression: node,
+    };
+}
+/**
+ * Gets the root test callee name.
+ * @param callee Input callee value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getTestRootName(callExpression.callee);
+ * ```
+ */
+function getTestRootName(callee) {
+    if (callee.type === "Identifier") {
+        return callee.name;
+    }
+    if (callee.type === "MemberExpression" && callee.object.type !== "Super") {
+        return getTestRootName(callee.object);
+    }
+    return void 0;
+}
+/**
+ * Checks whether a value is an AAA phase.
+ * @param value Input value value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isAaaPhase("Arrange");
+ * ```
+ */
+function isAaaPhase(value) {
+    return phaseNames.includes(value);
+}
+export { aaaPhaseOrder, analyzeTestBlock, countActStatements, getFlattenedSections, getIndentationAtOffset, getLineStartRange, getPhaseBoundaryComments, getSectionPhases, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyzer.analysis.js","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.analysis.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint max-lines: [\"error\", 350] -- Mandatory multiline JSDoc for internal helpers pushes this split file over the default limit. */\r\n\r\nimport type { Rule } from \"eslint\";\r\nimport type * as ESTree from \"estree\";\r\n\r\nimport type {\r\n  AaaPhase,\r\n  LocatedComment,\r\n  LocatedNode,\r\n  SourceComment,\r\n  TestBlockAnalysis,\r\n} from \"./types\";\r\n\r\nimport { isLocatedComment, isRangeWithin } from \"./analyzer.super\";\r\n\r\n/** Canonical ordering used when comparing AAA phases. */\r\nconst aaaPhaseOrder = {\r\n  Act: 1,\r\n  Arrange: 0,\r\n  Assert: 2,\r\n} as const satisfies Record<AaaPhase, number>;\r\n\r\n/** Recognized AAA phase names. */\r\nconst phaseNames = [\"Arrange\", \"Act\", \"Assert\"] as const satisfies readonly [\r\n  AaaPhase,\r\n  AaaPhase,\r\n  AaaPhase,\r\n];\r\n\r\n/** Helper state for flattened section comments. */\r\ninterface FlattenedSection {\r\n  /** Original source comment for the section marker. */\r\n  comment: SourceComment;\r\n  /** Phase represented by the flattened section entry. */\r\n  phase: AaaPhase;\r\n}\r\n\r\n/** Supported call-expression wrapper for analyzed test blocks. */\r\ninterface SupportedTestCall {\r\n  /** Callback argument that owns the test body. */\r\n  callback: SupportedTestCallback;\r\n  /** Original `it` or `test` invocation. */\r\n  callExpression: LocatedNode<ESTree.CallExpression>;\r\n}\r\n\r\n/** Supported test callback shape for `it` and `test` calls. */\r\ntype SupportedTestCallback = LocatedNode<\r\n  ESTree.ArrowFunctionExpression | ESTree.FunctionExpression\r\n> & {\r\n  /** Callback body block used for section analysis. */\r\n  body: LocatedNode<ESTree.BlockStatement>;\r\n};\r\n\r\n/**\r\n * Analyzes supported AAA test blocks.\r\n * @param context Input context value.\r\n * @param node Input node value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * analyzeTestBlock(context, node);\r\n * ```\r\n */\r\nfunction analyzeTestBlock(\r\n  context: Rule.RuleContext,\r\n  node: ESTree.CallExpression,\r\n): TestBlockAnalysis | undefined {\r\n  const testCall = getSupportedTestCall(node);\r\n  if (testCall === void 0) {\r\n    return void 0;\r\n  }\r\n\r\n  const { callback, callExpression } = testCall;\r\n  const { sourceCode } = context;\r\n  const sectionComments: TestBlockAnalysis[\"sectionComments\"] = sourceCode\r\n    .getAllComments()\r\n    .filter(\r\n      (comment) =>\r\n        isLocatedComment(comment) &&\r\n        comment.type === \"Line\" &&\r\n        isRangeWithin(comment.range, callback.body.range) &&\r\n        getSectionPhases(comment.value).length > 0,\r\n    )\r\n    .map((comment) => ({\r\n      comment: comment as LocatedComment,\r\n      phases: getSectionPhases(comment.value),\r\n    }));\r\n\r\n  return {\r\n    body: callback.body,\r\n    bodyLineCount:\r\n      callback.body.loc.end.line - callback.body.loc.start.line - 1,\r\n    callExpression,\r\n    newline: getNewline(sourceCode.text),\r\n    sectionComments,\r\n    sourceText: sourceCode.text,\r\n    statements: callback.body.body.map((statement) => {\r\n      const phases = getStatementPhases(statement, sectionComments);\r\n      return {\r\n        node: statement as LocatedNode<ESTree.Statement>,\r\n        phase: phases.at(-1),\r\n        phases,\r\n      };\r\n    }),\r\n  };\r\n}\r\n\r\n/**\r\n * Counts Act statements.\r\n * @param analysis Input analysis value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * countActStatements(analysis);\r\n * ```\r\n */\r\nfunction countActStatements(analysis: TestBlockAnalysis): number {\r\n  return analysis.statements.filter(\r\n    (statement) =>\r\n      statement.phases.includes(\"Act\") &&\r\n      (statement.node.type === \"ExpressionStatement\" ||\r\n        statement.node.type === \"VariableDeclaration\"),\r\n  ).length;\r\n}\r\n\r\n/**\r\n * Flattens section comments.\r\n * @param analysis Input analysis value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getFlattenedSections(analysis);\r\n * ```\r\n */\r\nfunction getFlattenedSections(\r\n  analysis: Pick<TestBlockAnalysis, \"sectionComments\">,\r\n): FlattenedSection[] {\r\n  return analysis.sectionComments.flatMap((sectionComment) =>\r\n    sectionComment.phases.map((phase) => ({\r\n      comment: sectionComment.comment,\r\n      phase,\r\n    })),\r\n  );\r\n}\r\n\r\n/**\r\n * Gets indentation at an offset.\r\n * @param sourceText Input sourceText value.\r\n * @param offset Input offset value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getIndentationAtOffset(sourceText, 4);\r\n * ```\r\n */\r\nfunction getIndentationAtOffset(sourceText: string, offset: number): string {\r\n  const lineStart = sourceText.lastIndexOf(\"\\n\", Math.max(0, offset - 1)) + 1;\r\n  const linePrefix = sourceText.slice(lineStart, offset);\r\n  const trimmedPrefix = linePrefix.trimStart();\r\n\r\n  return linePrefix.slice(0, linePrefix.length - trimmedPrefix.length);\r\n}\r\n\r\n/**\r\n * Gets the start range for a line.\r\n * @param sourceText Input sourceText value.\r\n * @param line Input line value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getLineStartRange(sourceText, 2);\r\n * ```\r\n */\r\nfunction getLineStartRange(sourceText: string, line: number): [number, number] {\r\n  let currentLine = 1;\r\n  let currentOffset = 0;\r\n  for (const character of sourceText) {\r\n    if (currentLine === line) {\r\n      return [currentOffset, currentOffset];\r\n    }\r\n    if (character === \"\\n\") {\r\n      currentLine += 1;\r\n    }\r\n    currentOffset += 1;\r\n  }\r\n  return [sourceText.length, sourceText.length];\r\n}\r\n\r\n/**\r\n * Gets the newline sequence.\r\n * @param text Input text value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getNewline(sourceText);\r\n * ```\r\n */\r\nfunction getNewline(text: string): \"\\n\" | \"\\r\\n\" {\r\n  return text.includes(\"\\r\\n\") ? \"\\r\\n\" : \"\\n\";\r\n}\r\n\r\n/**\r\n * Gets phase-boundary comments.\r\n * @param analysis Input analysis value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getPhaseBoundaryComments(analysis);\r\n * ```\r\n */\r\nfunction getPhaseBoundaryComments(\r\n  analysis: Pick<TestBlockAnalysis, \"sectionComments\">,\r\n): TestBlockAnalysis[\"sectionComments\"] {\r\n  return analysis.sectionComments.filter((sectionComment) =>\r\n    sectionComment.phases.some(\r\n      (phase) => phase === \"Act\" || phase === \"Assert\",\r\n    ),\r\n  );\r\n}\r\n\r\n/**\r\n * Parses AAA phases from a comment.\r\n * @param commentValue Input commentValue value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getSectionPhases(\"Arrange & Act\");\r\n * ```\r\n */\r\nfunction getSectionPhases(commentValue: string): AaaPhase[] {\r\n  const trimmedComment = commentValue.trim();\r\n  if (trimmedComment.length === 0) {\r\n    return [];\r\n  }\r\n  const parts = trimmedComment.split(/\\s*&\\s*/u);\r\n  return parts.every((part) => isAaaPhase(part)) ? parts : [];\r\n}\r\n\r\n/**\r\n * Gets the active phases for a statement.\r\n * @param statement Input statement value.\r\n * @param sectionComments Input sectionComments value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getStatementPhases(statement, sectionComments);\r\n * ```\r\n */\r\nfunction getStatementPhases(\r\n  statement: ESTree.Statement,\r\n  sectionComments: TestBlockAnalysis[\"sectionComments\"],\r\n): AaaPhase[] {\r\n  const statementLine = statement.loc?.start.line;\r\n  if (statementLine === void 0) {\r\n    return [];\r\n  }\r\n  let currentPhases: AaaPhase[] = [];\r\n  for (const sectionComment of sectionComments) {\r\n    if (sectionComment.comment.loc.start.line > statementLine) {\r\n      break;\r\n    }\r\n    currentPhases = sectionComment.phases;\r\n  }\r\n  return currentPhases;\r\n}\r\n\r\n/**\r\n * Gets supported test call metadata.\r\n * @param node Input node value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getSupportedTestCall(node);\r\n * ```\r\n */\r\nfunction getSupportedTestCall(\r\n  node: ESTree.CallExpression,\r\n): SupportedTestCall | undefined {\r\n  const rootName = getTestRootName(node.callee);\r\n  if (rootName !== \"it\" && rootName !== \"test\") {\r\n    return void 0;\r\n  }\r\n\r\n  const callbackArgument = node.arguments.at(-1);\r\n  if (\r\n    callbackArgument === void 0 ||\r\n    callbackArgument.type === \"SpreadElement\" ||\r\n    (callbackArgument.type !== \"ArrowFunctionExpression\" &&\r\n      callbackArgument.type !== \"FunctionExpression\") ||\r\n    callbackArgument.body.type !== \"BlockStatement\"\r\n  ) {\r\n    return void 0;\r\n  }\r\n\r\n  return {\r\n    callback: callbackArgument as SupportedTestCallback,\r\n    callExpression: node as LocatedNode<ESTree.CallExpression>,\r\n  };\r\n}\r\n\r\n/**\r\n * Gets the root test callee name.\r\n * @param callee Input callee value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getTestRootName(callExpression.callee);\r\n * ```\r\n */\r\nfunction getTestRootName(\r\n  callee: ESTree.CallExpression[\"callee\"],\r\n): string | undefined {\r\n  if (callee.type === \"Identifier\") {\r\n    return callee.name;\r\n  }\r\n  if (callee.type === \"MemberExpression\" && callee.object.type !== \"Super\") {\r\n    return getTestRootName(callee.object);\r\n  }\r\n  return void 0;\r\n}\r\n\r\n/**\r\n * Checks whether a value is an AAA phase.\r\n * @param value Input value value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isAaaPhase(\"Arrange\");\r\n * ```\r\n */\r\nfunction isAaaPhase(value: string): value is AaaPhase {\r\n  return phaseNames.includes(value as AaaPhase);\r\n}\r\n\r\nexport {\r\n  aaaPhaseOrder,\r\n  analyzeTestBlock,\r\n  countActStatements,\r\n  getFlattenedSections,\r\n  getIndentationAtOffset,\r\n  getLineStartRange,\r\n  getPhaseBoundaryComments,\r\n  getSectionPhases,\r\n};\r\nexport type { FlattenedSection };\r\n"]}

package/dist/domain/testing/aaa/analyzer.assertions.d.ts

@@ -0,0 +1,93 @@
+import type * as ESTree from "estree";
+import type { LocatedNode, TestBlockAnalysis } from "./types.js";
+/** Identifier names extracted from an assertion statement. */
+interface AssertionIdentifiers {
+    /** Identifier used as the actual value. */
+    actual: string | undefined;
+    /** Identifier used as the expected value. */
+    expected: string | undefined;
+}
+/**
+ * Collects Assert declarations.
+ * @param analysis Input analysis value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getAssertDeclaredIdentifiers(analysis);
+ * ```
+ */
+declare function getAssertDeclaredIdentifiers(analysis: TestBlockAnalysis): Map<string, LocatedNode<ESTree.Identifier>>;
+/**
+ * Extracts assertion identifiers.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getAssertionIdentifiers(statement);
+ * ```
+ */
+declare function getAssertionIdentifiers(statement: ESTree.Statement): AssertionIdentifiers;
+/**
+ * Gets a statement expression.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getStatementExpression(statement);
+ * ```
+ */
+declare function getStatementExpression(statement: ESTree.Statement): ESTree.Expression | undefined;
+/**
+ * Checks for assertions.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasAssertion(statement);
+ * ```
+ */
+declare function hasAssertion(statement: ESTree.Statement): boolean;
+/**
+ * Checks for action expressions.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isActionExpression(expression);
+ * ```
+ */
+declare function isActionExpression(expression: ESTree.Expression | undefined): boolean;
+/**
+ * Checks Assert statement validity.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isValidAssertStatement(statement);
+ * ```
+ */
+declare function isValidAssertStatement(statement: ESTree.Statement): boolean;
+/**
+ * Unwraps nested expressions.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * unwrapExpression(expression);
+ * ```
+ */
+declare function unwrapExpression(expression: ESTree.Expression | undefined): ESTree.Expression | undefined;
+/**
+ * Checks AAA naming prefixes.
+ * @param name Input name value.
+ * @param prefix Input prefix value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * usesPrefix("actualResult", "actual");
+ * ```
+ */
+declare function usesPrefix(name: string, prefix: "actual" | "expected"): boolean;
+export { getAssertDeclaredIdentifiers, getAssertionIdentifiers, getStatementExpression, hasAssertion, isActionExpression, isValidAssertStatement, unwrapExpression, usesPrefix, };
+export type { AssertionIdentifiers };
+//# sourceMappingURL=analyzer.assertions.d.ts.map

package/dist/domain/testing/aaa/analyzer.assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.assertions.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.assertions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAI9D,8DAA8D;AAC9D,UAAU,oBAAoB;IAC5B,2CAA2C;IAC3C,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAUD;;;;;;;;GAQG;AACH,iBAAS,4BAA4B,CACnC,QAAQ,EAAE,iBAAiB,GAC1B,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAkB7C;AAwBD;;;;;;;;GAQG;AACH,iBAAS,uBAAuB,CAC9B,SAAS,EAAE,MAAM,CAAC,SAAS,GAC1B,oBAAoB,CAqBtB;AAmFD;;;;;;;;GAQG;AACH,iBAAS,sBAAsB,CAC7B,SAAS,EAAE,MAAM,CAAC,SAAS,GAC1B,MAAM,CAAC,UAAU,GAAG,SAAS,CAY/B;AAED;;;;;;;;GAQG;AACH,iBAAS,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAQ1D;AAqBD;;;;;;;;GAQG;AACH,iBAAS,kBAAkB,CACzB,UAAU,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,GACxC,OAAO,CAOT;AA8BD;;;;;;;;GAQG;AACH,iBAAS,sBAAsB,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAmBpE;AAED;;;;;;;;GAQG;AACH,iBAAS,gBAAgB,CACvB,UAAU,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,GACxC,MAAM,CAAC,UAAU,GAAG,SAAS,CAQ/B;AAED;;;;;;;;;GASG;AACH,iBAAS,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAG,UAAU,GAAG,OAAO,CAExE;AAED,OAAO,EACL,4BAA4B,EAC5B,uBAAuB,EACvB,sBAAsB,EACtB,YAAY,EACZ,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,UAAU,GACX,CAAC;AACF,YAAY,EAAE,oBAAoB,EAAE,CAAC"}