@codeperfect/eslint-plugin 1.0.0 → 2.1.0

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

@@ -0,0 +1,203 @@
+import { getStatementExpression, hasAssertion, isActionExpression, unwrapExpression, } from "./analyzer.assertions.js";
+import { visitStatementWithoutDeferredBodies } from "./analyzer.classification.traversal.js";
+import { arrayMutationMethods, getExpressionName, getInvokedName, isCallableExpression, isLocatedComment, isUtilityConstructor, isUtilityNamedCall, isUtilityNamespaceCall, isVoidLikeMethodName, visitNode, voidLikeMethodNames, } from "./analyzer.super.js";
+/**
+ * Checks for async logic.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasAsyncLogic(statement);
+ * ```
+ */
+function hasAsyncLogic(statement) {
+    let foundAsyncLogic = false;
+    visitStatementWithoutDeferredBodies(statement, (node) => {
+        if (node.type === "AwaitExpression") {
+            foundAsyncLogic = true;
+            return;
+        }
+        if (node.type === "CallExpression" &&
+            node.callee.type === "MemberExpression" &&
+            node.callee.property.type === "Identifier" &&
+            ["catch", "finally", "then"].includes(node.callee.property.name)) {
+            foundAsyncLogic = true;
+            return;
+        }
+        if (node.type === "NewExpression" &&
+            getExpressionName(node.callee) === "Promise") {
+            foundAsyncLogic = true;
+        }
+    });
+    return foundAsyncLogic;
+}
+/**
+ * Checks for await usage.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasAwait(statement);
+ * ```
+ */
+function hasAwait(statement) {
+    let foundAwait = false;
+    visitStatementWithoutDeferredBodies(statement, (node) => {
+        if (node.type === "AwaitExpression") {
+            foundAwait = true;
+        }
+    });
+    return foundAwait;
+}
+/**
+ * Checks for blank lines before comments.
+ * @param sourceText Input sourceText value.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasBlankLineBeforeComment(sourceText, comment);
+ * ```
+ */
+function hasBlankLineBeforeComment(sourceText, comment) {
+    if (!isLocatedComment(comment)) {
+        return true;
+    }
+    const lines = sourceText.split(/\r\n|\n/u);
+    const previousLine = lines[comment.loc.start.line - 2];
+    return previousLine === void 0 || previousLine.trim().length === 0;
+}
+/**
+ * Checks for capturable Act results.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasCapturableActResult(statement);
+ * ```
+ */
+function hasCapturableActResult(statement) {
+    if (statement.type !== "ExpressionStatement") {
+        return false;
+    }
+    const expression = unwrapExpression(statement.expression);
+    if (!isActionExpression(expression) || isUtilityLikeExpression(expression)) {
+        return false;
+    }
+    const calleeName = getInvokedName(expression);
+    return (calleeName === void 0 ||
+        (!voidLikeMethodNames.has(calleeName) && !isVoidLikeMethodName(calleeName)));
+}
+/**
+ * Checks for mutation.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasMutation(statement);
+ * ```
+ */
+function hasMutation(statement) {
+    let foundMutation = false;
+    visitNode(statement, (node) => {
+        if (node.type === "AssignmentExpression" ||
+            node.type === "UpdateExpression" ||
+            node.type === "UnaryExpression") {
+            if (node.type !== "UnaryExpression" || node.operator === "delete") {
+                foundMutation = true;
+            }
+            return;
+        }
+        if (node.type === "CallExpression" &&
+            node.callee.type === "MemberExpression" &&
+            node.callee.property.type === "Identifier" &&
+            arrayMutationMethods.has(node.callee.property.name)) {
+            foundMutation = true;
+        }
+    });
+    return foundMutation;
+}
+/**
+ * Checks for meaningful Act statements.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isMeaningfulActStatement(statement);
+ * ```
+ */
+function isMeaningfulActStatement(statement) {
+    const expression = getStatementExpression(statement);
+    if (expression === void 0) {
+        return false;
+    }
+    return (isActionExpression(expression) &&
+        !isUtilityLikeExpression(expression) &&
+        !hasAssertion(statement));
+}
+/**
+ * Checks for rule create calls.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isRuleCreateInvocation(expression);
+ * ```
+ */
+function isRuleCreateInvocation(expression) {
+    return (expression.type === "CallExpression" &&
+        expression.callee.type === "MemberExpression" &&
+        expression.callee.object.type === "Identifier" &&
+        expression.callee.property.type === "Identifier" &&
+        expression.callee.property.name === "create" &&
+        expression.callee.object.name.endsWith("Rule"));
+}
+/**
+ * Checks for setup-like statements.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isSetupLikeStatement(statement);
+ * ```
+ */
+function isSetupLikeStatement(statement) {
+    if (statement.type === "VariableDeclaration") {
+        return statement.declarations.every((declaration) => {
+            if (declaration.init === null) {
+                return true;
+            }
+            const init = unwrapExpression(declaration.init);
+            return !isActionExpression(init) || isUtilityLikeExpression(init);
+        });
+    }
+    const expression = getStatementExpression(statement);
+    return expression !== void 0 && isUtilityLikeExpression(expression);
+}
+/**
+ * Checks for utility-like expressions.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isUtilityLikeExpression(expression);
+ * ```
+ */
+function isUtilityLikeExpression(expression) {
+    const unwrappedExpression = unwrapExpression(expression);
+    if (!isCallableExpression(unwrappedExpression)) {
+        return false;
+    }
+    const calleeName = getExpressionName(unwrappedExpression.callee);
+    if (calleeName === void 0) {
+        return false;
+    }
+    return (!isRuleCreateInvocation(unwrappedExpression) &&
+        (isUtilityConstructor(unwrappedExpression, calleeName) ||
+            isUtilityNamedCall(calleeName) ||
+            isUtilityNamespaceCall(unwrappedExpression)));
+}
+/** Companion marker for test isolation. */
+const analyzerClassificationHelpersCompanion = true;
+export { analyzerClassificationHelpersCompanion, hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyzer.classification.helpers.js","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.classification.helpers.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,mCAAmC,EAAE,MAAM,qCAAqC,CAAC;AAC1F,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,SAAS,EACT,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;GAQG;AACH,SAAS,aAAa,CAAC,SAA2B;IAChD,IAAI,eAAe,GAAG,KAAK,CAAC;IAC5B,mCAAmC,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE;QACtD,IAAI,IAAI,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;YACpC,eAAe,GAAG,IAAI,CAAC;YACvB,OAAO;QACT,CAAC;QACD,IACE,IAAI,CAAC,IAAI,KAAK,gBAAgB;YAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB;YACvC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;YAC1C,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EAChE,CAAC;YACD,eAAe,GAAG,IAAI,CAAC;YACvB,OAAO;QACT,CAAC;QACD,IACE,IAAI,CAAC,IAAI,KAAK,eAAe;YAC7B,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,SAAS,EAC5C,CAAC;YACD,eAAe,GAAG,IAAI,CAAC;QACzB,CAAC;IACH,CAAC,CAAC,CAAC;IACH,OAAO,eAAe,CAAC;AACzB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,QAAQ,CAAC,SAA2B;IAC3C,IAAI,UAAU,GAAG,KAAK,CAAC;IACvB,mCAAmC,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE;QACtD,IAAI,IAAI,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;YACpC,UAAU,GAAG,IAAI,CAAC;QACpB,CAAC;IACH,CAAC,CAAC,CAAC;IACH,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,yBAAyB,CAChC,UAAkB,EAClB,OAAsB;IAEtB,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC;IACd,CAAC;IACD,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAC3C,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IACvD,OAAO,YAAY,KAAK,KAAK,CAAC,IAAI,YAAY,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC;AACrE,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,sBAAsB,CAAC,SAA2B;IACzD,IAAI,SAAS,CAAC,IAAI,KAAK,qBAAqB,EAAE,CAAC;QAC7C,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,UAAU,GAAG,gBAAgB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IAC1D,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,IAAI,uBAAuB,CAAC,UAAU,CAAC,EAAE,CAAC;QAC3E,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,UAAU,GAAG,cAAc,CAC/B,UAA0D,CAC3D,CAAC;IACF,OAAO,CACL,UAAU,KAAK,KAAK,CAAC;QACrB,CAAC,CAAC,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC,CAC5E,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,WAAW,CAAC,SAA2B;IAC9C,IAAI,aAAa,GAAG,KAAK,CAAC;IAC1B,SAAS,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE;QAC5B,IACE,IAAI,CAAC,IAAI,KAAK,sBAAsB;YACpC,IAAI,CAAC,IAAI,KAAK,kBAAkB;YAChC,IAAI,CAAC,IAAI,KAAK,iBAAiB,EAC/B,CAAC;YACD,IAAI,IAAI,CAAC,IAAI,KAAK,iBAAiB,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAClE,aAAa,GAAG,IAAI,CAAC;YACvB,CAAC;YACD,OAAO;QACT,CAAC;QACD,IACE,IAAI,CAAC,IAAI,KAAK,gBAAgB;YAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB;YACvC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;YAC1C,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,EACnD,CAAC;YACD,aAAa,GAAG,IAAI,CAAC;QACvB,CAAC;IACH,CAAC,CAAC,CAAC;IACH,OAAO,aAAa,CAAC;AACvB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,wBAAwB,CAAC,SAA2B;IAC3D,MAAM,UAAU,GAAG,sBAAsB,CAAC,SAAS,CAAC,CAAC;IACrD,IAAI,UAAU,KAAK,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,CACL,kBAAkB,CAAC,UAAU,CAAC;QAC9B,CAAC,uBAAuB,CAAC,UAAU,CAAC;QACpC,CAAC,YAAY,CAAC,SAAS,CAAC,CACzB,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,sBAAsB,CAC7B,UAAwD;IAExD,OAAO,CACL,UAAU,CAAC,IAAI,KAAK,gBAAgB;QACpC,UAAU,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB;QAC7C,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY;QAC9C,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;QAChD,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,QAAQ;QAC5C,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAC/C,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,oBAAoB,CAAC,SAA2B;IACvD,IAAI,SAAS,CAAC,IAAI,KAAK,qBAAqB,EAAE,CAAC;QAC7C,OAAO,SAAS,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,EAAE;YAClD,IAAI,WAAW,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBAC9B,OAAO,IAAI,CAAC;YACd,CAAC;YACD,MAAM,IAAI,GAAG,gBAAgB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAChD,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,uBAAuB,CAAC,IAAI,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;IACL,CAAC;IACD,MAAM,UAAU,GAAG,sBAAsB,CAAC,SAAS,CAAC,CAAC;IACrD,OAAO,UAAU,KAAK,KAAK,CAAC,IAAI,uBAAuB,CAAC,UAAU,CAAC,CAAC;AACtE,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,uBAAuB,CAC9B,UAAyC;IAEzC,MAAM,mBAAmB,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACzD,IAAI,CAAC,oBAAoB,CAAC,mBAAmB,CAAC,EAAE,CAAC;QAC/C,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,UAAU,GAAG,iBAAiB,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;IACjE,IAAI,UAAU,KAAK,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,CACL,CAAC,sBAAsB,CAAC,mBAAmB,CAAC;QAC5C,CAAC,oBAAoB,CAAC,mBAAmB,EAAE,UAAU,CAAC;YACpD,kBAAkB,CAAC,UAAU,CAAC;YAC9B,sBAAsB,CAAC,mBAAmB,CAAC,CAAC,CAC/C,CAAC;AACJ,CAAC;AAED,2CAA2C;AAC3C,MAAM,sCAAsC,GAAG,IAAa,CAAC;AAE7D,OAAO,EACL,sCAAsC,EACtC,aAAa,EACb,QAAQ,EACR,yBAAyB,EACzB,sBAAsB,EACtB,WAAW,EACX,wBAAwB,EACxB,oBAAoB,GACrB,CAAC","sourcesContent":["import type * as ESTree from \"estree\";\r\n\r\nimport type { SourceComment } from \"./types\";\r\n\r\nimport {\r\n  getStatementExpression,\r\n  hasAssertion,\r\n  isActionExpression,\r\n  unwrapExpression,\r\n} from \"./analyzer.assertions\";\r\nimport { visitStatementWithoutDeferredBodies } from \"./analyzer.classification.traversal\";\r\nimport {\r\n  arrayMutationMethods,\r\n  getExpressionName,\r\n  getInvokedName,\r\n  isCallableExpression,\r\n  isLocatedComment,\r\n  isUtilityConstructor,\r\n  isUtilityNamedCall,\r\n  isUtilityNamespaceCall,\r\n  isVoidLikeMethodName,\r\n  visitNode,\r\n  voidLikeMethodNames,\r\n} from \"./analyzer.super\";\r\n\r\n/**\r\n * Checks for async logic.\r\n * @param statement Input statement value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * hasAsyncLogic(statement);\r\n * ```\r\n */\r\nfunction hasAsyncLogic(statement: ESTree.Statement): boolean {\r\n  let foundAsyncLogic = false;\r\n  visitStatementWithoutDeferredBodies(statement, (node) => {\r\n    if (node.type === \"AwaitExpression\") {\r\n      foundAsyncLogic = true;\r\n      return;\r\n    }\r\n    if (\r\n      node.type === \"CallExpression\" &&\r\n      node.callee.type === \"MemberExpression\" &&\r\n      node.callee.property.type === \"Identifier\" &&\r\n      [\"catch\", \"finally\", \"then\"].includes(node.callee.property.name)\r\n    ) {\r\n      foundAsyncLogic = true;\r\n      return;\r\n    }\r\n    if (\r\n      node.type === \"NewExpression\" &&\r\n      getExpressionName(node.callee) === \"Promise\"\r\n    ) {\r\n      foundAsyncLogic = true;\r\n    }\r\n  });\r\n  return foundAsyncLogic;\r\n}\r\n\r\n/**\r\n * Checks for await usage.\r\n * @param statement Input statement value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * hasAwait(statement);\r\n * ```\r\n */\r\nfunction hasAwait(statement: ESTree.Statement): boolean {\r\n  let foundAwait = false;\r\n  visitStatementWithoutDeferredBodies(statement, (node) => {\r\n    if (node.type === \"AwaitExpression\") {\r\n      foundAwait = true;\r\n    }\r\n  });\r\n  return foundAwait;\r\n}\r\n\r\n/**\r\n * Checks for blank lines before comments.\r\n * @param sourceText Input sourceText value.\r\n * @param comment Input comment value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * hasBlankLineBeforeComment(sourceText, comment);\r\n * ```\r\n */\r\nfunction hasBlankLineBeforeComment(\r\n  sourceText: string,\r\n  comment: SourceComment,\r\n): boolean {\r\n  if (!isLocatedComment(comment)) {\r\n    return true;\r\n  }\r\n  const lines = sourceText.split(/\\r\\n|\\n/u);\r\n  const previousLine = lines[comment.loc.start.line - 2];\r\n  return previousLine === void 0 || previousLine.trim().length === 0;\r\n}\r\n\r\n/**\r\n * Checks for capturable Act results.\r\n * @param statement Input statement value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * hasCapturableActResult(statement);\r\n * ```\r\n */\r\nfunction hasCapturableActResult(statement: ESTree.Statement): boolean {\r\n  if (statement.type !== \"ExpressionStatement\") {\r\n    return false;\r\n  }\r\n  const expression = unwrapExpression(statement.expression);\r\n  if (!isActionExpression(expression) || isUtilityLikeExpression(expression)) {\r\n    return false;\r\n  }\r\n  const calleeName = getInvokedName(\r\n    expression as ESTree.CallExpression | ESTree.NewExpression,\r\n  );\r\n  return (\r\n    calleeName === void 0 ||\r\n    (!voidLikeMethodNames.has(calleeName) && !isVoidLikeMethodName(calleeName))\r\n  );\r\n}\r\n\r\n/**\r\n * Checks for mutation.\r\n * @param statement Input statement value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * hasMutation(statement);\r\n * ```\r\n */\r\nfunction hasMutation(statement: ESTree.Statement): boolean {\r\n  let foundMutation = false;\r\n  visitNode(statement, (node) => {\r\n    if (\r\n      node.type === \"AssignmentExpression\" ||\r\n      node.type === \"UpdateExpression\" ||\r\n      node.type === \"UnaryExpression\"\r\n    ) {\r\n      if (node.type !== \"UnaryExpression\" || node.operator === \"delete\") {\r\n        foundMutation = true;\r\n      }\r\n      return;\r\n    }\r\n    if (\r\n      node.type === \"CallExpression\" &&\r\n      node.callee.type === \"MemberExpression\" &&\r\n      node.callee.property.type === \"Identifier\" &&\r\n      arrayMutationMethods.has(node.callee.property.name)\r\n    ) {\r\n      foundMutation = true;\r\n    }\r\n  });\r\n  return foundMutation;\r\n}\r\n\r\n/**\r\n * Checks for meaningful Act statements.\r\n * @param statement Input statement value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isMeaningfulActStatement(statement);\r\n * ```\r\n */\r\nfunction isMeaningfulActStatement(statement: ESTree.Statement): boolean {\r\n  const expression = getStatementExpression(statement);\r\n  if (expression === void 0) {\r\n    return false;\r\n  }\r\n  return (\r\n    isActionExpression(expression) &&\r\n    !isUtilityLikeExpression(expression) &&\r\n    !hasAssertion(statement)\r\n  );\r\n}\r\n\r\n/**\r\n * Checks for rule create calls.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isRuleCreateInvocation(expression);\r\n * ```\r\n */\r\nfunction isRuleCreateInvocation(\r\n  expression: ESTree.CallExpression | ESTree.NewExpression,\r\n): boolean {\r\n  return (\r\n    expression.type === \"CallExpression\" &&\r\n    expression.callee.type === \"MemberExpression\" &&\r\n    expression.callee.object.type === \"Identifier\" &&\r\n    expression.callee.property.type === \"Identifier\" &&\r\n    expression.callee.property.name === \"create\" &&\r\n    expression.callee.object.name.endsWith(\"Rule\")\r\n  );\r\n}\r\n\r\n/**\r\n * Checks for setup-like statements.\r\n * @param statement Input statement value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isSetupLikeStatement(statement);\r\n * ```\r\n */\r\nfunction isSetupLikeStatement(statement: ESTree.Statement): boolean {\r\n  if (statement.type === \"VariableDeclaration\") {\r\n    return statement.declarations.every((declaration) => {\r\n      if (declaration.init === null) {\r\n        return true;\r\n      }\r\n      const init = unwrapExpression(declaration.init);\r\n      return !isActionExpression(init) || isUtilityLikeExpression(init);\r\n    });\r\n  }\r\n  const expression = getStatementExpression(statement);\r\n  return expression !== void 0 && isUtilityLikeExpression(expression);\r\n}\r\n\r\n/**\r\n * Checks for utility-like expressions.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isUtilityLikeExpression(expression);\r\n * ```\r\n */\r\nfunction isUtilityLikeExpression(\r\n  expression: ESTree.Expression | undefined,\r\n): boolean {\r\n  const unwrappedExpression = unwrapExpression(expression);\r\n  if (!isCallableExpression(unwrappedExpression)) {\r\n    return false;\r\n  }\r\n  const calleeName = getExpressionName(unwrappedExpression.callee);\r\n  if (calleeName === void 0) {\r\n    return false;\r\n  }\r\n  return (\r\n    !isRuleCreateInvocation(unwrappedExpression) &&\r\n    (isUtilityConstructor(unwrappedExpression, calleeName) ||\r\n      isUtilityNamedCall(calleeName) ||\r\n      isUtilityNamespaceCall(unwrappedExpression))\r\n  );\r\n}\r\n\r\n/** Companion marker for test isolation. */\r\nconst analyzerClassificationHelpersCompanion = true as const;\r\n\r\nexport {\r\n  analyzerClassificationHelpersCompanion,\r\n  hasAsyncLogic,\r\n  hasAwait,\r\n  hasBlankLineBeforeComment,\r\n  hasCapturableActResult,\r\n  hasMutation,\r\n  isMeaningfulActStatement,\r\n  isSetupLikeStatement,\r\n};\r\n"]}

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

