@codeperfect/eslint-plugin 1.0.0 → 2.0.0

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

@@ -0,0 +1,46 @@
+/** Canonical ordering used when comparing AAA phases. */
+declare const aaaPhaseOrder: {
+    readonly Act: 1;
+    readonly Arrange: 0;
+    readonly Assert: 2;
+};
+/** Analyzes a supported `it` or `test` callback for AAA sections. */
+declare const analyzeTestBlock: (context: import("eslint").Rule.RuleContext, node: import("estree").CallExpression) => import("./types.js").TestBlockAnalysis | undefined;
+/** Counts statement forms that should be treated as Act steps. */
+declare const countActStatements: (analysis: import("./types.js").TestBlockAnalysis) => number;
+/** Collects identifiers declared inside Assert sections. */
+declare const getAssertDeclaredIdentifiers: (analysis: import("./types.js").TestBlockAnalysis) => Map<string, import("./types.js").LocatedNode<import("estree").Identifier>>;
+/** Extracts `actual` and `expected` identifiers from assertion statements. */
+declare const getAssertionIdentifiers: (statement: import("estree").Statement) => import("./analyzer.assertions.js").AssertionIdentifiers;
+/** Flattens section comments into one entry per resolved phase. */
+declare const getFlattenedSections: (analysis: Pick<import("./types.js").TestBlockAnalysis, "sectionComments">) => import("./analyzer.analysis.js").FlattenedSection[];
+/** Returns the indentation prefix that appears before a given offset. */
+declare const getIndentationAtOffset: (sourceText: string, offset: number) => string;
+/** Resolves the starting range for a specific source line. */
+declare const getLineStartRange: (sourceText: string, line: number) => [number, number];
+/** Filters section comments down to phase boundaries that matter after Arrange. */
+declare const getPhaseBoundaryComments: (analysis: Pick<import("./types.js").TestBlockAnalysis, "sectionComments">) => import("./types.js").SectionComment[];
+/** Parses AAA phases from a section comment value. */
+declare const getSectionPhases: (commentValue: string) => import("./types.js").AaaPhase[];
+/** Detects whether a statement contains any assertion call. */
+declare const hasAssertion: (statement: import("estree").Statement) => boolean;
+/** Detects asynchronous behavior such as awaits, promise chains, and promises. */
+declare const hasAsyncLogic: (statement: import("estree").Statement) => boolean;
+/** Detects whether a statement contains an `await` expression. */
+declare const hasAwait: (statement: import("estree").Statement) => boolean;
+/** Checks whether a section comment is separated by a blank line. */
+declare const hasBlankLineBeforeComment: (sourceText: string, comment: import("estree").Comment) => boolean;
+/** Detects Act expressions whose result should usually be captured. */
+declare const hasCapturableActResult: (statement: import("estree").Statement) => boolean;
+/** Detects mutation-oriented statements and array mutator calls. */
+declare const hasMutation: (statement: import("estree").Statement) => boolean;
+/** Detects statements that represent meaningful Act steps. */
+declare const isMeaningfulActStatement: (statement: import("estree").Statement) => boolean;
+/** Detects statements that should stay in Arrange as setup helpers. */
+declare const isSetupLikeStatement: (statement: import("estree").Statement) => boolean;
+/** Detects whether a statement shape is valid inside Assert. */
+declare const isValidAssertStatement: (statement: import("estree").Statement) => boolean;
+/** Checks whether an identifier matches the expected AAA naming prefix. */
+declare const usesPrefix: (name: string, prefix: "actual" | "expected") => boolean;
+export { aaaPhaseOrder, analyzeTestBlock, countActStatements, getAssertDeclaredIdentifiers, getAssertionIdentifiers, getFlattenedSections, getIndentationAtOffset, getLineStartRange, getPhaseBoundaryComments, getSectionPhases, hasAssertion, hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, usesPrefix, };
+//# sourceMappingURL=analyzer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.ts"],"names":[],"mappings":"AA2BA,yDAAyD;AACzD,QAAA,MAAM,aAAa;;;;CAA8B,CAAC;AAmBlD,qEAAqE;AACrE,QAAA,MAAM,gBAAgB,wIAA0C,CAAC;AAEjE,kEAAkE;AAClE,QAAA,MAAM,kBAAkB,2DAA4C,CAAC;AAErE,4DAA4D;AAC5D,QAAA,MAAM,4BAA4B,4HAEjC,CAAC;AAEF,8EAA8E;AAC9E,QAAA,MAAM,uBAAuB,iGAAiD,CAAC;AAE/E,mEAAmE;AACnE,QAAA,MAAM,oBAAoB,8HAA8C,CAAC;AAEzE,yEAAyE;AACzE,QAAA,MAAM,sBAAsB,gDAAgD,CAAC;AAE7E,8DAA8D;AAC9D,QAAA,MAAM,iBAAiB,wDAA2C,CAAC;AAEnE,mFAAmF;AACnF,QAAA,MAAM,wBAAwB,gHAE7B,CAAC;AAEF,sDAAsD;AACtD,QAAA,MAAM,gBAAgB,wDAA0C,CAAC;AAEjE,+DAA+D;AAC/D,QAAA,MAAM,YAAY,oDAAsC,CAAC;AAEzD,kFAAkF;AAClF,QAAA,MAAM,aAAa,oDAAuC,CAAC;AAE3D,kEAAkE;AAClE,QAAA,MAAM,QAAQ,oDAAkC,CAAC;AAEjD,qEAAqE;AACrE,QAAA,MAAM,yBAAyB,oEAE9B,CAAC;AAEF,uEAAuE;AACvE,QAAA,MAAM,sBAAsB,oDAAgD,CAAC;AAE7E,oEAAoE;AACpE,QAAA,MAAM,WAAW,oDAAqC,CAAC;AAEvD,8DAA8D;AAC9D,QAAA,MAAM,wBAAwB,oDAE7B,CAAC;AAEF,uEAAuE;AACvE,QAAA,MAAM,oBAAoB,oDAA8C,CAAC;AAEzE,gEAAgE;AAChE,QAAA,MAAM,sBAAsB,oDAAgD,CAAC;AAE7E,2EAA2E;AAC3E,QAAA,MAAM,UAAU,0DAAoC,CAAC;AAErD,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,4BAA4B,EAC5B,uBAAuB,EACvB,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,wBAAwB,EACxB,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,yBAAyB,EACzB,sBAAsB,EACtB,WAAW,EACX,wBAAwB,EACxB,oBAAoB,EACpB,sBAAsB,EACtB,UAAU,GACX,CAAC"}

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

