@codeperfect/eslint-plugin 2.0.0 → 2.1.0

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

@@ -0,0 +1,105 @@
+/**
+ * Gets assert operands.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getAssertOperands(expression);
+ * ```
+ */
+function getAssertOperands(expression) {
+    if (expression.callee.type === "MemberExpression" &&
+        expression.callee.object.type === "Identifier" &&
+        expression.callee.object.name === "assert") {
+        const [actual, expected] = expression.arguments;
+        if (actual?.type !== "SpreadElement" &&
+            expected?.type !== "SpreadElement") {
+            return { actual, expected };
+        }
+    }
+    return void 0;
+}
+/**
+ * Gets expect operands.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getExpectOperands(expression);
+ * ```
+ */
+function getExpectOperands(expression) {
+    if (expression.callee.type === "Identifier" &&
+        expression.callee.name === "expect") {
+        const [actual] = expression.arguments;
+        return actual?.type === "SpreadElement"
+            ? { actual: void 0, expected: void 0 }
+            : { actual, expected: void 0 };
+    }
+    if (expression.callee.type === "MemberExpression" &&
+        expression.callee.object.type === "CallExpression") {
+        const nestedOperands = getExpectOperands(expression.callee.object);
+        if (nestedOperands === void 0) {
+            return void 0;
+        }
+        const [expected] = expression.arguments;
+        return expected?.type === "SpreadElement"
+            ? nestedOperands
+            : { actual: nestedOperands.actual, expected };
+    }
+    return void 0;
+}
+/**
+ * Gets an identifier name.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getIdentifierName(expression);
+ * ```
+ */
+function getIdentifierName(expression) {
+    return expression?.type === "Identifier" ? expression.name : void 0;
+}
+/**
+ * Checks whether an assertion evaluates the actual operand inline.
+ * @param expression Assertion call expression to inspect.
+ * @param isActionExpression Predicate that identifies action-like expressions.
+ * @returns True when the assertion actual operand performs action-like work.
+ * @example
+ * ```typescript
+ * const actual = hasEvaluatedAssertionActual(expression, () => true);
+ * void actual;
+ * ```
+ */
+function hasEvaluatedAssertionActual(expression, isActionExpression) {
+    const operands = getExpectOperands(expression) ?? getAssertOperands(expression);
+    return operands !== void 0 && isActionExpression(operands.actual);
+}
+/**
+ * Checks for assertion calls.
+ * @param node Input node value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isAssertionCall(node);
+ * ```
+ */
+function isAssertionCall(node) {
+    if (node.callee.type === "Identifier") {
+        return node.callee.name === "expect" || node.callee.name === "assert";
+    }
+    if (node.callee.type !== "MemberExpression") {
+        return false;
+    }
+    if (node.callee.object.type === "Identifier" &&
+        node.callee.object.name === "assert") {
+        return true;
+    }
+    return (node.callee.object.type === "CallExpression" &&
+        isAssertionCall(node.callee.object));
+}
+/** Companion marker for test isolation. */
+const analyzerAssertionsOperandsCompanion = true;
+export { analyzerAssertionsOperandsCompanion, getAssertOperands, getExpectOperands, getIdentifierName, hasEvaluatedAssertionActual, isAssertionCall, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyzer.assertions.operands.js","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.assertions.operands.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as ESTree from \"estree\";\r\n\r\n/** Raw assertion operands extracted from a call expression. */\r\ninterface AssertionOperands {\r\n  /** Expression used as the actual operand. */\r\n  actual: ESTree.Expression | undefined;\r\n  /** Expression used as the expected operand. */\r\n  expected: ESTree.Expression | undefined;\r\n}\r\n\r\n/**\r\n * Gets assert operands.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getAssertOperands(expression);\r\n * ```\r\n */\r\nfunction getAssertOperands(\r\n  expression: ESTree.CallExpression,\r\n): AssertionOperands | undefined {\r\n  if (\r\n    expression.callee.type === \"MemberExpression\" &&\r\n    expression.callee.object.type === \"Identifier\" &&\r\n    expression.callee.object.name === \"assert\"\r\n  ) {\r\n    const [actual, expected] = expression.arguments;\r\n    if (\r\n      actual?.type !== \"SpreadElement\" &&\r\n      expected?.type !== \"SpreadElement\"\r\n    ) {\r\n      return { actual, expected };\r\n    }\r\n  }\r\n  return void 0;\r\n}\r\n\r\n/**\r\n * Gets expect operands.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getExpectOperands(expression);\r\n * ```\r\n */\r\nfunction getExpectOperands(\r\n  expression: ESTree.CallExpression,\r\n): AssertionOperands | undefined {\r\n  if (\r\n    expression.callee.type === \"Identifier\" &&\r\n    expression.callee.name === \"expect\"\r\n  ) {\r\n    const [actual] = expression.arguments;\r\n    return actual?.type === \"SpreadElement\"\r\n      ? { actual: void 0, expected: void 0 }\r\n      : { actual, expected: void 0 };\r\n  }\r\n\r\n  if (\r\n    expression.callee.type === \"MemberExpression\" &&\r\n    expression.callee.object.type === \"CallExpression\"\r\n  ) {\r\n    const nestedOperands = getExpectOperands(expression.callee.object);\r\n    if (nestedOperands === void 0) {\r\n      return void 0;\r\n    }\r\n\r\n    const [expected] = expression.arguments;\r\n\r\n    return expected?.type === \"SpreadElement\"\r\n      ? nestedOperands\r\n      : { actual: nestedOperands.actual, expected };\r\n  }\r\n\r\n  return void 0;\r\n}\r\n\r\n/**\r\n * Gets an identifier name.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getIdentifierName(expression);\r\n * ```\r\n */\r\nfunction getIdentifierName(\r\n  expression: ESTree.Expression | undefined,\r\n): string | undefined {\r\n  return expression?.type === \"Identifier\" ? expression.name : void 0;\r\n}\r\n\r\n/**\r\n * Checks whether an assertion evaluates the actual operand inline.\r\n * @param expression Assertion call expression to inspect.\r\n * @param isActionExpression Predicate that identifies action-like expressions.\r\n * @returns True when the assertion actual operand performs action-like work.\r\n * @example\r\n * ```typescript\r\n * const actual = hasEvaluatedAssertionActual(expression, () => true);\r\n * void actual;\r\n * ```\r\n */\r\nfunction hasEvaluatedAssertionActual(\r\n  expression: ESTree.CallExpression,\r\n  isActionExpression: (expression: ESTree.Expression | undefined) => boolean,\r\n): boolean {\r\n  const operands =\r\n    getExpectOperands(expression) ?? getAssertOperands(expression);\r\n\r\n  return operands !== void 0 && isActionExpression(operands.actual);\r\n}\r\n\r\n/**\r\n * Checks for assertion calls.\r\n * @param node Input node value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isAssertionCall(node);\r\n * ```\r\n */\r\nfunction isAssertionCall(node: ESTree.CallExpression): boolean {\r\n  if (node.callee.type === \"Identifier\") {\r\n    return node.callee.name === \"expect\" || node.callee.name === \"assert\";\r\n  }\r\n\r\n  if (node.callee.type !== \"MemberExpression\") {\r\n    return false;\r\n  }\r\n\r\n  if (\r\n    node.callee.object.type === \"Identifier\" &&\r\n    node.callee.object.name === \"assert\"\r\n  ) {\r\n    return true;\r\n  }\r\n\r\n  return (\r\n    node.callee.object.type === \"CallExpression\" &&\r\n    isAssertionCall(node.callee.object)\r\n  );\r\n}\r\n\r\n/** Companion marker for test isolation. */\r\nconst analyzerAssertionsOperandsCompanion = true as const;\r\n\r\nexport {\r\n  analyzerAssertionsOperandsCompanion,\r\n  getAssertOperands,\r\n  getExpectOperands,\r\n  getIdentifierName,\r\n  hasEvaluatedAssertionActual,\r\n  isAssertionCall,\r\n};\r\n"]}

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