@@ -0,0 +1,31 @@
+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.helpers.js";
+/**
+ * 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);
+}
+/** Checks whether a statement contains any async or await logic. */
+const hasAsyncLogic = forward(hasAsyncLogicImplementation);
+/** Checks whether a node contains an `await` expression. */
+const hasAwait = forward(hasAwaitImplementation);
+/** Checks whether there is a blank line immediately before a comment node. */
+const hasBlankLineBeforeComment = forward(hasBlankLineBeforeCommentImplementation);
+/** Checks whether an Act statement produces a result worth capturing. */
+const hasCapturableActResult = forward(hasCapturableActResultImplementation);
+/** Checks whether a statement performs an observable state mutation. */
+const hasMutation = forward(hasMutationImplementation);
+/** Checks whether a statement is a meaningful Act step (not setup or assertion). */
+const isMeaningfulActStatement = forward(isMeaningfulActStatementImplementation);
+/** Checks whether a statement looks like an Arrange-phase setup step. */
+const isSetupLikeStatement = forward(isSetupLikeStatementImplementation);
+export { hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/testing/aaa/analyzer.classification.member-patterns.d.ts

@@ -0,0 +1,9 @@
+/** Companion exports for analyzer classification member-pattern tests. */
+declare const analyzerClassificationMemberPatterns: {
+    hasAssertion: (statement: import("estree").Statement) => boolean;
+    hasCapturableActResult: (statement: import("estree").Statement) => boolean;
+    isMeaningfulActStatement: (statement: import("estree").Statement) => boolean;
+    isSetupLikeStatement: (statement: import("estree").Statement) => boolean;
+};
+export { analyzerClassificationMemberPatterns };
+//# sourceMappingURL=analyzer.classification.member-patterns.d.ts.map

package/dist/domain/testing/aaa/analyzer.classification.member-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.classification.member-patterns.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.classification.member-patterns.ts"],"names":[],"mappings":"AAOA,0EAA0E;AAC1E,QAAA,MAAM,oCAAoC;;;;;CAKzC,CAAC;AAEF,OAAO,EAAE,oCAAoC,EAAE,CAAC"}

package/dist/domain/testing/aaa/analyzer.classification.member-patterns.js

@@ -0,0 +1,10 @@
+import { hasAssertion, hasCapturableActResult, isMeaningfulActStatement, isSetupLikeStatement, } from "./analyzer.js";
+/** Companion exports for analyzer classification member-pattern tests. */
+const analyzerClassificationMemberPatterns = {
+    hasAssertion,
+    hasCapturableActResult,
+    isMeaningfulActStatement,
+    isSetupLikeStatement,
+};
+export { analyzerClassificationMemberPatterns };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5hbHl6ZXIuY2xhc3NpZmljYXRpb24ubWVtYmVyLXBhdHRlcm5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RvbWFpbi90ZXN0aW5nL2FhYS9hbmFseXplci5jbGFzc2lmaWNhdGlvbi5tZW1iZXItcGF0dGVybnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLFlBQVksRUFDWixzQkFBc0IsRUFDdEIsd0JBQXdCLEVBQ3hCLG9CQUFvQixHQUNyQixNQUFNLFlBQVksQ0FBQztBQUVwQiwwRUFBMEU7QUFDMUUsTUFBTSxvQ0FBb0MsR0FBRztJQUMzQyxZQUFZO0lBQ1osc0JBQXNCO0lBQ3RCLHdCQUF3QjtJQUN4QixvQkFBb0I7Q0FDckIsQ0FBQztBQUVGLE9BQU8sRUFBRSxvQ0FBb0MsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcclxuICBoYXNBc3NlcnRpb24sXHJcbiAgaGFzQ2FwdHVyYWJsZUFjdFJlc3VsdCxcclxuICBpc01lYW5pbmdmdWxBY3RTdGF0ZW1lbnQsXHJcbiAgaXNTZXR1cExpa2VTdGF0ZW1lbnQsXHJcbn0gZnJvbSBcIi4vYW5hbHl6ZXJcIjtcclxuXHJcbi8qKiBDb21wYW5pb24gZXhwb3J0cyBmb3IgYW5hbHl6ZXIgY2xhc3NpZmljYXRpb24gbWVtYmVyLXBhdHRlcm4gdGVzdHMuICovXHJcbmNvbnN0IGFuYWx5emVyQ2xhc3NpZmljYXRpb25NZW1iZXJQYXR0ZXJucyA9IHtcclxuICBoYXNBc3NlcnRpb24sXHJcbiAgaGFzQ2FwdHVyYWJsZUFjdFJlc3VsdCxcclxuICBpc01lYW5pbmdmdWxBY3RTdGF0ZW1lbnQsXHJcbiAgaXNTZXR1cExpa2VTdGF0ZW1lbnQsXHJcbn07XHJcblxyXG5leHBvcnQgeyBhbmFseXplckNsYXNzaWZpY2F0aW9uTWVtYmVyUGF0dGVybnMgfTtcclxuIl19

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

@@ -0,0 +1,4 @@
+/** Companion module for classification mutation spec coverage. */
+declare const analyzerClassificationMutationsCompanion: true;
+export { analyzerClassificationMutationsCompanion };
+//# sourceMappingURL=analyzer.classification.mutations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.classification.mutations.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.classification.mutations.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,QAAA,MAAM,wCAAwC,EAAG,IAAa,CAAC;AAE/D,OAAO,EAAE,wCAAwC,EAAE,CAAC"}

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

@@ -0,0 +1,4 @@
+/** Companion module for classification mutation spec coverage. */
+const analyzerClassificationMutationsCompanion = true;
+export { analyzerClassificationMutationsCompanion };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5hbHl6ZXIuY2xhc3NpZmljYXRpb24ubXV0YXRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RvbWFpbi90ZXN0aW5nL2FhYS9hbmFseXplci5jbGFzc2lmaWNhdGlvbi5tdXRhdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsa0VBQWtFO0FBQ2xFLE1BQU0sd0NBQXdDLEdBQUcsSUFBYSxDQUFDO0FBRS9ELE9BQU8sRUFBRSx3Q0FBd0MsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqIENvbXBhbmlvbiBtb2R1bGUgZm9yIGNsYXNzaWZpY2F0aW9uIG11dGF0aW9uIHNwZWMgY292ZXJhZ2UuICovXHJcbmNvbnN0IGFuYWx5emVyQ2xhc3NpZmljYXRpb25NdXRhdGlvbnNDb21wYW5pb24gPSB0cnVlIGFzIGNvbnN0O1xyXG5cclxuZXhwb3J0IHsgYW5hbHl6ZXJDbGFzc2lmaWNhdGlvbk11dGF0aW9uc0NvbXBhbmlvbiB9O1xyXG4iXX0=

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

@@ -0,0 +1,15 @@
+import type * as ESTree from "estree";
+/**
+ * Visits a statement while skipping nested function bodies that execute later.
+ * @param statement Input statement value.
+ * @param callback Input callback value.
+ * @example
+ * ```typescript
+ * visitStatementWithoutDeferredBodies(statement, () => {});
+ * ```
+ */
+declare function visitStatementWithoutDeferredBodies(statement: ESTree.Statement, callback: (node: ESTree.Node) => void): void;
+/** Companion marker for test isolation. */
+declare const analyzerClassificationTraversalCompanion: true;
+export { analyzerClassificationTraversalCompanion, visitStatementWithoutDeferredBodies, };
+//# sourceMappingURL=analyzer.classification.traversal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.classification.traversal.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.classification.traversal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAqBtC;;;;;;;;GAQG;AACH,iBAAS,mCAAmC,CAC1C,SAAS,EAAE,MAAM,CAAC,SAAS,EAC3B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,KAAK,IAAI,GACpC,IAAI,CAKN;AAED,2CAA2C;AAC3C,QAAA,MAAM,wCAAwC,EAAG,IAAa,CAAC;AAE/D,OAAO,EACL,wCAAwC,EACxC,mCAAmC,GACpC,CAAC"}

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

@@ -0,0 +1,34 @@
+import { visitNode } from "./analyzer.super.js";
+/**
+ * Checks whether a node introduces deferred execution.
+ * @param node Input node value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isDeferredFunctionNode({ type: "ArrowFunctionExpression" } as ESTree.Node);
+ * ```
+ */
+function isDeferredFunctionNode(node) {
+    return (node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionDeclaration" ||
+        node.type === "FunctionExpression");
+}
+/**
+ * Visits a statement while skipping nested function bodies that execute later.
+ * @param statement Input statement value.
+ * @param callback Input callback value.
+ * @example
+ * ```typescript
+ * visitStatementWithoutDeferredBodies(statement, () => {});
+ * ```
+ */
+function visitStatementWithoutDeferredBodies(statement, callback) {
+    visitNode(statement, (node) => {
+        callback(node);
+        return node === statement || !isDeferredFunctionNode(node);
+    });
+}
+/** Companion marker for test isolation. */
+const analyzerClassificationTraversalCompanion = true;
+export { analyzerClassificationTraversalCompanion, visitStatementWithoutDeferredBodies, };
+//# sourceMappingURL=data:application/json;base64,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

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.helpers.js").AssertionIdentifiers;
+/** Flattens section comments into one entry per resolved phase. */
+declare const getFlattenedSections: (analysis: Pick<import("./types.js").TestBlockAnalysis, "sectionComments">) => import("./analyzer.analysis.helpers.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,yGAAiD,CAAC;AAE/E,mEAAmE;AACnE,QAAA,MAAM,oBAAoB,sIAA8C,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,106 @@
+import type * as ESTree from "estree";
+import type { LocatedComment, SourceComment } from "./types.js";
+/** Visits an ESTree node graph while ignoring cycles. */
+declare const visitNode: (node: ESTree.Node, callback: (node: ESTree.Node) => boolean | undefined, seenNodes?: WeakSet<object> | undefined) => void;
+/** 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>;
+/**
+ * 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;
+/**
+ * Checks whether a call name is built from void-like verb tokens.
+ * @param calleeName Input calleeName value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isVoidLikeMethodName("scheduleAndFlush");
+ * ```
+ */
+declare function isVoidLikeMethodName(calleeName: string): boolean;
+export { arrayMutationMethods, getExpressionName, getInvokedName, isCallableExpression, isLocatedComment, isRangeWithin, isUtilityConstructor, isUtilityNamedCall, isUtilityNamespaceCall, isVoidLikeMethodName, setupLikeNames, utilityMethodNames, visitNode, voidLikeMethodNames, };
+//# 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":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAqB7D,yDAAyD;AACzD,QAAA,MAAM,SAAS,4HAAmC,CAAC;AAEnD,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,aAcvB,CAAC;AAEH;;;;;;;;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;AAkBD;;;;;;;;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;AAED;;;;;;;;;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,CAST;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;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,aAAa,EACb,oBAAoB,EACpB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,SAAS,EACT,mBAAmB,GACpB,CAAC"}