@@ -0,0 +1,59 @@
+import { aaaPhaseOrder as aaaPhaseOrderImplementation, analyzeTestBlock as analyzeTestBlockImplementation, countActStatements as countActStatementsImplementation, getFlattenedSections as getFlattenedSectionsImplementation, getIndentationAtOffset as getIndentationAtOffsetImplementation, getLineStartRange as getLineStartRangeImplementation, getPhaseBoundaryComments as getPhaseBoundaryCommentsImplementation, getSectionPhases as getSectionPhasesImplementation, } from "./analyzer.analysis.js";
+import { getAssertDeclaredIdentifiers as getAssertDeclaredIdentifiersImplementation, getAssertionIdentifiers as getAssertionIdentifiersImplementation, hasAssertion as hasAssertionImplementation, isValidAssertStatement as isValidAssertStatementImplementation, usesPrefix as usesPrefixImplementation, } from "./analyzer.assertions.js";
+import { hasAsyncLogic as hasAsyncLogicImplementation, hasAwait as hasAwaitImplementation, hasBlankLineBeforeComment as hasBlankLineBeforeCommentImplementation, hasCapturableActResult as hasCapturableActResultImplementation, hasMutation as hasMutationImplementation, isMeaningfulActStatement as isMeaningfulActStatementImplementation, isSetupLikeStatement as isSetupLikeStatementImplementation, } from "./analyzer.classification.js";
+/** Canonical ordering used when comparing AAA phases. */
+const aaaPhaseOrder = aaaPhaseOrderImplementation;
+/**
+ * Creates a local forwarding function for an imported analyzer helper.
+ * @template TParameters Forwarded parameter tuple.
+ * @template TResult Forwarded return type.
+ * @param implementation Imported helper implementation.
+ * @returns Local function that forwards all arguments to the implementation.
+ * @example
+ * ```typescript
+ * const localHelper = forward(implementation);
+ * ```
+ */
+function forward(implementation) {
+    return (...parameters) => implementation(...parameters);
+}
+/** Analyzes a supported `it` or `test` callback for AAA sections. */
+const analyzeTestBlock = forward(analyzeTestBlockImplementation);
+/** Counts statement forms that should be treated as Act steps. */
+const countActStatements = forward(countActStatementsImplementation);
+/** Collects identifiers declared inside Assert sections. */
+const getAssertDeclaredIdentifiers = forward(getAssertDeclaredIdentifiersImplementation);
+/** Extracts `actual` and `expected` identifiers from assertion statements. */
+const getAssertionIdentifiers = forward(getAssertionIdentifiersImplementation);
+/** Flattens section comments into one entry per resolved phase. */
+const getFlattenedSections = forward(getFlattenedSectionsImplementation);
+/** Returns the indentation prefix that appears before a given offset. */
+const getIndentationAtOffset = forward(getIndentationAtOffsetImplementation);
+/** Resolves the starting range for a specific source line. */
+const getLineStartRange = forward(getLineStartRangeImplementation);
+/** Filters section comments down to phase boundaries that matter after Arrange. */
+const getPhaseBoundaryComments = forward(getPhaseBoundaryCommentsImplementation);
+/** Parses AAA phases from a section comment value. */
+const getSectionPhases = forward(getSectionPhasesImplementation);
+/** Detects whether a statement contains any assertion call. */
+const hasAssertion = forward(hasAssertionImplementation);
+/** Detects asynchronous behavior such as awaits, promise chains, and promises. */
+const hasAsyncLogic = forward(hasAsyncLogicImplementation);
+/** Detects whether a statement contains an `await` expression. */
+const hasAwait = forward(hasAwaitImplementation);
+/** Checks whether a section comment is separated by a blank line. */
+const hasBlankLineBeforeComment = forward(hasBlankLineBeforeCommentImplementation);
+/** Detects Act expressions whose result should usually be captured. */
+const hasCapturableActResult = forward(hasCapturableActResultImplementation);
+/** Detects mutation-oriented statements and array mutator calls. */
+const hasMutation = forward(hasMutationImplementation);
+/** Detects statements that represent meaningful Act steps. */
+const isMeaningfulActStatement = forward(isMeaningfulActStatementImplementation);
+/** Detects statements that should stay in Arrange as setup helpers. */
+const isSetupLikeStatement = forward(isSetupLikeStatementImplementation);
+/** Detects whether a statement shape is valid inside Assert. */
+const isValidAssertStatement = forward(isValidAssertStatementImplementation);
+/** Checks whether an identifier matches the expected AAA naming prefix. */
+const usesPrefix = forward(usesPrefixImplementation);
+export { aaaPhaseOrder, analyzeTestBlock, countActStatements, getAssertDeclaredIdentifiers, getAssertionIdentifiers, getFlattenedSections, getIndentationAtOffset, getLineStartRange, getPhaseBoundaryComments, getSectionPhases, hasAssertion, hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, usesPrefix, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyzer.js","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  aaaPhaseOrder as aaaPhaseOrderImplementation,\n  analyzeTestBlock as analyzeTestBlockImplementation,\n  countActStatements as countActStatementsImplementation,\n  getFlattenedSections as getFlattenedSectionsImplementation,\n  getIndentationAtOffset as getIndentationAtOffsetImplementation,\n  getLineStartRange as getLineStartRangeImplementation,\n  getPhaseBoundaryComments as getPhaseBoundaryCommentsImplementation,\n  getSectionPhases as getSectionPhasesImplementation,\n} from \"./analyzer.analysis\";\nimport {\n  getAssertDeclaredIdentifiers as getAssertDeclaredIdentifiersImplementation,\n  getAssertionIdentifiers as getAssertionIdentifiersImplementation,\n  hasAssertion as hasAssertionImplementation,\n  isValidAssertStatement as isValidAssertStatementImplementation,\n  usesPrefix as usesPrefixImplementation,\n} from \"./analyzer.assertions\";\nimport {\n  hasAsyncLogic as hasAsyncLogicImplementation,\n  hasAwait as hasAwaitImplementation,\n  hasBlankLineBeforeComment as hasBlankLineBeforeCommentImplementation,\n  hasCapturableActResult as hasCapturableActResultImplementation,\n  hasMutation as hasMutationImplementation,\n  isMeaningfulActStatement as isMeaningfulActStatementImplementation,\n  isSetupLikeStatement as isSetupLikeStatementImplementation,\n} from \"./analyzer.classification\";\n\n/** Canonical ordering used when comparing AAA phases. */\nconst aaaPhaseOrder = aaaPhaseOrderImplementation;\n\n/**\n * Creates a local forwarding function for an imported analyzer helper.\n * @template TParameters Forwarded parameter tuple.\n * @template TResult Forwarded return type.\n * @param implementation Imported helper implementation.\n * @returns Local function that forwards all arguments to the implementation.\n * @example\n * ```typescript\n * const localHelper = forward(implementation);\n * ```\n */\nfunction forward<TParameters extends unknown[], TResult>(\n  implementation: (...parameters: TParameters) => TResult,\n): (...parameters: TParameters) => TResult {\n  return (...parameters) => implementation(...parameters);\n}\n\n/** Analyzes a supported `it` or `test` callback for AAA sections. */\nconst analyzeTestBlock = forward(analyzeTestBlockImplementation);\n\n/** Counts statement forms that should be treated as Act steps. */\nconst countActStatements = forward(countActStatementsImplementation);\n\n/** Collects identifiers declared inside Assert sections. */\nconst getAssertDeclaredIdentifiers = forward(\n  getAssertDeclaredIdentifiersImplementation,\n);\n\n/** Extracts `actual` and `expected` identifiers from assertion statements. */\nconst getAssertionIdentifiers = forward(getAssertionIdentifiersImplementation);\n\n/** Flattens section comments into one entry per resolved phase. */\nconst getFlattenedSections = forward(getFlattenedSectionsImplementation);\n\n/** Returns the indentation prefix that appears before a given offset. */\nconst getIndentationAtOffset = forward(getIndentationAtOffsetImplementation);\n\n/** Resolves the starting range for a specific source line. */\nconst getLineStartRange = forward(getLineStartRangeImplementation);\n\n/** Filters section comments down to phase boundaries that matter after Arrange. */\nconst getPhaseBoundaryComments = forward(\n  getPhaseBoundaryCommentsImplementation,\n);\n\n/** Parses AAA phases from a section comment value. */\nconst getSectionPhases = forward(getSectionPhasesImplementation);\n\n/** Detects whether a statement contains any assertion call. */\nconst hasAssertion = forward(hasAssertionImplementation);\n\n/** Detects asynchronous behavior such as awaits, promise chains, and promises. */\nconst hasAsyncLogic = forward(hasAsyncLogicImplementation);\n\n/** Detects whether a statement contains an `await` expression. */\nconst hasAwait = forward(hasAwaitImplementation);\n\n/** Checks whether a section comment is separated by a blank line. */\nconst hasBlankLineBeforeComment = forward(\n  hasBlankLineBeforeCommentImplementation,\n);\n\n/** Detects Act expressions whose result should usually be captured. */\nconst hasCapturableActResult = forward(hasCapturableActResultImplementation);\n\n/** Detects mutation-oriented statements and array mutator calls. */\nconst hasMutation = forward(hasMutationImplementation);\n\n/** Detects statements that represent meaningful Act steps. */\nconst isMeaningfulActStatement = forward(\n  isMeaningfulActStatementImplementation,\n);\n\n/** Detects statements that should stay in Arrange as setup helpers. */\nconst isSetupLikeStatement = forward(isSetupLikeStatementImplementation);\n\n/** Detects whether a statement shape is valid inside Assert. */\nconst isValidAssertStatement = forward(isValidAssertStatementImplementation);\n\n/** Checks whether an identifier matches the expected AAA naming prefix. */\nconst usesPrefix = forward(usesPrefixImplementation);\n\nexport {\n  aaaPhaseOrder,\n  analyzeTestBlock,\n  countActStatements,\n  getAssertDeclaredIdentifiers,\n  getAssertionIdentifiers,\n  getFlattenedSections,\n  getIndentationAtOffset,\n  getLineStartRange,\n  getPhaseBoundaryComments,\n  getSectionPhases,\n  hasAssertion,\n  hasAsyncLogic,\n  hasAwait,\n  hasBlankLineBeforeComment,\n  hasCapturableActResult,\n  hasMutation,\n  isMeaningfulActStatement,\n  isSetupLikeStatement,\n  isValidAssertStatement,\n  usesPrefix,\n};\n"]}

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

