@codeperfect/eslint-plugin 1.0.0 → 2.1.0

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

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

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

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

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

@@ -0,0 +1,185 @@
+import { getAssertOperands, getExpectOperands, getIdentifierName, hasEvaluatedAssertionActual, isAssertionCall, } from "./analyzer.assertions.operands.js";
+import { visitNode } from "./analyzer.super.js";
+/**
+ * Collects Assert declarations.
+ * @param analysis Input analysis value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getAssertDeclaredIdentifiers(analysis);
+ * ```
+ */
+function getAssertDeclaredIdentifiers(analysis) {
+    const declaredIdentifiers = new Map();
+    for (const statement of analysis.statements) {
+        if (statement.phases.includes("Assert") &&
+            statement.node.type === "VariableDeclaration") {
+            for (const declaration of statement.node.declarations) {
+                if (declaration.id.type === "Identifier") {
+                    declaredIdentifiers.set(declaration.id.name, declaration.id);
+                }
+            }
+        }
+    }
+    return declaredIdentifiers;
+}
+/**
+ * Gets the outer assertion call expression for one statement when present.
+ * @param statement Statement to inspect.
+ * @returns Assertion call expression when the statement is expression-based.
+ * @example
+ * ```typescript
+ * const expression = getAssertionExpression(statement);
+ * void expression;
+ * ```
+ */
+function getAssertionExpression(statement) {
+    if (statement.type !== "ExpressionStatement") {
+        return void 0;
+    }
+    const expression = unwrapExpression(statement.expression);
+    return expression?.type === "CallExpression" ? expression : void 0;
+}
+/**
+ * Extracts assertion identifiers.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getAssertionIdentifiers(statement);
+ * ```
+ */
+function getAssertionIdentifiers(statement) {
+    if (statement.type !== "ExpressionStatement") {
+        return { actual: void 0, expected: void 0 };
+    }
+    const expression = unwrapExpression(statement.expression);
+    if (expression?.type !== "CallExpression") {
+        return { actual: void 0, expected: void 0 };
+    }
+    const expectOperands = getExpectOperands(expression);
+    if (expectOperands !== void 0) {
+        return {
+            actual: getIdentifierName(expectOperands.actual),
+            expected: getIdentifierName(expectOperands.expected),
+        };
+    }
+    const assertOperands = getAssertOperands(expression);
+    return {
+        actual: getIdentifierName(assertOperands?.actual),
+        expected: getIdentifierName(assertOperands?.expected),
+    };
+}
+/**
+ * Gets a statement expression.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getStatementExpression(statement);
+ * ```
+ */
+function getStatementExpression(statement) {
+    if (statement.type === "ExpressionStatement") {
+        return statement.expression;
+    }
+    if (statement.type === "VariableDeclaration" &&
+        statement.declarations.length === 1) {
+        const [declaration] = statement.declarations;
+        return declaration?.init;
+    }
+    return void 0;
+}
+/**
+ * Checks for assertions.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasAssertion(statement);
+ * ```
+ */
+function hasAssertion(statement) {
+    let foundAssertion = false;
+    visitNode(statement, (node) => {
+        if (node.type === "CallExpression" && isAssertionCall(node)) {
+            foundAssertion = true;
+        }
+    });
+    return foundAssertion;
+}
+/**
+ * Checks for action expressions.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isActionExpression(expression);
+ * ```
+ */
+function isActionExpression(expression) {
+    const unwrappedExpression = unwrapExpression(expression);
+    return (unwrappedExpression?.type === "AwaitExpression" ||
+        unwrappedExpression?.type === "CallExpression" ||
+        unwrappedExpression?.type === "NewExpression");
+}
+/**
+ * Checks Assert statement validity.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isValidAssertStatement(statement);
+ * ```
+ */
+function isValidAssertStatement(statement) {
+    if (hasAssertion(statement)) {
+        const assertionExpression = getAssertionExpression(statement);
+        return (assertionExpression === void 0 ||
+            !hasEvaluatedAssertionActual(assertionExpression, isActionExpression));
+    }
+    if (statement.type !== "VariableDeclaration") {
+        return false;
+    }
+    return statement.declarations.every((declaration) => {
+        if (declaration.init === null) {
+            return true;
+        }
+        return !isActionExpression(unwrapExpression(declaration.init));
+    });
+}
+/**
+ * Unwraps nested expressions.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * unwrapExpression(expression);
+ * ```
+ */
+function unwrapExpression(expression) {
+    if (expression?.type === "ChainExpression") {
+        return unwrapExpression(expression.expression);
+    }
+    if (expression?.type === "AwaitExpression") {
+        return expression.argument;
+    }
+    return expression;
+}
+/**
+ * Checks AAA naming prefixes.
+ * @param name Input name value.
+ * @param prefix Input prefix value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * usesPrefix("actualResult", "actual");
+ * ```
+ */
+function usesPrefix(name, prefix) {
+    return name === prefix || name.startsWith(prefix);
+}
+/** Companion marker for test isolation. */
+const analyzerAssertionsHelpersCompanion = true;
+export { analyzerAssertionsHelpersCompanion, getAssertDeclaredIdentifiers, getAssertionIdentifiers, getStatementExpression, hasAssertion, isActionExpression, isValidAssertStatement, unwrapExpression, usesPrefix, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyzer.assertions.helpers.js","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.assertions.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as ESTree from \"estree\";\r\n\r\nimport type { LocatedNode, TestBlockAnalysis } from \"./types\";\r\n\r\nimport {\r\n  getAssertOperands,\r\n  getExpectOperands,\r\n  getIdentifierName,\r\n  hasEvaluatedAssertionActual,\r\n  isAssertionCall,\r\n} from \"./analyzer.assertions.operands\";\r\nimport { visitNode } from \"./analyzer.super\";\r\n\r\n/** Identifier names extracted from an assertion statement. */\r\ninterface AssertionIdentifiers {\r\n  /** Identifier used as the actual value. */\r\n  actual: string | undefined;\r\n  /** Identifier used as the expected value. */\r\n  expected: string | undefined;\r\n}\r\n\r\n/**\r\n * Collects Assert declarations.\r\n * @param analysis Input analysis value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getAssertDeclaredIdentifiers(analysis);\r\n * ```\r\n */\r\nfunction getAssertDeclaredIdentifiers(\r\n  analysis: TestBlockAnalysis,\r\n): Map<string, LocatedNode<ESTree.Identifier>> {\r\n  const declaredIdentifiers = new Map<string, LocatedNode<ESTree.Identifier>>();\r\n  for (const statement of analysis.statements) {\r\n    if (\r\n      statement.phases.includes(\"Assert\") &&\r\n      statement.node.type === \"VariableDeclaration\"\r\n    ) {\r\n      for (const declaration of statement.node.declarations) {\r\n        if (declaration.id.type === \"Identifier\") {\r\n          declaredIdentifiers.set(\r\n            declaration.id.name,\r\n            declaration.id as LocatedNode<ESTree.Identifier>,\r\n          );\r\n        }\r\n      }\r\n    }\r\n  }\r\n  return declaredIdentifiers;\r\n}\r\n\r\n/**\r\n * Gets the outer assertion call expression for one statement when present.\r\n * @param statement Statement to inspect.\r\n * @returns Assertion call expression when the statement is expression-based.\r\n * @example\r\n * ```typescript\r\n * const expression = getAssertionExpression(statement);\r\n * void expression;\r\n * ```\r\n */\r\nfunction getAssertionExpression(\r\n  statement: ESTree.Statement,\r\n): ESTree.CallExpression | undefined {\r\n  if (statement.type !== \"ExpressionStatement\") {\r\n    return void 0;\r\n  }\r\n\r\n  const expression = unwrapExpression(statement.expression);\r\n\r\n  return expression?.type === \"CallExpression\" ? expression : void 0;\r\n}\r\n\r\n/**\r\n * Extracts assertion identifiers.\r\n * @param statement Input statement value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getAssertionIdentifiers(statement);\r\n * ```\r\n */\r\nfunction getAssertionIdentifiers(\r\n  statement: ESTree.Statement,\r\n): AssertionIdentifiers {\r\n  if (statement.type !== \"ExpressionStatement\") {\r\n    return { actual: void 0, expected: void 0 };\r\n  }\r\n  const expression = unwrapExpression(statement.expression);\r\n  if (expression?.type !== \"CallExpression\") {\r\n    return { actual: void 0, expected: void 0 };\r\n  }\r\n\r\n  const expectOperands = getExpectOperands(expression);\r\n  if (expectOperands !== void 0) {\r\n    return {\r\n      actual: getIdentifierName(expectOperands.actual),\r\n      expected: getIdentifierName(expectOperands.expected),\r\n    };\r\n  }\r\n  const assertOperands = getAssertOperands(expression);\r\n  return {\r\n    actual: getIdentifierName(assertOperands?.actual),\r\n    expected: getIdentifierName(assertOperands?.expected),\r\n  };\r\n}\r\n\r\n/**\r\n * Gets a statement expression.\r\n * @param statement Input statement value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getStatementExpression(statement);\r\n * ```\r\n */\r\nfunction getStatementExpression(\r\n  statement: ESTree.Statement,\r\n): ESTree.Expression | undefined {\r\n  if (statement.type === \"ExpressionStatement\") {\r\n    return statement.expression;\r\n  }\r\n  if (\r\n    statement.type === \"VariableDeclaration\" &&\r\n    statement.declarations.length === 1\r\n  ) {\r\n    const [declaration] = statement.declarations;\r\n    return declaration?.init as ESTree.Expression | undefined;\r\n  }\r\n  return void 0;\r\n}\r\n\r\n/**\r\n * Checks for assertions.\r\n * @param statement Input statement value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * hasAssertion(statement);\r\n * ```\r\n */\r\nfunction hasAssertion(statement: ESTree.Statement): boolean {\r\n  let foundAssertion = false;\r\n  visitNode(statement, (node) => {\r\n    if (node.type === \"CallExpression\" && isAssertionCall(node)) {\r\n      foundAssertion = true;\r\n    }\r\n  });\r\n  return foundAssertion;\r\n}\r\n\r\n/**\r\n * Checks for action expressions.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isActionExpression(expression);\r\n * ```\r\n */\r\nfunction isActionExpression(\r\n  expression: ESTree.Expression | undefined,\r\n): boolean {\r\n  const unwrappedExpression = unwrapExpression(expression);\r\n  return (\r\n    unwrappedExpression?.type === \"AwaitExpression\" ||\r\n    unwrappedExpression?.type === \"CallExpression\" ||\r\n    unwrappedExpression?.type === \"NewExpression\"\r\n  );\r\n}\r\n\r\n/**\r\n * Checks Assert statement validity.\r\n * @param statement Input statement value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isValidAssertStatement(statement);\r\n * ```\r\n */\r\nfunction isValidAssertStatement(statement: ESTree.Statement): boolean {\r\n  if (hasAssertion(statement)) {\r\n    const assertionExpression = getAssertionExpression(statement);\r\n\r\n    return (\r\n      assertionExpression === void 0 ||\r\n      !hasEvaluatedAssertionActual(assertionExpression, isActionExpression)\r\n    );\r\n  }\r\n  if (statement.type !== \"VariableDeclaration\") {\r\n    return false;\r\n  }\r\n\r\n  return statement.declarations.every((declaration) => {\r\n    if (declaration.init === null) {\r\n      return true;\r\n    }\r\n    return !isActionExpression(unwrapExpression(declaration.init));\r\n  });\r\n}\r\n\r\n/**\r\n * Unwraps nested expressions.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * unwrapExpression(expression);\r\n * ```\r\n */\r\nfunction unwrapExpression(\r\n  expression: ESTree.Expression | undefined,\r\n): ESTree.Expression | undefined {\r\n  if (expression?.type === \"ChainExpression\") {\r\n    return unwrapExpression(expression.expression);\r\n  }\r\n  if (expression?.type === \"AwaitExpression\") {\r\n    return expression.argument;\r\n  }\r\n  return expression;\r\n}\r\n\r\n/**\r\n * Checks AAA naming prefixes.\r\n * @param name Input name value.\r\n * @param prefix Input prefix value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * usesPrefix(\"actualResult\", \"actual\");\r\n * ```\r\n */\r\nfunction usesPrefix(name: string, prefix: \"actual\" | \"expected\"): boolean {\r\n  return name === prefix || name.startsWith(prefix);\r\n}\r\n\r\n/** Companion marker for test isolation. */\r\nconst analyzerAssertionsHelpersCompanion = true as const;\r\n\r\nexport {\r\n  analyzerAssertionsHelpersCompanion,\r\n  getAssertDeclaredIdentifiers,\r\n  getAssertionIdentifiers,\r\n  getStatementExpression,\r\n  hasAssertion,\r\n  isActionExpression,\r\n  isValidAssertStatement,\r\n  unwrapExpression,\r\n  usesPrefix,\r\n};\r\nexport type { AssertionIdentifiers };\r\n"]}

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

