@codeperfect/eslint-plugin 2.0.0 → 2.2.0

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

@@ -0,0 +1,93 @@
+import type * as ESTree from "estree";
+import type { LocatedNode, TestBlockAnalysis } from "./types.js";
+/** Identifier names extracted from an assertion statement. */
+interface AssertionIdentifiers {
+    /** Identifier used as the actual value. */
+    actual: string | undefined;
+    /** Identifier used as the expected value. */
+    expected: string | undefined;
+}
+/**
+ * Collects Assert declarations.
+ * @param analysis Input analysis value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getAssertDeclaredIdentifiers(analysis);
+ * ```
+ */
+declare function getAssertDeclaredIdentifiers(analysis: TestBlockAnalysis): Map<string, LocatedNode<ESTree.Identifier>>;
+/**
+ * Extracts assertion identifiers.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getAssertionIdentifiers(statement);
+ * ```
+ */
+declare function getAssertionIdentifiers(statement: ESTree.Statement): AssertionIdentifiers;
+/**
+ * Gets a statement expression.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getStatementExpression(statement);
+ * ```
+ */
+declare function getStatementExpression(statement: ESTree.Statement): ESTree.Expression | undefined;
+/**
+ * Checks for assertions.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * hasAssertion(statement);
+ * ```
+ */
+declare function hasAssertion(statement: ESTree.Statement): boolean;
+/**
+ * Checks for action expressions.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isActionExpression(expression);
+ * ```
+ */
+declare function isActionExpression(expression: ESTree.Expression | undefined): boolean;
+/**
+ * Checks Assert statement validity.
+ * @param statement Input statement value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isValidAssertStatement(statement);
+ * ```
+ */
+declare function isValidAssertStatement(statement: ESTree.Statement): boolean;
+/**
+ * Unwraps nested expressions.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * unwrapExpression(expression);
+ * ```
+ */
+declare function unwrapExpression(expression: ESTree.Expression | undefined): ESTree.Expression | undefined;
+/**
+ * Checks AAA naming prefixes.
+ * @param name Input name value.
+ * @param prefix Input prefix value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * usesPrefix("actualResult", "actual");
+ * ```
+ */
+declare function usesPrefix(name: string, prefix: "actual" | "expected"): boolean;
+/** Companion marker for test isolation. */
+export { getAssertDeclaredIdentifiers, getAssertionIdentifiers, getStatementExpression, hasAssertion, isActionExpression, isValidAssertStatement, unwrapExpression, usesPrefix, };
+//# 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,OAAO,EACL,4BAA4B,EAC5B,uBAAuB,EACvB,sBAAsB,EACtB,YAAY,EACZ,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,UAAU,GACX,CAAC"}

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

@@ -0,0 +1,184 @@
+import { getAssertOperands, getExpectOperands, getIdentifierName, hasEvaluatedAssertionActual, isAssertionCall, } from "./analyzer.assertions.operands.js";
+import { visitNode } from "./analyzer.super.helpers.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. */
+export { 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.helpers\";\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\nexport {\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\n"]}

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

@@ -1,283 +1,5 @@
-/* eslint max-lines: ["error", 380] -- Mandatory multiline JSDoc for internal helpers pushes this split file over the default limit. */
-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 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;
-}
-/**
- * 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 whether an assertion evaluates the actual operand inline.
- * @param expression Assertion call expression to inspect.
- * @returns True when the assertion actual operand performs action-like work.
- * @example
- * ```typescript
- * const actual = hasEvaluatedAssertionActual(expression);
- * void actual;
- * ```
- */
-function hasEvaluatedAssertionActual(expression) {
-    const operands = getExpectOperands(expression) ?? getAssertOperands(expression);
-    return operands !== void 0 && isActionExpression(operands.actual);
-}
-/**
- * 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 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));
-}
-/**
- * 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));
-    }
-    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);
-}
-export { getAssertDeclaredIdentifiers, getAssertionIdentifiers, getStatementExpression, hasAssertion, isActionExpression, isValidAssertStatement, unwrapExpression, usesPrefix, };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyzer.assertions.js","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.assertions.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint max-lines: [\"error\", 380] -- Mandatory multiline JSDoc for internal helpers pushes this split file over the default limit. */\r\n\r\nimport type * as ESTree from \"estree\";\r\n\r\nimport type { LocatedNode, TestBlockAnalysis } from \"./types\";\r\n\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/** 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 * 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 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    const [expected] = expression.arguments;\r\n    return expected?.type === \"SpreadElement\"\r\n      ? nestedOperands\r\n      : { actual: nestedOperands.actual, expected };\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 * 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 whether an assertion evaluates the actual operand inline.\r\n * @param expression Assertion call expression to inspect.\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);\r\n * void actual;\r\n * ```\r\n */\r\nfunction hasEvaluatedAssertionActual(\r\n  expression: ESTree.CallExpression,\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 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 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  if (node.callee.type !== \"MemberExpression\") {\r\n    return false;\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  return (\r\n    node.callee.object.type === \"CallExpression\" &&\r\n    isAssertionCall(node.callee.object)\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)\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\nexport {\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"]}
+/** Companion module retained for companion-spec enforcement after wrapper export removal. */
+const analyzerAssertionsModuleCompanion = void 0;
+JSON.stringify(analyzerAssertionsModuleCompanion);
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5hbHl6ZXIuYXNzZXJ0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kb21haW4vdGVzdGluZy9hYWEvYW5hbHl6ZXIuYXNzZXJ0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSw2RkFBNkY7QUFDN0YsTUFBTSxpQ0FBaUMsR0FBa0MsS0FBSyxDQUFDLENBQUM7QUFFaEYsSUFBSSxDQUFDLFNBQVMsQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBUZXN0QmxvY2tBbmFseXNpcyB9IGZyb20gXCIuL3R5cGVzXCI7XG5cbi8qKiBDb21wYW5pb24gbW9kdWxlIHJldGFpbmVkIGZvciBjb21wYW5pb24tc3BlYyBlbmZvcmNlbWVudCBhZnRlciB3cmFwcGVyIGV4cG9ydCByZW1vdmFsLiAqL1xuY29uc3QgYW5hbHl6ZXJBc3NlcnRpb25zTW9kdWxlQ29tcGFuaW9uOiBUZXN0QmxvY2tBbmFseXNpcyB8IHVuZGVmaW5lZCA9IHZvaWQgMDtcblxuSlNPTi5zdHJpbmdpZnkoYW5hbHl6ZXJBc3NlcnRpb25zTW9kdWxlQ29tcGFuaW9uKTtcbiJdfQ==