@@ -0,0 +1,107 @@
+import type * as ESTree from "estree";
+import type { LocatedComment, SourceComment } from "./types.js";
+/** Array mutator methods that imply observable state changes. */
+declare const arrayMutationMethods: Set<string>;
+/** Names that usually signal Arrange-oriented helper calls. */
+declare const setupLikeNames: RegExp;
+/** Call names that should be treated as utility operations instead of Act steps. */
+declare const utilityMethodNames: Set<string>;
+/** Method names that usually behave like void side-effect helpers. */
+declare const voidLikeMethodNames: Set<string>;
+/** Name pattern used for void-like method detection. */
+declare const voidLikeNamePattern: RegExp;
+/**
+ * Gets an expression name when it can be resolved statically.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getExpressionName(expression);
+ * ```
+ */
+declare function getExpressionName(expression: ESTree.Expression | ESTree.PrivateIdentifier | ESTree.Super): string | undefined;
+/**
+ * Gets a callee name for a call or construction expression.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getInvokedName(expression);
+ * ```
+ */
+declare function getInvokedName(expression: ESTree.CallExpression | ESTree.NewExpression): string | undefined;
+/**
+ * Checks whether an expression is callable.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isCallableExpression(expression);
+ * ```
+ */
+declare function isCallableExpression(expression: ESTree.Expression | undefined): expression is ESTree.CallExpression | ESTree.NewExpression;
+/**
+ * Checks whether a comment has location metadata.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isLocatedComment(comment);
+ * ```
+ */
+declare function isLocatedComment(comment: SourceComment): comment is LocatedComment;
+/**
+ * Checks whether a range is fully contained within another range.
+ * @param range Input range value.
+ * @param container Input container value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isRangeWithin(range, container);
+ * ```
+ */
+declare function isRangeWithin(range: [number, number], container: [number, number]): boolean;
+/**
+ * Checks whether a constructor call should be treated as setup.
+ * @param expression Input expression value.
+ * @param calleeName Input calleeName value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isUtilityConstructor(expression, "Map");
+ * ```
+ */
+declare function isUtilityConstructor(expression: ESTree.CallExpression | ESTree.NewExpression, calleeName: string): boolean;
+/**
+ * Checks whether a callee name looks utility-like.
+ * @param calleeName Input calleeName value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isUtilityNamedCall("setupFixture");
+ * ```
+ */
+declare function isUtilityNamedCall(calleeName: string): boolean;
+/**
+ * Checks whether a call uses a utility namespace.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isUtilityNamespaceCall(expression);
+ * ```
+ */
+declare function isUtilityNamespaceCall(expression: ESTree.CallExpression | ESTree.NewExpression): boolean;
+/**
+ * Visits an ESTree node graph while ignoring cycles.
+ * @param node Input node value.
+ * @param callback Input callback value.
+ * @param seenNodes Input seenNodes value.
+ * @example
+ * ```typescript
+ * visitNode(node, () => {});
+ * ```
+ */
+declare function visitNode(node: ESTree.Node, callback: (node: ESTree.Node) => void, seenNodes?: WeakSet<object>): void;
+export { arrayMutationMethods, getExpressionName, getInvokedName, isCallableExpression, isLocatedComment, isRangeWithin, isUtilityConstructor, isUtilityNamedCall, isUtilityNamespaceCall, setupLikeNames, utilityMethodNames, visitNode, voidLikeMethodNames, voidLikeNamePattern, };
+//# sourceMappingURL=analyzer.super.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.super.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.super.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7D,iEAAiE;AACjE,QAAA,MAAM,oBAAoB,aAUxB,CAAC;AAEH,+DAA+D;AAC/D,QAAA,MAAM,cAAc,QACsE,CAAC;AAE3F,oFAAoF;AACpF,QAAA,MAAM,kBAAkB,aAiBtB,CAAC;AAEH,sEAAsE;AACtE,QAAA,MAAM,mBAAmB,aAavB,CAAC;AAEH,wDAAwD;AACxD,QAAA,MAAM,mBAAmB,QACwD,CAAC;AAQlF;;;;;;;;GAQG;AACH,iBAAS,iBAAiB,CACxB,UAAU,EAAE,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,iBAAiB,GAAG,MAAM,CAAC,KAAK,GACtE,MAAM,GAAG,SAAS,CAiBpB;AAED;;;;;;;;GAQG;AACH,iBAAS,cAAc,CACrB,UAAU,EAAE,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,aAAa,GACvD,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAC3B,UAAU,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,GACxC,UAAU,IAAI,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,aAAa,CAK5D;AAED;;;;;;;;GAQG;AACH,iBAAS,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,IAAI,cAAc,CAI3E;AAoBD;;;;;;;;;GASG;AACH,iBAAS,aAAa,CACpB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACvB,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1B,OAAO,CAET;AAED;;;;;;;;;GASG;AACH,iBAAS,oBAAoB,CAC3B,UAAU,EAAE,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,aAAa,EACxD,UAAU,EAAE,MAAM,GACjB,OAAO,CAQT;AAED;;;;;;;;GAQG;AACH,iBAAS,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;;;;;GAQG;AACH,iBAAS,sBAAsB,CAC7B,UAAU,EAAE,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,aAAa,GACvD,OAAO,CAMT;AAED;;;;;;;;;GASG;AACH,iBAAS,SAAS,CAChB,IAAI,EAAE,MAAM,CAAC,IAAI,EACjB,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,KAAK,IAAI,EACrC,SAAS,kBAAwB,GAChC,IAAI,CAaN;AAgCD,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,aAAa,EACb,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,EACtB,cAAc,EACd,kBAAkB,EAClB,SAAS,EACT,mBAAmB,EACnB,mBAAmB,GACpB,CAAC"}

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