@@ -0,0 +1,33 @@
+import { getAssertDeclaredIdentifiers as getAssertDeclaredIdentifiersImplementation, getAssertionIdentifiers as getAssertionIdentifiersImplementation, getStatementExpression as getStatementExpressionImplementation, hasAssertion as hasAssertionImplementation, isActionExpression as isActionExpressionImplementation, isValidAssertStatement as isValidAssertStatementImplementation, unwrapExpression as unwrapExpressionImplementation, usesPrefix as usesPrefixImplementation, } from "./analyzer.assertions.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);
+}
+/** Collects all declared identifiers from an assert statement. */
+const getAssertDeclaredIdentifiers = forward(getAssertDeclaredIdentifiersImplementation);
+/** Resolves the identifier names used in an assertion call. */
+const getAssertionIdentifiers = forward(getAssertionIdentifiersImplementation);
+/** Extracts the expression from an expression statement node. */
+const getStatementExpression = forward(getStatementExpressionImplementation);
+/** Checks whether a statement contains an assertion call. */
+const hasAssertion = forward(hasAssertionImplementation);
+/** Checks whether an expression is an Act-phase action expression. */
+const isActionExpression = forward(isActionExpressionImplementation);
+/** Checks whether a statement is a valid Assert-phase assertion. */
+const isValidAssertStatement = forward(isValidAssertStatementImplementation);
+/** Unwraps a nested or chained expression to its root call. */
+const unwrapExpression = forward(unwrapExpressionImplementation);
+/** Checks whether an assertion call uses a known assertion prefix. */
+const usesPrefix = forward(usesPrefixImplementation);
+export { getAssertDeclaredIdentifiers, getAssertionIdentifiers, getStatementExpression, hasAssertion, isActionExpression, isValidAssertStatement, unwrapExpression, usesPrefix, };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,64 @@
+import type * as ESTree from "estree";
+/** Raw assertion operands extracted from a call expression. */
+interface AssertionOperands {
+    /** Expression used as the actual operand. */
+    actual: ESTree.Expression | undefined;
+    /** Expression used as the expected operand. */
+    expected: ESTree.Expression | undefined;
+}
+/**
+ * Gets assert operands.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getAssertOperands(expression);
+ * ```
+ */
+declare function getAssertOperands(expression: ESTree.CallExpression): AssertionOperands | undefined;
+/**
+ * Gets expect operands.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getExpectOperands(expression);
+ * ```
+ */
+declare function getExpectOperands(expression: ESTree.CallExpression): AssertionOperands | undefined;
+/**
+ * Gets an identifier name.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getIdentifierName(expression);
+ * ```
+ */
+declare function getIdentifierName(expression: ESTree.Expression | undefined): string | undefined;
+/**
+ * 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;
+ * ```
+ */
+declare function hasEvaluatedAssertionActual(expression: ESTree.CallExpression, isActionExpression: (expression: ESTree.Expression | undefined) => boolean): boolean;
+/**
+ * Checks for assertion calls.
+ * @param node Input node value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isAssertionCall(node);
+ * ```
+ */
+declare function isAssertionCall(node: ESTree.CallExpression): boolean;
+/** Companion marker for test isolation. */
+declare const analyzerAssertionsOperandsCompanion: true;
+export { analyzerAssertionsOperandsCompanion, getAssertOperands, getExpectOperands, getIdentifierName, hasEvaluatedAssertionActual, isAssertionCall, };
+//# sourceMappingURL=analyzer.assertions.operands.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.assertions.operands.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.assertions.operands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,+DAA+D;AAC/D,UAAU,iBAAiB;IACzB,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;IACtC,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;CACzC;AAED;;;;;;;;GAQG;AACH,iBAAS,iBAAiB,CACxB,UAAU,EAAE,MAAM,CAAC,cAAc,GAChC,iBAAiB,GAAG,SAAS,CAe/B;AAED;;;;;;;;GAQG;AACH,iBAAS,iBAAiB,CACxB,UAAU,EAAE,MAAM,CAAC,cAAc,GAChC,iBAAiB,GAAG,SAAS,CA4B/B;AAED;;;;;;;;GAQG;AACH,iBAAS,iBAAiB,CACxB,UAAU,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,GACxC,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;;;;;;GAUG;AACH,iBAAS,2BAA2B,CAClC,UAAU,EAAE,MAAM,CAAC,cAAc,EACjC,kBAAkB,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,KAAK,OAAO,GACzE,OAAO,CAKT;AAED;;;;;;;;GAQG;AACH,iBAAS,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,cAAc,GAAG,OAAO,CAoB7D;AAED,2CAA2C;AAC3C,QAAA,MAAM,mCAAmC,EAAG,IAAa,CAAC;AAE1D,OAAO,EACL,mCAAmC,EACnC,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,2BAA2B,EAC3B,eAAe,GAChB,CAAC"}

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

@@ -0,0 +1,16 @@
+/** 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

@@ -0,0 +1 @@
+{"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"}