@@ -1,75 +1,16 @@
-import type * as ESTree from "estree";
-import type { SourceComment } from "./types.js";
-/**
- * Checks for async logic.
- * @param statement Input statement value.
- * @returns Return value output.
- * @example
- * ```typescript
- * hasAsyncLogic(statement);
- * ```
- */
-declare function hasAsyncLogic(statement: ESTree.Statement): boolean;
-/**
- * Checks for await usage.
- * @param statement Input statement value.
- * @returns Return value output.
- * @example
- * ```typescript
- * hasAwait(statement);
- * ```
- */
-declare function hasAwait(statement: ESTree.Statement): boolean;
-/**
- * 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);
- * ```
- */
-declare function hasBlankLineBeforeComment(sourceText: string, comment: SourceComment): boolean;
-/**
- * Checks for capturable Act results.
- * @param statement Input statement value.
- * @returns Return value output.
- * @example
- * ```typescript
- * hasCapturableActResult(statement);
- * ```
- */
-declare function hasCapturableActResult(statement: ESTree.Statement): boolean;
-/**
- * Checks for mutation.
- * @param statement Input statement value.
- * @returns Return value output.
- * @example
- * ```typescript
- * hasMutation(statement);
- * ```
- */
-declare function hasMutation(statement: ESTree.Statement): boolean;
-/**
- * Checks for meaningful Act statements.
- * @param statement Input statement value.
- * @returns Return value output.
- * @example
- * ```typescript
- * isMeaningfulActStatement(statement);
- * ```
- */
-declare function isMeaningfulActStatement(statement: ESTree.Statement): boolean;
-/**
- * Checks for setup-like statements.
- * @param statement Input statement value.
- * @returns Return value output.
- * @example
- * ```typescript
- * isSetupLikeStatement(statement);
- * ```
- */
-declare function isSetupLikeStatement(statement: ESTree.Statement): boolean;
+/** Checks whether a statement contains any async or await logic. */
+declare const hasAsyncLogic: (statement: import("estree").Statement) => boolean;
+/** Checks whether a node contains an `await` expression. */
+declare const hasAwait: (statement: import("estree").Statement) => boolean;
+/** Checks whether there is a blank line immediately before a comment node. */
+declare const hasBlankLineBeforeComment: (sourceText: string, comment: import("estree").Comment) => boolean;
+/** Checks whether an Act statement produces a result worth capturing. */
+declare const hasCapturableActResult: (statement: import("estree").Statement) => boolean;
+/** Checks whether a statement performs an observable state mutation. */
+declare const hasMutation: (statement: import("estree").Statement) => boolean;
+/** Checks whether a statement is a meaningful Act step (not setup or assertion). */
+declare const isMeaningfulActStatement: (statement: import("estree").Statement) => boolean;
+/** Checks whether a statement looks like an Arrange-phase setup step. */
+declare const isSetupLikeStatement: (statement: import("estree").Statement) => boolean;
 export { hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, };
 //# sourceMappingURL=analyzer.classification.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"analyzer.classification.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.classification.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAsB7C;;;;;;;;GAQG;AACH,iBAAS,aAAa,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CA4B3D;AAED;;;;;;;;GAQG;AACH,iBAAS,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAUtD;AAED;;;;;;;;;GASG;AACH,iBAAS,yBAAyB,CAChC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,aAAa,GACrB,OAAO,CAST;AAED;;;;;;;;GAQG;AACH,iBAAS,sBAAsB,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAmBpE;AAED;;;;;;;;GAQG;AACH,iBAAS,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CA2BzD;AAED;;;;;;;;GAQG;AACH,iBAAS,wBAAwB,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAWtE;AAwBD;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAgBlE;AAgCD,OAAO,EACL,aAAa,EACb,QAAQ,EACR,yBAAyB,EACzB,sBAAsB,EACtB,WAAW,EACX,wBAAwB,EACxB,oBAAoB,GACrB,CAAC"}