@@ -0,0 +1,228 @@
+/* eslint max-lines: ["error", 320] -- Mandatory multiline JSDoc for these shared helper functions pushes this split file over the default limit. */
+/** Array mutator methods that imply observable state changes. */
+const arrayMutationMethods = new Set([
+    "copyWithin",
+    "fill",
+    "pop",
+    "push",
+    "reverse",
+    "shift",
+    "sort",
+    "splice",
+    "unshift",
+]);
+/** Names that usually signal Arrange-oriented helper calls. */
+const setupLikeNames = /^(?:arrange|build|create|fixture|get|given|make|mock|parse|seed|setup|spy|stub|write)/u;
+/** Call names that should be treated as utility operations instead of Act steps. */
+const utilityMethodNames = new Set([
+    "advanceTimersByTime",
+    "clearAllMocks",
+    "debug",
+    "fn",
+    "info",
+    "join",
+    "log",
+    "mockImplementation",
+    "mockRejectedValue",
+    "mockResolvedValue",
+    "mockReturnValue",
+    "push",
+    "resetAllMocks",
+    "resolve",
+    "useFakeTimers",
+    "warn",
+]);
+/** Method names that usually behave like void side-effect helpers. */
+const voidLikeMethodNames = new Set([
+    "clear",
+    "debug",
+    "dispatch",
+    "emit",
+    "info",
+    "log",
+    "print",
+    "publish",
+    "reset",
+    "set",
+    "trigger",
+    "warn",
+]);
+/** Name pattern used for void-like method detection. */
+const voidLikeNamePattern = /^(?:clear|debug|dispatch|emit|info|log|print|publish|reset|set|trigger|warn)/u;
+/**
+ * Gets an expression name when it can be resolved statically.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getExpressionName(expression);
+ * ```
+ */
+function getExpressionName(expression) {
+    if (expression.type === "Super") {
+        return void 0;
+    }
+    if (expression.type === "Identifier") {
+        return expression.name;
+    }
+    if (expression.type === "MemberExpression" &&
+        expression.property.type === "Identifier") {
+        return expression.property.name;
+    }
+    return void 0;
+}
+/**
+ * Gets a callee name for a call or construction expression.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getInvokedName(expression);
+ * ```
+ */
+function getInvokedName(expression) {
+    return getExpressionName(expression.callee);
+}
+/**
+ * Checks whether an expression is callable.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isCallableExpression(expression);
+ * ```
+ */
+function isCallableExpression(expression) {
+    return (expression?.type === "CallExpression" ||
+        expression?.type === "NewExpression");
+}
+/**
+ * Checks whether a comment has location metadata.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isLocatedComment(comment);
+ * ```
+ */
+function isLocatedComment(comment) {
+    return (comment.loc !== null && comment.loc !== void 0 && comment.range !== void 0);
+}
+/**
+ * Checks whether a value is an ESTree node.
+ * @param value Input value value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isNode(value);
+ * ```
+ */
+function isNode(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "type" in value &&
+        typeof value.type === "string");
+}
+/**
+ * Checks whether a range is fully contained within another range.
+ * @param range Input range value.
+ * @param container Input container value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isRangeWithin(range, container);
+ * ```
+ */
+function isRangeWithin(range, container) {
+    return range[0] >= container[0] && range[1] <= container[1];
+}
+/**
+ * Checks whether a constructor call should be treated as setup.
+ * @param expression Input expression value.
+ * @param calleeName Input calleeName value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isUtilityConstructor(expression, "Map");
+ * ```
+ */
+function isUtilityConstructor(expression, calleeName) {
+    return (expression.type === "NewExpression" &&
+        (calleeName === "Map" ||
+            calleeName === "Set" ||
+            calleeName === "SourceCode" ||
+            calleeName === "ESLint"));
+}
+/**
+ * Checks whether a callee name looks utility-like.
+ * @param calleeName Input calleeName value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isUtilityNamedCall("setupFixture");
+ * ```
+ */
+function isUtilityNamedCall(calleeName) {
+    return utilityMethodNames.has(calleeName) || setupLikeNames.test(calleeName);
+}
+/**
+ * Checks whether a call uses a utility namespace.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isUtilityNamespaceCall(expression);
+ * ```
+ */
+function isUtilityNamespaceCall(expression) {
+    return (expression.callee.type === "MemberExpression" &&
+        expression.callee.object.type === "Identifier" &&
+        ["console", "vi"].includes(expression.callee.object.name));
+}
+/**
+ * Visits an ESTree node graph while ignoring cycles.
+ * @param node Input node value.
+ * @param callback Input callback value.
+ * @param seenNodes Input seenNodes value.
+ * @example
+ * ```typescript
+ * visitNode(node, () => {});
+ * ```
+ */
+function visitNode(node, callback, seenNodes = new WeakSet()) {
+    if (seenNodes.has(node)) {
+        return;
+    }
+    seenNodes.add(node);
+    callback(node);
+    for (const [key, value] of Object.entries(node)) {
+        if (key !== "parent") {
+            visitValue(value, callback, seenNodes);
+        }
+    }
+}
+/**
+ * Visits child values that may contain nested ESTree nodes.
+ * @param value Input value value.
+ * @param callback Input callback value.
+ * @param seenNodes Input seenNodes value.
+ * @example
+ * ```typescript
+ * visitValue(value, () => {}, new WeakSet<object>());
+ * ```
+ */
+function visitValue(value, callback, seenNodes) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (isNode(item)) {
+                visitNode(item, callback, seenNodes);
+            }
+        }
+        return;
+    }
+    if (isNode(value)) {
+        visitNode(value, callback, seenNodes);
+    }
+}
+export { arrayMutationMethods, getExpressionName, getInvokedName, isCallableExpression, isLocatedComment, isRangeWithin, isUtilityConstructor, isUtilityNamedCall, isUtilityNamespaceCall, setupLikeNames, utilityMethodNames, visitNode, voidLikeMethodNames, voidLikeNamePattern, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyzer.super.js","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.super.ts"],"names":[],"mappings":"AAAA,oJAAoJ;AAMpJ,iEAAiE;AACjE,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC;IACnC,YAAY;IACZ,MAAM;IACN,KAAK;IACL,MAAM;IACN,SAAS;IACT,OAAO;IACP,MAAM;IACN,QAAQ;IACR,SAAS;CACV,CAAC,CAAC;AAEH,+DAA+D;AAC/D,MAAM,cAAc,GAClB,wFAAwF,CAAC;AAE3F,oFAAoF;AACpF,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC;IACjC,qBAAqB;IACrB,eAAe;IACf,OAAO;IACP,IAAI;IACJ,MAAM;IACN,MAAM;IACN,KAAK;IACL,oBAAoB;IACpB,mBAAmB;IACnB,mBAAmB;IACnB,iBAAiB;IACjB,MAAM;IACN,eAAe;IACf,SAAS;IACT,eAAe;IACf,MAAM;CACP,CAAC,CAAC;AAEH,sEAAsE;AACtE,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC;IAClC,OAAO;IACP,OAAO;IACP,UAAU;IACV,MAAM;IACN,MAAM;IACN,KAAK;IACL,OAAO;IACP,SAAS;IACT,OAAO;IACP,KAAK;IACL,SAAS;IACT,MAAM;CACP,CAAC,CAAC;AAEH,wDAAwD;AACxD,MAAM,mBAAmB,GACvB,+EAA+E,CAAC;AAQlF;;;;;;;;GAQG;AACH,SAAS,iBAAiB,CACxB,UAAuE;IAEvE,IAAI,UAAU,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAChC,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,IAAI,UAAU,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;QACrC,OAAO,UAAU,CAAC,IAAI,CAAC;IACzB,CAAC;IAED,IACE,UAAU,CAAC,IAAI,KAAK,kBAAkB;QACtC,UAAU,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY,EACzC,CAAC;QACD,OAAO,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC;IAClC,CAAC;IAED,OAAO,KAAK,CAAC,CAAC;AAChB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,cAAc,CACrB,UAAwD;IAExD,OAAO,iBAAiB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,oBAAoB,CAC3B,UAAyC;IAEzC,OAAO,CACL,UAAU,EAAE,IAAI,KAAK,gBAAgB;QACrC,UAAU,EAAE,IAAI,KAAK,eAAe,CACrC,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,gBAAgB,CAAC,OAAsB;IAC9C,OAAO,CACL,OAAO,CAAC,GAAG,KAAK,IAAI,IAAI,OAAO,CAAC,GAAG,KAAK,KAAK,CAAC,IAAI,OAAO,CAAC,KAAK,KAAK,KAAK,CAAC,CAC3E,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,MAAM,CAAC,KAAc;IAC5B,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,MAAM,IAAI,KAAK;QACf,OAAQ,KAAuB,CAAC,IAAI,KAAK,QAAQ,CAClD,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,aAAa,CACpB,KAAuB,EACvB,SAA2B;IAE3B,OAAO,KAAK,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,oBAAoB,CAC3B,UAAwD,EACxD,UAAkB;IAElB,OAAO,CACL,UAAU,CAAC,IAAI,KAAK,eAAe;QACnC,CAAC,UAAU,KAAK,KAAK;YACnB,UAAU,KAAK,KAAK;YACpB,UAAU,KAAK,YAAY;YAC3B,UAAU,KAAK,QAAQ,CAAC,CAC3B,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,kBAAkB,CAAC,UAAkB;IAC5C,OAAO,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,sBAAsB,CAC7B,UAAwD;IAExD,OAAO,CACL,UAAU,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB;QAC7C,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY;QAC9C,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAC1D,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,SAAS,CAChB,IAAiB,EACjB,QAAqC,EACrC,YAAY,IAAI,OAAO,EAAU;IAEjC,IAAI,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,OAAO;IACT,CAAC;IAED,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,CAAC;IAEf,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAChD,IAAI,GAAG,KAAK,QAAQ,EAAE,CAAC;YACrB,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,UAAU,CACjB,KAAc,EACd,QAAqC,EACrC,SAA0B;IAE1B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;gBACjB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;YACvC,CAAC;QACH,CAAC;QAED,OAAO;IACT,CAAC;IAED,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;QAClB,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC;IACxC,CAAC;AACH,CAAC;AAED,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,aAAa,EACb,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,EACtB,cAAc,EACd,kBAAkB,EAClB,SAAS,EACT,mBAAmB,EACnB,mBAAmB,GACpB,CAAC","sourcesContent":["/* eslint max-lines: [\"error\", 320] -- Mandatory multiline JSDoc for these shared helper functions pushes this split file over the default limit. */\r\n\r\nimport type * as ESTree from \"estree\";\r\n\r\nimport type { LocatedComment, SourceComment } from \"./types\";\r\n\r\n/** Array mutator methods that imply observable state changes. */\r\nconst arrayMutationMethods = new Set([\r\n  \"copyWithin\",\r\n  \"fill\",\r\n  \"pop\",\r\n  \"push\",\r\n  \"reverse\",\r\n  \"shift\",\r\n  \"sort\",\r\n  \"splice\",\r\n  \"unshift\",\r\n]);\r\n\r\n/** Names that usually signal Arrange-oriented helper calls. */\r\nconst setupLikeNames =\r\n  /^(?:arrange|build|create|fixture|get|given|make|mock|parse|seed|setup|spy|stub|write)/u;\r\n\r\n/** Call names that should be treated as utility operations instead of Act steps. */\r\nconst utilityMethodNames = new Set([\r\n  \"advanceTimersByTime\",\r\n  \"clearAllMocks\",\r\n  \"debug\",\r\n  \"fn\",\r\n  \"info\",\r\n  \"join\",\r\n  \"log\",\r\n  \"mockImplementation\",\r\n  \"mockRejectedValue\",\r\n  \"mockResolvedValue\",\r\n  \"mockReturnValue\",\r\n  \"push\",\r\n  \"resetAllMocks\",\r\n  \"resolve\",\r\n  \"useFakeTimers\",\r\n  \"warn\",\r\n]);\r\n\r\n/** Method names that usually behave like void side-effect helpers. */\r\nconst voidLikeMethodNames = new Set([\r\n  \"clear\",\r\n  \"debug\",\r\n  \"dispatch\",\r\n  \"emit\",\r\n  \"info\",\r\n  \"log\",\r\n  \"print\",\r\n  \"publish\",\r\n  \"reset\",\r\n  \"set\",\r\n  \"trigger\",\r\n  \"warn\",\r\n]);\r\n\r\n/** Name pattern used for void-like method detection. */\r\nconst voidLikeNamePattern =\r\n  /^(?:clear|debug|dispatch|emit|info|log|print|publish|reset|set|trigger|warn)/u;\r\n\r\n/** Object shape used for ESTree node narrowing. */\r\ninterface NodeLikeValue {\r\n  /** Potential ESTree node type field. */\r\n  type?: unknown;\r\n}\r\n\r\n/**\r\n * Gets an expression name when it can be resolved statically.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getExpressionName(expression);\r\n * ```\r\n */\r\nfunction getExpressionName(\r\n  expression: ESTree.Expression | ESTree.PrivateIdentifier | ESTree.Super,\r\n): string | undefined {\r\n  if (expression.type === \"Super\") {\r\n    return void 0;\r\n  }\r\n\r\n  if (expression.type === \"Identifier\") {\r\n    return expression.name;\r\n  }\r\n\r\n  if (\r\n    expression.type === \"MemberExpression\" &&\r\n    expression.property.type === \"Identifier\"\r\n  ) {\r\n    return expression.property.name;\r\n  }\r\n\r\n  return void 0;\r\n}\r\n\r\n/**\r\n * Gets a callee name for a call or construction expression.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getInvokedName(expression);\r\n * ```\r\n */\r\nfunction getInvokedName(\r\n  expression: ESTree.CallExpression | ESTree.NewExpression,\r\n): string | undefined {\r\n  return getExpressionName(expression.callee);\r\n}\r\n\r\n/**\r\n * Checks whether an expression is callable.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isCallableExpression(expression);\r\n * ```\r\n */\r\nfunction isCallableExpression(\r\n  expression: ESTree.Expression | undefined,\r\n): expression is ESTree.CallExpression | ESTree.NewExpression {\r\n  return (\r\n    expression?.type === \"CallExpression\" ||\r\n    expression?.type === \"NewExpression\"\r\n  );\r\n}\r\n\r\n/**\r\n * Checks whether a comment has location metadata.\r\n * @param comment Input comment value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isLocatedComment(comment);\r\n * ```\r\n */\r\nfunction isLocatedComment(comment: SourceComment): comment is LocatedComment {\r\n  return (\r\n    comment.loc !== null && comment.loc !== void 0 && comment.range !== void 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks whether a value is an ESTree node.\r\n * @param value Input value value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isNode(value);\r\n * ```\r\n */\r\nfunction isNode(value: unknown): value is ESTree.Node {\r\n  return (\r\n    typeof value === \"object\" &&\r\n    value !== null &&\r\n    \"type\" in value &&\r\n    typeof (value as NodeLikeValue).type === \"string\"\r\n  );\r\n}\r\n\r\n/**\r\n * Checks whether a range is fully contained within another range.\r\n * @param range Input range value.\r\n * @param container Input container value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isRangeWithin(range, container);\r\n * ```\r\n */\r\nfunction isRangeWithin(\r\n  range: [number, number],\r\n  container: [number, number],\r\n): boolean {\r\n  return range[0] >= container[0] && range[1] <= container[1];\r\n}\r\n\r\n/**\r\n * Checks whether a constructor call should be treated as setup.\r\n * @param expression Input expression value.\r\n * @param calleeName Input calleeName value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isUtilityConstructor(expression, \"Map\");\r\n * ```\r\n */\r\nfunction isUtilityConstructor(\r\n  expression: ESTree.CallExpression | ESTree.NewExpression,\r\n  calleeName: string,\r\n): boolean {\r\n  return (\r\n    expression.type === \"NewExpression\" &&\r\n    (calleeName === \"Map\" ||\r\n      calleeName === \"Set\" ||\r\n      calleeName === \"SourceCode\" ||\r\n      calleeName === \"ESLint\")\r\n  );\r\n}\r\n\r\n/**\r\n * Checks whether a callee name looks utility-like.\r\n * @param calleeName Input calleeName value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isUtilityNamedCall(\"setupFixture\");\r\n * ```\r\n */\r\nfunction isUtilityNamedCall(calleeName: string): boolean {\r\n  return utilityMethodNames.has(calleeName) || setupLikeNames.test(calleeName);\r\n}\r\n\r\n/**\r\n * Checks whether a call uses a utility namespace.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isUtilityNamespaceCall(expression);\r\n * ```\r\n */\r\nfunction isUtilityNamespaceCall(\r\n  expression: ESTree.CallExpression | ESTree.NewExpression,\r\n): boolean {\r\n  return (\r\n    expression.callee.type === \"MemberExpression\" &&\r\n    expression.callee.object.type === \"Identifier\" &&\r\n    [\"console\", \"vi\"].includes(expression.callee.object.name)\r\n  );\r\n}\r\n\r\n/**\r\n * Visits an ESTree node graph while ignoring cycles.\r\n * @param node Input node value.\r\n * @param callback Input callback value.\r\n * @param seenNodes Input seenNodes value.\r\n * @example\r\n * ```typescript\r\n * visitNode(node, () => {});\r\n * ```\r\n */\r\nfunction visitNode(\r\n  node: ESTree.Node,\r\n  callback: (node: ESTree.Node) => void,\r\n  seenNodes = new WeakSet<object>(),\r\n): void {\r\n  if (seenNodes.has(node)) {\r\n    return;\r\n  }\r\n\r\n  seenNodes.add(node);\r\n  callback(node);\r\n\r\n  for (const [key, value] of Object.entries(node)) {\r\n    if (key !== \"parent\") {\r\n      visitValue(value, callback, seenNodes);\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Visits child values that may contain nested ESTree nodes.\r\n * @param value Input value value.\r\n * @param callback Input callback value.\r\n * @param seenNodes Input seenNodes value.\r\n * @example\r\n * ```typescript\r\n * visitValue(value, () => {}, new WeakSet<object>());\r\n * ```\r\n */\r\nfunction visitValue(\r\n  value: unknown,\r\n  callback: (node: ESTree.Node) => void,\r\n  seenNodes: WeakSet<object>,\r\n): void {\r\n  if (Array.isArray(value)) {\r\n    for (const item of value) {\r\n      if (isNode(item)) {\r\n        visitNode(item, callback, seenNodes);\r\n      }\r\n    }\r\n\r\n    return;\r\n  }\r\n\r\n  if (isNode(value)) {\r\n    visitNode(value, callback, seenNodes);\r\n  }\r\n}\r\n\r\nexport {\r\n  arrayMutationMethods,\r\n  getExpressionName,\r\n  getInvokedName,\r\n  isCallableExpression,\r\n  isLocatedComment,\r\n  isRangeWithin,\r\n  isUtilityConstructor,\r\n  isUtilityNamedCall,\r\n  isUtilityNamespaceCall,\r\n  setupLikeNames,\r\n  utilityMethodNames,\r\n  visitNode,\r\n  voidLikeMethodNames,\r\n  voidLikeNamePattern,\r\n};\r\n"]}

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

@@ -1,3 +1,3 @@
-export { aaaPhaseOrder, analyzeTestBlock, countActStatements, getAssertDeclaredIdentifiers, getAssertionIdentifiers, getFlattenedSections, getIndentationAtOffset, getLineStartRange, getPhaseBoundaryComments, getSectionPhases, hasAssertion, hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, usesPrefix, } from "./analyzer";
-export type { AaaPhase, LocatedComment, LocatedNode, SectionComment, SourceComment, StatementPhase, TestBlockAnalysis, } from "./types";
+export { aaaPhaseOrder, analyzeTestBlock, countActStatements, getAssertDeclaredIdentifiers, getAssertionIdentifiers, getFlattenedSections, getIndentationAtOffset, getLineStartRange, getPhaseBoundaryComments, getSectionPhases, hasAssertion, hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, usesPrefix, } from "./analyzer.js";
+export type { AaaPhase, LocatedComment, LocatedNode, SectionComment, SourceComment, StatementPhase, TestBlockAnalysis, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,4BAA4B,EAC5B,uBAAuB,EACvB,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,wBAAwB,EACxB,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,yBAAyB,EACzB,sBAAsB,EACtB,WAAW,EACX,wBAAwB,EACxB,oBAAoB,EACpB,sBAAsB,EACtB,UAAU,GACX,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,QAAQ,EACR,cAAc,EACd,WAAW,EACX,cAAc,EACd,aAAa,EACb,cAAc,EACd,iBAAiB,GAClB,MAAM,SAAS,CAAC"}

package/dist/domain/testing/aaa/index.js

@@ -0,0 +1,2 @@
+export { aaaPhaseOrder, analyzeTestBlock, countActStatements, getAssertDeclaredIdentifiers, getAssertionIdentifiers, getFlattenedSections, getIndentationAtOffset, getLineStartRange, getPhaseBoundaryComments, getSectionPhases, hasAssertion, hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, usesPrefix, } from "./analyzer.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvYWFhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxhQUFhLEVBQ2IsZ0JBQWdCLEVBQ2hCLGtCQUFrQixFQUNsQiw0QkFBNEIsRUFDNUIsdUJBQXVCLEVBQ3ZCLG9CQUFvQixFQUNwQixzQkFBc0IsRUFDdEIsaUJBQWlCLEVBQ2pCLHdCQUF3QixFQUN4QixnQkFBZ0IsRUFDaEIsWUFBWSxFQUNaLGFBQWEsRUFDYixRQUFRLEVBQ1IseUJBQXlCLEVBQ3pCLHNCQUFzQixFQUN0QixXQUFXLEVBQ1gsd0JBQXdCLEVBQ3hCLG9CQUFvQixFQUNwQixzQkFBc0IsRUFDdEIsVUFBVSxHQUNYLE1BQU0sWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgYWFhUGhhc2VPcmRlcixcbiAgYW5hbHl6ZVRlc3RCbG9jayxcbiAgY291bnRBY3RTdGF0ZW1lbnRzLFxuICBnZXRBc3NlcnREZWNsYXJlZElkZW50aWZpZXJzLFxuICBnZXRBc3NlcnRpb25JZGVudGlmaWVycyxcbiAgZ2V0RmxhdHRlbmVkU2VjdGlvbnMsXG4gIGdldEluZGVudGF0aW9uQXRPZmZzZXQsXG4gIGdldExpbmVTdGFydFJhbmdlLFxuICBnZXRQaGFzZUJvdW5kYXJ5Q29tbWVudHMsXG4gIGdldFNlY3Rpb25QaGFzZXMsXG4gIGhhc0Fzc2VydGlvbixcbiAgaGFzQXN5bmNMb2dpYyxcbiAgaGFzQXdhaXQsXG4gIGhhc0JsYW5rTGluZUJlZm9yZUNvbW1lbnQsXG4gIGhhc0NhcHR1cmFibGVBY3RSZXN1bHQsXG4gIGhhc011dGF0aW9uLFxuICBpc01lYW5pbmdmdWxBY3RTdGF0ZW1lbnQsXG4gIGlzU2V0dXBMaWtlU3RhdGVtZW50LFxuICBpc1ZhbGlkQXNzZXJ0U3RhdGVtZW50LFxuICB1c2VzUHJlZml4LFxufSBmcm9tIFwiLi9hbmFseXplclwiO1xuZXhwb3J0IHR5cGUge1xuICBBYWFQaGFzZSxcbiAgTG9jYXRlZENvbW1lbnQsXG4gIExvY2F0ZWROb2RlLFxuICBTZWN0aW9uQ29tbWVudCxcbiAgU291cmNlQ29tbWVudCxcbiAgU3RhdGVtZW50UGhhc2UsXG4gIFRlc3RCbG9ja0FuYWx5c2lzLFxufSBmcm9tIFwiLi90eXBlc1wiO1xuIl19

package/dist/domain/testing/aaa/types.d.ts

@@ -0,0 +1,58 @@
+import type { Rule } from "eslint";
+import type * as ESTree from "estree";
+/** Named AAA phases recognized by the analyzer. */
+type AaaPhase = "Act" | "Arrange" | "Assert";
+/** Source comment with guaranteed location and range metadata. */
+type LocatedComment = SourceComment & {
+    /** Normalized location for the comment. */
+    loc: NonNullable<SourceComment["loc"]>;
+    /** Inclusive source range for the comment. */
+    range: [number, number];
+};
+/**
+ * ESTree node with required location and range metadata.
+ * @template TNode Node subtype carried by the wrapper.
+ */
+type LocatedNode<TNode extends ESTree.Node = ESTree.Node> = TNode & {
+    /** Normalized location for the node. */
+    loc: NonNullable<ESTree.Node["loc"]>;
+    /** Inclusive source range for the node. */
+    range: [number, number];
+};
+/** Section comment and the AAA phases it declares. */
+interface SectionComment {
+    /** Located line comment used as the section marker. */
+    comment: LocatedComment;
+    /** Phases declared by the section marker. */
+    phases: AaaPhase[];
+}
+/** Raw source comment nodes returned by ESLint. */
+type SourceComment = ReturnType<Rule.RuleContext["sourceCode"]["getAllComments"]>[number];
+/** Statement annotated with its active AAA phases. */
+interface StatementPhase {
+    /** Statement node that belongs to the analyzed test body. */
+    node: LocatedNode<ESTree.Statement>;
+    /** Last active phase before this statement, when any exists. */
+    phase: AaaPhase | undefined;
+    /** All active phases inherited from the nearest section marker. */
+    phases: AaaPhase[];
+}
+/** Derived metadata for a supported test callback. */
+interface TestBlockAnalysis {
+    /** Block body belonging to the test callback. */
+    body: LocatedNode<ESTree.BlockStatement>;
+    /** Number of lines inside the callback body. */
+    bodyLineCount: number;
+    /** Original call expression for `it` or `test`. */
+    callExpression: LocatedNode<ESTree.CallExpression>;
+    /** Newline style used by the source text. */
+    newline: "\n" | "\r\n";
+    /** Ordered AAA section comments within the callback body. */
+    sectionComments: SectionComment[];
+    /** Full source text for the analyzed file. */
+    sourceText: string;
+    /** Statements paired with their resolved AAA phases. */
+    statements: StatementPhase[];
+}
+export type { AaaPhase, LocatedComment, LocatedNode, SectionComment, SourceComment, StatementPhase, TestBlockAnalysis, };
+//# sourceMappingURL=types.d.ts.map

package/dist/domain/testing/aaa/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,mDAAmD;AACnD,KAAK,QAAQ,GAAG,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE7C,kEAAkE;AAClE,KAAK,cAAc,GAAG,aAAa,GAAG;IACpC,2CAA2C;IAC3C,GAAG,EAAE,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;IAEvC,8CAA8C;IAC9C,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzB,CAAC;AAEF;;;GAGG;AACH,KAAK,WAAW,CAAC,KAAK,SAAS,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,KAAK,GAAG;IAClE,wCAAwC;IACxC,GAAG,EAAE,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAErC,2CAA2C;IAC3C,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzB,CAAC;AAEF,sDAAsD;AACtD,UAAU,cAAc;IACtB,uDAAuD;IACvD,OAAO,EAAE,cAAc,CAAC;IAExB,6CAA6C;IAC7C,MAAM,EAAE,QAAQ,EAAE,CAAC;CACpB;AAED,mDAAmD;AACnD,KAAK,aAAa,GAAG,UAAU,CAC7B,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,gBAAgB,CAAC,CACjD,CAAC,MAAM,CAAC,CAAC;AAEV,sDAAsD;AACtD,UAAU,cAAc;IACtB,6DAA6D;IAC7D,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAEpC,gEAAgE;IAChE,KAAK,EAAE,QAAQ,GAAG,SAAS,CAAC;IAE5B,mEAAmE;IACnE,MAAM,EAAE,QAAQ,EAAE,CAAC;CACpB;AAED,sDAAsD;AACtD,UAAU,iBAAiB;IACzB,iDAAiD;IACjD,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;IAEzC,gDAAgD;IAChD,aAAa,EAAE,MAAM,CAAC;IAEtB,mDAAmD;IACnD,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;IAEnD,6CAA6C;IAC7C,OAAO,EAAE,IAAI,GAAG,MAAM,CAAC;IAEvB,6DAA6D;IAC7D,eAAe,EAAE,cAAc,EAAE,CAAC;IAElC,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IAEnB,wDAAwD;IACxD,UAAU,EAAE,cAAc,EAAE,CAAC;CAC9B;AAED,YAAY,EACV,QAAQ,EACR,cAAc,EACd,WAAW,EACX,cAAc,EACd,aAAa,EACb,cAAc,EACd,iBAAiB,GAClB,CAAC"}

package/dist/domain/testing/aaa/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/testing/assert-actual-expected-names/index.d.ts

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

package/dist/domain/testing/assert-actual-expected-names/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/assert-actual-expected-names/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/testing/assert-actual-expected-names/index.js

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

package/dist/{testing → domain/testing}/assert-actual-expected-names/rule.d.ts

@@ -1,4 +1,5 @@
 import type { Rule } from "eslint";
+/** Enforces actual/expected-style prefixes for assert-phase comparison variables. */
 declare const assertActualExpectedNamesRule: Rule.RuleModule;
 export { assertActualExpectedNamesRule };
 //# sourceMappingURL=rule.d.ts.map

package/dist/domain/testing/assert-actual-expected-names/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/assert-actual-expected-names/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAsInC,qFAAqF;AACrF,QAAA,MAAM,6BAA6B,EAAE,IAAI,CAAC,UAwCzC,CAAC;AAEF,OAAO,EAAE,6BAA6B,EAAE,CAAC"}