+{"version":3,"file":"analyzer.classification.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.classification.ts"],"names":[],"mappings":"AA2BA,oEAAoE;AACpE,QAAA,MAAM,aAAa,oDAAuC,CAAC;AAE3D,4DAA4D;AAC5D,QAAA,MAAM,QAAQ,oDAAkC,CAAC;AAEjD,8EAA8E;AAC9E,QAAA,MAAM,yBAAyB,oEAE9B,CAAC;AAEF,yEAAyE;AACzE,QAAA,MAAM,sBAAsB,oDAAgD,CAAC;AAE7E,wEAAwE;AACxE,QAAA,MAAM,WAAW,oDAAqC,CAAC;AAEvD,oFAAoF;AACpF,QAAA,MAAM,wBAAwB,oDAE7B,CAAC;AAEF,yEAAyE;AACzE,QAAA,MAAM,oBAAoB,oDAA8C,CAAC;AAEzE,OAAO,EACL,aAAa,EACb,QAAQ,EACR,yBAAyB,EACzB,sBAAsB,EACtB,WAAW,EACX,wBAAwB,EACxB,oBAAoB,GACrB,CAAC"}

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

@@ -0,0 +1,77 @@
+import type * as ESTree from "estree";
+import type { SourceComment } from "./types.js";
+/**
+ * Checks for async logic.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasAsyncLogic(statement);
+ * ```
+ */
+declare function hasAsyncLogic(statement: ESTree.Statement): boolean;
+/**
+ * Checks for await usage.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasAwait(statement);
+ * ```
+ */
+declare function hasAwait(statement: ESTree.Statement): boolean;
+/**
+ * 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);
+ * ```
+ */
+declare function hasBlankLineBeforeComment(sourceText: string, comment: SourceComment): boolean;
+/**
+ * Checks for capturable Act results.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasCapturableActResult(statement);
+ * ```
+ */
+declare function hasCapturableActResult(statement: ESTree.Statement): boolean;
+/**
+ * Checks for mutation.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasMutation(statement);
+ * ```
+ */
+declare function hasMutation(statement: ESTree.Statement): boolean;
+/**
+ * Checks for meaningful Act statements.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isMeaningfulActStatement(statement);
+ * ```
+ */
+declare function isMeaningfulActStatement(statement: ESTree.Statement): boolean;
+/**
+ * Checks for setup-like statements.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isSetupLikeStatement(statement);
+ * ```
+ */
+declare function isSetupLikeStatement(statement: ESTree.Statement): boolean;
+/** Companion marker for test isolation. */
+declare const analyzerClassificationHelpersCompanion: true;
+export { analyzerClassificationHelpersCompanion, hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, };
+//# sourceMappingURL=analyzer.classification.helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.classification.helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.classification.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAuB7C;;;;;;;;GAQG;AACH,iBAAS,aAAa,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAwB3D;AAED;;;;;;;;GAQG;AACH,iBAAS,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAQtD;AAED;;;;;;;;;GASG;AACH,iBAAS,yBAAyB,CAChC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,aAAa,GACrB,OAAO,CAOT;AAED;;;;;;;;GAQG;AACH,iBAAS,sBAAsB,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAepE;AAED;;;;;;;;GAQG;AACH,iBAAS,WAAW,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAuBzD;AAED;;;;;;;;GAQG;AACH,iBAAS,wBAAwB,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAUtE;AAwBD;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS,GAAG,OAAO,CAYlE;AA8BD,2CAA2C;AAC3C,QAAA,MAAM,sCAAsC,EAAG,IAAa,CAAC;AAE7D,OAAO,EACL,sCAAsC,EACtC,aAAa,EACb,QAAQ,EACR,yBAAyB,EACzB,sBAAsB,EACtB,WAAW,EACX,wBAAwB,EACxB,oBAAoB,GACrB,CAAC"}

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":"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","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"]}