@codeperfect/eslint-plugin 1.0.0 → 2.0.0

package/dist/domain/testing/prefer-vitest-incremental-casts/type-shape-helpers.js

@@ -0,0 +1,138 @@
+import { isMethodDeclaration, isMethodSignature, isParameter, isPropertyDeclaration, isPropertySignature, SignatureKind, SymbolFlags, } from "typescript";
+/**
+ * Selects a single object-like branch from a union when one exists.
+ * @param checker TypeScript type checker instance.
+ * @param unionType Union type to inspect.
+ * @returns The single object-like branch when the union is unambiguous.
+ * @example
+ * ```typescript
+ * const branch = getSingleUnionObjectLikeType(checker, unionType);
+ * ```
+ */
+function getSingleUnionObjectLikeType(checker, unionType) {
+    const objectLikeTypes = unionType.types.filter((type) => hasObjectShape(checker, type));
+    return objectLikeTypes.length === 1 ? objectLikeTypes[0] : void 0;
+}
+/**
+ * Detects whether a TypeScript type has an object-like surface.
+ * @param checker TypeScript type checker instance.
+ * @param targetType Candidate target type.
+ * @returns True when the type exposes properties or callable signatures.
+ * @example
+ * ```typescript
+ * const objectLike = hasObjectShape(checker, targetType);
+ * ```
+ */
+function hasObjectShape(checker, targetType) {
+    return (checker.getPropertiesOfType(targetType).length > 0 ||
+        checker.getSignaturesOfType(targetType, SignatureKind.Call).length > 0 ||
+        checker.getSignaturesOfType(targetType, SignatureKind.Construct).length > 0);
+}
+/**
+ * Checks whether a TypeScript symbol flag is present without using bitwise syntax.
+ * @param flags Symbol flag bitset to inspect.
+ * @param flag Specific flag to test.
+ * @returns True when the flag is present in the bitset.
+ * @example
+ * ```typescript
+ * const hasOptionalFlag = hasSymbolFlag(SymbolFlags.Optional, SymbolFlags.Optional);
+ * ```
+ */
+function hasSymbolFlag(flags, flag) {
+    return Math.trunc(flags / flag) % 2 === 1;
+}
+/**
+ * Determines whether a symbol represents an optional object property.
+ * @param propertySymbol Property symbol being checked.
+ * @returns True when a declaration marks the property as optional.
+ * @example
+ * ```typescript
+ * const optional = isOptionalSymbol(propertySymbol);
+ * ```
+ */
+function isOptionalSymbol(propertySymbol) {
+    const flags = typeof propertySymbol.getFlags === "function"
+        ? propertySymbol.getFlags()
+        : (propertySymbol.flags ?? 0);
+    if (hasSymbolFlag(flags, SymbolFlags.Optional)) {
+        return true;
+    }
+    const declarations = propertySymbol.getDeclarations() ?? [];
+    return declarations.some((declaration) => {
+        if (isParameter(declaration) ||
+            isPropertyDeclaration(declaration) ||
+            isPropertySignature(declaration) ||
+            isMethodDeclaration(declaration) ||
+            isMethodSignature(declaration)) {
+            return declaration.questionToken !== void 0;
+        }
+        return false;
+    });
+}
+/**
+ * Determines whether the object literal still needs an outer cast.
+ * @param context Data used to decide whether the full object needs casting.
+ * @returns True when the full object still needs casting.
+ * @example
+ * ```typescript
+ * const needsOuterCast = isOuterCastRequired(context);
+ * ```
+ */
+function isOuterCastRequired(context) {
+    const { checker, propertyNames, targetType } = context;
+    if (checker.getSignaturesOfType(targetType, SignatureKind.Call).length > 0) {
+        return true;
+    }
+    if (checker.getSignaturesOfType(targetType, SignatureKind.Construct).length > 0) {
+        return true;
+    }
+    return checker
+        .getPropertiesOfType(targetType)
+        .some((propertySymbol) => !isOptionalSymbol(propertySymbol) &&
+        !propertyNames.has(propertySymbol.getName()));
+}
+/**
+ * Narrows a target type to the object-like type the fixer can reason about.
+ * @param checker TypeScript type checker instance.
+ * @param targetType Candidate target type.
+ * @returns Object-like type when the target can be normalized safely.
+ * @example
+ * ```typescript
+ * const normalizedType = normalizeObjectLikeType(checker, targetType);
+ * ```
+ */
+function normalizeObjectLikeType(checker, targetType) {
+    if (targetType === void 0) {
+        return void 0;
+    }
+    const resolvedType = checker.getAwaitedType(targetType);
+    if (resolvedType === void 0) {
+        return void 0;
+    }
+    const directObjectLikeType = [resolvedType].find((type) => hasObjectShape(checker, type));
+    return (directObjectLikeType ??
+        (resolvedType.isUnion()
+            ? getSingleUnionObjectLikeType(checker, resolvedType)
+            : void 0));
+}
+/**
+ * Resolves the factory function's returned object type from its call signatures.
+ * @param checker TypeScript type checker instance.
+ * @param factoryParameterType Type of the factory callback parameter.
+ * @returns Normalized object-like return type when one is available.
+ * @example
+ * ```typescript
+ * const returnType = resolveFactoryReturnType(checker, factoryParameterType);
+ * ```
+ */
+function resolveFactoryReturnType(checker, factoryParameterType) {
+    for (const factorySignature of checker.getSignaturesOfType(factoryParameterType, SignatureKind.Call)) {
+        const normalizedReturnType = normalizeObjectLikeType(checker, checker.getReturnTypeOfSignature(factorySignature));
+        if (normalizedReturnType !== void 0) {
+            return normalizedReturnType;
+        }
+    }
+    return void 0;
+}
+export { isOuterCastRequired, normalizeObjectLikeType, resolveFactoryReturnType, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type-shape-helpers.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/type-shape-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as ts from \"typescript\";\r\n\r\nimport {\r\n  isMethodDeclaration,\r\n  isMethodSignature,\r\n  isParameter,\r\n  isPropertyDeclaration,\r\n  isPropertySignature,\r\n  SignatureKind,\r\n  SymbolFlags,\r\n} from \"typescript\";\r\n\r\nimport type { OuterCastContext } from \"./types\";\r\n\r\n/** Minimal symbol-flag shape used by unit-test doubles. */\r\ninterface SymbolWithOptionalFlags {\r\n  /** Optional numeric flag bitset supplied by test doubles. */\r\n  flags?: number;\r\n\r\n  /** Optional getter used by real TypeScript symbols. */\r\n  getFlags?: () => number;\r\n}\r\n\r\n/**\r\n * Selects a single object-like branch from a union when one exists.\r\n * @param checker TypeScript type checker instance.\r\n * @param unionType Union type to inspect.\r\n * @returns The single object-like branch when the union is unambiguous.\r\n * @example\r\n * ```typescript\r\n * const branch = getSingleUnionObjectLikeType(checker, unionType);\r\n * ```\r\n */\r\nfunction getSingleUnionObjectLikeType(\r\n  checker: ts.TypeChecker,\r\n  unionType: ts.UnionType,\r\n): ts.Type | undefined {\r\n  const objectLikeTypes = unionType.types.filter((type) =>\r\n    hasObjectShape(checker, type),\r\n  );\r\n\r\n  return objectLikeTypes.length === 1 ? objectLikeTypes[0] : void 0;\r\n}\r\n\r\n/**\r\n * Detects whether a TypeScript type has an object-like surface.\r\n * @param checker TypeScript type checker instance.\r\n * @param targetType Candidate target type.\r\n * @returns True when the type exposes properties or callable signatures.\r\n * @example\r\n * ```typescript\r\n * const objectLike = hasObjectShape(checker, targetType);\r\n * ```\r\n */\r\nfunction hasObjectShape(checker: ts.TypeChecker, targetType: ts.Type): boolean {\r\n  return (\r\n    checker.getPropertiesOfType(targetType).length > 0 ||\r\n    checker.getSignaturesOfType(targetType, SignatureKind.Call).length > 0 ||\r\n    checker.getSignaturesOfType(targetType, SignatureKind.Construct).length > 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks whether a TypeScript symbol flag is present without using bitwise syntax.\r\n * @param flags Symbol flag bitset to inspect.\r\n * @param flag Specific flag to test.\r\n * @returns True when the flag is present in the bitset.\r\n * @example\r\n * ```typescript\r\n * const hasOptionalFlag = hasSymbolFlag(SymbolFlags.Optional, SymbolFlags.Optional);\r\n * ```\r\n */\r\nfunction hasSymbolFlag(flags: number, flag: SymbolFlags): boolean {\r\n  return Math.trunc(flags / flag) % 2 === 1;\r\n}\r\n\r\n/**\r\n * Determines whether a symbol represents an optional object property.\r\n * @param propertySymbol Property symbol being checked.\r\n * @returns True when a declaration marks the property as optional.\r\n * @example\r\n * ```typescript\r\n * const optional = isOptionalSymbol(propertySymbol);\r\n * ```\r\n */\r\nfunction isOptionalSymbol(propertySymbol: ts.Symbol): boolean {\r\n  const flags =\r\n    typeof propertySymbol.getFlags === \"function\"\r\n      ? propertySymbol.getFlags()\r\n      : ((propertySymbol as SymbolWithOptionalFlags).flags ?? 0);\r\n\r\n  if (hasSymbolFlag(flags, SymbolFlags.Optional)) {\r\n    return true;\r\n  }\r\n\r\n  const declarations = propertySymbol.getDeclarations() ?? [];\r\n\r\n  return declarations.some((declaration) => {\r\n    if (\r\n      isParameter(declaration) ||\r\n      isPropertyDeclaration(declaration) ||\r\n      isPropertySignature(declaration) ||\r\n      isMethodDeclaration(declaration) ||\r\n      isMethodSignature(declaration)\r\n    ) {\r\n      return declaration.questionToken !== void 0;\r\n    }\r\n\r\n    return false;\r\n  });\r\n}\r\n\r\n/**\r\n * Determines whether the object literal still needs an outer cast.\r\n * @param context Data used to decide whether the full object needs casting.\r\n * @returns True when the full object still needs casting.\r\n * @example\r\n * ```typescript\r\n * const needsOuterCast = isOuterCastRequired(context);\r\n * ```\r\n */\r\nfunction isOuterCastRequired(context: OuterCastContext): boolean {\r\n  const { checker, propertyNames, targetType } = context;\r\n\r\n  if (checker.getSignaturesOfType(targetType, SignatureKind.Call).length > 0) {\r\n    return true;\r\n  }\r\n\r\n  if (\r\n    checker.getSignaturesOfType(targetType, SignatureKind.Construct).length > 0\r\n  ) {\r\n    return true;\r\n  }\r\n\r\n  return checker\r\n    .getPropertiesOfType(targetType)\r\n    .some(\r\n      (propertySymbol) =>\r\n        !isOptionalSymbol(propertySymbol) &&\r\n        !propertyNames.has(propertySymbol.getName()),\r\n    );\r\n}\r\n\r\n/**\r\n * Narrows a target type to the object-like type the fixer can reason about.\r\n * @param checker TypeScript type checker instance.\r\n * @param targetType Candidate target type.\r\n * @returns Object-like type when the target can be normalized safely.\r\n * @example\r\n * ```typescript\r\n * const normalizedType = normalizeObjectLikeType(checker, targetType);\r\n * ```\r\n */\r\nfunction normalizeObjectLikeType(\r\n  checker: ts.TypeChecker,\r\n  targetType: ts.Type | undefined,\r\n): ts.Type | undefined {\r\n  if (targetType === void 0) {\r\n    return void 0;\r\n  }\r\n\r\n  const resolvedType = checker.getAwaitedType(targetType);\r\n\r\n  if (resolvedType === void 0) {\r\n    return void 0;\r\n  }\r\n\r\n  const directObjectLikeType = [resolvedType].find((type) =>\r\n    hasObjectShape(checker, type),\r\n  );\r\n\r\n  return (\r\n    directObjectLikeType ??\r\n    (resolvedType.isUnion()\r\n      ? getSingleUnionObjectLikeType(checker, resolvedType)\r\n      : void 0)\r\n  );\r\n}\r\n\r\n/**\r\n * Resolves the factory function's returned object type from its call signatures.\r\n * @param checker TypeScript type checker instance.\r\n * @param factoryParameterType Type of the factory callback parameter.\r\n * @returns Normalized object-like return type when one is available.\r\n * @example\r\n * ```typescript\r\n * const returnType = resolveFactoryReturnType(checker, factoryParameterType);\r\n * ```\r\n */\r\nfunction resolveFactoryReturnType(\r\n  checker: ts.TypeChecker,\r\n  factoryParameterType: ts.Type,\r\n): ts.Type | undefined {\r\n  for (const factorySignature of checker.getSignaturesOfType(\r\n    factoryParameterType,\r\n    SignatureKind.Call,\r\n  )) {\r\n    const normalizedReturnType = normalizeObjectLikeType(\r\n      checker,\r\n      checker.getReturnTypeOfSignature(factorySignature),\r\n    );\r\n\r\n    if (normalizedReturnType !== void 0) {\r\n      return normalizedReturnType;\r\n    }\r\n  }\r\n\r\n  return void 0;\r\n}\r\n\r\nexport {\r\n  isOuterCastRequired,\r\n  normalizeObjectLikeType,\r\n  resolveFactoryReturnType,\r\n};\r\n"]}

package/dist/domain/testing/prefer-vitest-incremental-casts/types.d.ts

@@ -0,0 +1,203 @@
+import type { ESLintUtils, TSESLint, TSESTree } from "@typescript-eslint/utils";
+import type * as ts from "typescript";
+/** Context used to build the final replacement for a matching mock object. */
+interface BuildMatchResultContext {
+    /** TypeScript type checker used for assignability checks. */
+    checker: ts.TypeChecker;
+    /** Factory function supplied to `vi.mock` or `vi.doMock`. */
+    factoryArgument: FactoryFunctionExpression;
+    /** Static module specifier used by the mock call. */
+    moduleSpecifier: string;
+    /** Returned object literal from the mock factory. */
+    objectExpression: TSESTree.ObjectExpression;
+    /** Property names already present in the rewritten object literal. */
+    propertyNames: Set<string>;
+    /** Nested property replacements collected for the object literal. */
+    replacements: PropertyReplacement[];
+    /** Expression returned by the mock factory. */
+    returnExpression: TSESTree.Expression;
+    /** Full source text of the current file. */
+    sourceText: string;
+    /** Target type inferred for the factory object. */
+    targetType: ts.Type;
+}
+/** Context required to replace one object literal property safely. */
+interface BuildPropertyReplacementContext {
+    /** TypeScript type checker used for assignability checks. */
+    checker: ts.TypeChecker;
+    /** Stable property key name from the mock object literal. */
+    keyName: string;
+    /** Static module specifier used by the mock call. */
+    moduleSpecifier: string;
+    /** Supported property being rewritten. */
+    property: SupportedProperty;
+    /** Parser services supplied by `@typescript-eslint`. */
+    services: ParserServices;
+    /** Full source text of the current file. */
+    sourceText: string;
+    /** Target property symbol from the imported module type. */
+    targetPropertySymbol: ts.Symbol;
+}
+/** Input required to analyze a `vi.mock` or `vi.doMock` call. */
+interface CollectMatchContext {
+    /** Call expression currently being analyzed. */
+    callExpression: TSESTree.CallExpression;
+    /** TypeScript type checker used for assignability checks. */
+    checker: ts.TypeChecker;
+    /** Parser services supplied by `@typescript-eslint`. */
+    services: ParserServices;
+    /** Full source text of the current file. */
+    sourceText: string;
+}
+/** Context used to collect nested property replacements. */
+interface CollectPropertyReplacementsContext {
+    /** TypeScript type checker used for assignability checks. */
+    checker: ts.TypeChecker;
+    /** Static module specifier used by the mock call. */
+    moduleSpecifier: string;
+    /** Returned object literal from the mock factory. */
+    objectExpression: TSESTree.ObjectExpression;
+    /** Parser services supplied by `@typescript-eslint`. */
+    services: ParserServices;
+    /** Full source text of the current file. */
+    sourceText: string;
+    /** Target type inferred for the factory object. */
+    targetType: ts.Type;
+}
+/** Function expressions supported as Vitest mock factories. */
+type FactoryFunctionExpression = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;
+/** Resolved inputs required to analyze a matching Vitest mock factory. */
+interface FactoryMatchInput {
+    /** Factory function supplied to `vi.mock` or `vi.doMock`. */
+    factoryArgument: FactoryFunctionExpression;
+    /** Static module specifier used by the mock call. */
+    moduleSpecifier: string;
+    /** Returned object literal from the mock factory. */
+    objectExpression: TSESTree.ObjectExpression;
+    /** Expression returned by the mock factory. */
+    returnExpression: TSESTree.Expression;
+}
+/** Context used to inspect one callable signature for a mock factory. */
+interface MatchingSignatureReturnTypeContext {
+    /** TypeScript type checker used for assignability checks. */
+    checker: ts.TypeChecker;
+    /** First mock-call argument node. */
+    firstArgument: ts.Node;
+    /** Type resolved for the first mock-call argument. */
+    firstArgumentType: ts.Type;
+    /** Callable signature being inspected. */
+    signature: ts.Signature;
+    /** TypeScript node for the factory callback argument. */
+    tsFactoryArgument: ts.Node;
+}
+/** Text replacement emitted for a matching factory object. */
+interface MatchResult {
+    /** Replacement source text for the returned object expression. */
+    replacementText: string;
+    /** Absolute range of the return expression to replace. */
+    returnExpressionRange: TSESTree.Range;
+}
+/** Rule message identifiers emitted by this rule. */
+type MessageIds = "preferVitestIncrementalCasts";
+/** Normalized arguments extracted from a supported mock call. */
+interface MockFactoryArguments {
+    /** Factory function supplied to `vi.mock` or `vi.doMock`. */
+    factoryArgument: FactoryFunctionExpression;
+    /** Static or import-expression module argument. */
+    moduleArgument: TSESTree.Expression;
+}
+/** Rule options accepted by this rule. */
+type Options = [];
+/** Context required to decide whether an outer cast is still needed. */
+interface OuterCastContext {
+    /** TypeScript type checker used for assignability checks. */
+    checker: ts.TypeChecker;
+    /** Property names already present in the rewritten object literal. */
+    propertyNames: ReadonlySet<string>;
+    /** Target type inferred for the factory object. */
+    targetType: ts.Type;
+}
+/** Parser services resolved from the configured TypeScript parser. */
+type ParserServices = ReturnType<typeof ESLintUtils.getParserServices>;
+/** Individual replacement details for one property inside the object literal. */
+interface PropertyReplacement {
+    /** Absolute range of the property inside the object literal. */
+    range: TSESTree.Range;
+    /** Replacement source text for the property. */
+    replacementText: string;
+}
+/** Replacement collection result for the object literal properties. */
+interface PropertyReplacementCollection {
+    /** Property names already present in the rewritten object literal. */
+    propertyNames: Set<string>;
+    /** Nested property replacements collected for the object literal. */
+    replacements: PropertyReplacement[];
+}
+/** Context for resolving the target type of a mock factory object literal. */
+interface ResolveFactoryTargetTypeContext {
+    /** Call expression currently being analyzed. */
+    callExpression: TSESTree.CallExpression;
+    /** TypeScript type checker used for assignability checks. */
+    checker: ts.TypeChecker;
+    /** Factory function supplied to `vi.mock` or `vi.doMock`. */
+    factoryArgument: FactoryFunctionExpression;
+    /** Returned object literal from the mock factory. */
+    objectExpression: TSESTree.ObjectExpression;
+    /** Parser services supplied by `@typescript-eslint`. */
+    services: ParserServices;
+}
+/** Context for determining whether shorthand syntax remains valid. */
+interface ShorthandContext {
+    /** Expression used as the property's value. */
+    baseValue: TSESTree.Expression;
+    /** Stable property key name from the mock object literal. */
+    keyName: string;
+    /** Whether the property value needs a nested cast. */
+    needsCast: boolean;
+    /** Supported property being rewritten. */
+    property: SupportedProperty;
+}
+/** Normalized inputs used when matching callable Vitest signatures. */
+interface SignatureMatchInputs {
+    /** Type resolved for the mock callee expression. */
+    calleeType: ts.Type;
+    /** First mock-call argument node. */
+    firstArgument: ts.Node;
+    /** Type resolved for the first mock-call argument. */
+    firstArgumentType: ts.Type;
+    /** TypeScript node for the factory callback argument. */
+    tsFactoryArgument: ts.Node;
+}
+/** Object literal properties supported by the fixer. */
+type SupportedProperty = Extract<TSESTree.ObjectLiteralElement, TSESTree.Property> & {
+    /** Indicates that computed property syntax is not allowed. */
+    computed: false;
+    /** Restricts the key to statically readable property names. */
+    key: SupportedPropertyKey;
+    /** Restricts the property to initializer syntax. */
+    kind: "init";
+    /** Indicates that method shorthand is not allowed. */
+    method: false;
+    /** Absolute range of the full property inside the source file. */
+    range: TSESTree.Range;
+    /** Expression value assigned to the property. */
+    value: SupportedPropertyValueRange & TSESTree.Expression;
+};
+/** Property keys supported by the fixer. */
+type SupportedPropertyKey = (SupportedPropertyKeyRange & TSESTree.Identifier) | (SupportedPropertyKeyRange & TSESTree.Literal);
+/** Stable property-key range metadata. */
+interface SupportedPropertyKeyRange {
+    /** Absolute range of the property key inside the source file. */
+    range: TSESTree.Range;
+}
+/** Stable property-value range metadata. */
+interface SupportedPropertyValueRange {
+    /** Absolute range of the property value inside the source file. */
+    range: TSESTree.Range;
+}
+/** Property-symbol lookup keyed by object literal property name. */
+type TargetPropertyMap = ReadonlyMap<string, ts.Symbol>;
+/** Typed rule context used by the typed RuleCreator wrapper. */
+type TypedRuleContext = Readonly<TSESLint.RuleContext<MessageIds, Options>>;
+export type { BuildMatchResultContext, BuildPropertyReplacementContext, CollectMatchContext, CollectPropertyReplacementsContext, FactoryFunctionExpression, FactoryMatchInput, MatchingSignatureReturnTypeContext, MatchResult, MessageIds, MockFactoryArguments, Options, OuterCastContext, ParserServices, PropertyReplacement, PropertyReplacementCollection, ResolveFactoryTargetTypeContext, ShorthandContext, SignatureMatchInputs, SupportedProperty, TargetPropertyMap, TypedRuleContext, };
+//# sourceMappingURL=types.d.ts.map

package/dist/domain/testing/prefer-vitest-incremental-casts/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/types.ts"],"names":[],"mappings":"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"}

package/dist/domain/testing/prefer-vitest-incremental-casts/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/types.ts"],"names":[],"mappings":"","sourcesContent":["import type { ESLintUtils, TSESLint, TSESTree } from \"@typescript-eslint/utils\";\r\nimport type * as ts from \"typescript\";\r\n\r\n/** Context used to build the final replacement for a matching mock object. */\r\ninterface BuildMatchResultContext {\r\n  /** TypeScript type checker used for assignability checks. */\r\n  checker: ts.TypeChecker;\r\n\r\n  /** Factory function supplied to `vi.mock` or `vi.doMock`. */\r\n  factoryArgument: FactoryFunctionExpression;\r\n\r\n  /** Static module specifier used by the mock call. */\r\n  moduleSpecifier: string;\r\n\r\n  /** Returned object literal from the mock factory. */\r\n  objectExpression: TSESTree.ObjectExpression;\r\n\r\n  /** Property names already present in the rewritten object literal. */\r\n  propertyNames: Set<string>;\r\n\r\n  /** Nested property replacements collected for the object literal. */\r\n  replacements: PropertyReplacement[];\r\n\r\n  /** Expression returned by the mock factory. */\r\n  returnExpression: TSESTree.Expression;\r\n\r\n  /** Full source text of the current file. */\r\n  sourceText: string;\r\n\r\n  /** Target type inferred for the factory object. */\r\n  targetType: ts.Type;\r\n}\r\n\r\n/** Context required to replace one object literal property safely. */\r\ninterface BuildPropertyReplacementContext {\r\n  /** TypeScript type checker used for assignability checks. */\r\n  checker: ts.TypeChecker;\r\n\r\n  /** Stable property key name from the mock object literal. */\r\n  keyName: string;\r\n\r\n  /** Static module specifier used by the mock call. */\r\n  moduleSpecifier: string;\r\n\r\n  /** Supported property being rewritten. */\r\n  property: SupportedProperty;\r\n\r\n  /** Parser services supplied by `@typescript-eslint`. */\r\n  services: ParserServices;\r\n\r\n  /** Full source text of the current file. */\r\n  sourceText: string;\r\n\r\n  /** Target property symbol from the imported module type. */\r\n  targetPropertySymbol: ts.Symbol;\r\n}\r\n\r\n/** Input required to analyze a `vi.mock` or `vi.doMock` call. */\r\ninterface CollectMatchContext {\r\n  /** Call expression currently being analyzed. */\r\n  callExpression: TSESTree.CallExpression;\r\n\r\n  /** TypeScript type checker used for assignability checks. */\r\n  checker: ts.TypeChecker;\r\n\r\n  /** Parser services supplied by `@typescript-eslint`. */\r\n  services: ParserServices;\r\n\r\n  /** Full source text of the current file. */\r\n  sourceText: string;\r\n}\r\n\r\n/** Context used to collect nested property replacements. */\r\ninterface CollectPropertyReplacementsContext {\r\n  /** TypeScript type checker used for assignability checks. */\r\n  checker: ts.TypeChecker;\r\n\r\n  /** Static module specifier used by the mock call. */\r\n  moduleSpecifier: string;\r\n\r\n  /** Returned object literal from the mock factory. */\r\n  objectExpression: TSESTree.ObjectExpression;\r\n\r\n  /** Parser services supplied by `@typescript-eslint`. */\r\n  services: ParserServices;\r\n\r\n  /** Full source text of the current file. */\r\n  sourceText: string;\r\n\r\n  /** Target type inferred for the factory object. */\r\n  targetType: ts.Type;\r\n}\r\n\r\n/** Function expressions supported as Vitest mock factories. */\r\ntype FactoryFunctionExpression =\r\n  | TSESTree.ArrowFunctionExpression\r\n  | TSESTree.FunctionExpression;\r\n\r\n/** Resolved inputs required to analyze a matching Vitest mock factory. */\r\ninterface FactoryMatchInput {\r\n  /** Factory function supplied to `vi.mock` or `vi.doMock`. */\r\n  factoryArgument: FactoryFunctionExpression;\r\n\r\n  /** Static module specifier used by the mock call. */\r\n  moduleSpecifier: string;\r\n\r\n  /** Returned object literal from the mock factory. */\r\n  objectExpression: TSESTree.ObjectExpression;\r\n\r\n  /** Expression returned by the mock factory. */\r\n  returnExpression: TSESTree.Expression;\r\n}\r\n\r\n/** Context used to inspect one callable signature for a mock factory. */\r\ninterface MatchingSignatureReturnTypeContext {\r\n  /** TypeScript type checker used for assignability checks. */\r\n  checker: ts.TypeChecker;\r\n\r\n  /** First mock-call argument node. */\r\n  firstArgument: ts.Node;\r\n\r\n  /** Type resolved for the first mock-call argument. */\r\n  firstArgumentType: ts.Type;\r\n\r\n  /** Callable signature being inspected. */\r\n  signature: ts.Signature;\r\n\r\n  /** TypeScript node for the factory callback argument. */\r\n  tsFactoryArgument: ts.Node;\r\n}\r\n\r\n/** Text replacement emitted for a matching factory object. */\r\ninterface MatchResult {\r\n  /** Replacement source text for the returned object expression. */\r\n  replacementText: string;\r\n\r\n  /** Absolute range of the return expression to replace. */\r\n  returnExpressionRange: TSESTree.Range;\r\n}\r\n\r\n/** Rule message identifiers emitted by this rule. */\r\ntype MessageIds = \"preferVitestIncrementalCasts\";\r\n\r\n/** Normalized arguments extracted from a supported mock call. */\r\ninterface MockFactoryArguments {\r\n  /** Factory function supplied to `vi.mock` or `vi.doMock`. */\r\n  factoryArgument: FactoryFunctionExpression;\r\n\r\n  /** Static or import-expression module argument. */\r\n  moduleArgument: TSESTree.Expression;\r\n}\r\n\r\n/** Rule options accepted by this rule. */\r\ntype Options = [];\r\n\r\n/** Context required to decide whether an outer cast is still needed. */\r\ninterface OuterCastContext {\r\n  /** TypeScript type checker used for assignability checks. */\r\n  checker: ts.TypeChecker;\r\n\r\n  /** Property names already present in the rewritten object literal. */\r\n  propertyNames: ReadonlySet<string>;\r\n\r\n  /** Target type inferred for the factory object. */\r\n  targetType: ts.Type;\r\n}\r\n/** Parser services resolved from the configured TypeScript parser. */\r\ntype ParserServices = ReturnType<typeof ESLintUtils.getParserServices>;\r\n/** Individual replacement details for one property inside the object literal. */\r\ninterface PropertyReplacement {\r\n  /** Absolute range of the property inside the object literal. */\r\n  range: TSESTree.Range;\r\n\r\n  /** Replacement source text for the property. */\r\n  replacementText: string;\r\n}\r\n\r\n/** Replacement collection result for the object literal properties. */\r\ninterface PropertyReplacementCollection {\r\n  /** Property names already present in the rewritten object literal. */\r\n  propertyNames: Set<string>;\r\n\r\n  /** Nested property replacements collected for the object literal. */\r\n  replacements: PropertyReplacement[];\r\n}\r\n\r\n/** Context for resolving the target type of a mock factory object literal. */\r\ninterface ResolveFactoryTargetTypeContext {\r\n  /** Call expression currently being analyzed. */\r\n  callExpression: TSESTree.CallExpression;\r\n\r\n  /** TypeScript type checker used for assignability checks. */\r\n  checker: ts.TypeChecker;\r\n\r\n  /** Factory function supplied to `vi.mock` or `vi.doMock`. */\r\n  factoryArgument: FactoryFunctionExpression;\r\n\r\n  /** Returned object literal from the mock factory. */\r\n  objectExpression: TSESTree.ObjectExpression;\r\n\r\n  /** Parser services supplied by `@typescript-eslint`. */\r\n  services: ParserServices;\r\n}\r\n/** Context for determining whether shorthand syntax remains valid. */\r\ninterface ShorthandContext {\r\n  /** Expression used as the property's value. */\r\n  baseValue: TSESTree.Expression;\r\n\r\n  /** Stable property key name from the mock object literal. */\r\n  keyName: string;\r\n\r\n  /** Whether the property value needs a nested cast. */\r\n  needsCast: boolean;\r\n\r\n  /** Supported property being rewritten. */\r\n  property: SupportedProperty;\r\n}\r\n/** Normalized inputs used when matching callable Vitest signatures. */\r\ninterface SignatureMatchInputs {\r\n  /** Type resolved for the mock callee expression. */\r\n  calleeType: ts.Type;\r\n\r\n  /** First mock-call argument node. */\r\n  firstArgument: ts.Node;\r\n\r\n  /** Type resolved for the first mock-call argument. */\r\n  firstArgumentType: ts.Type;\r\n\r\n  /** TypeScript node for the factory callback argument. */\r\n  tsFactoryArgument: ts.Node;\r\n}\r\n/** Object literal properties supported by the fixer. */\r\ntype SupportedProperty = Extract<\r\n  TSESTree.ObjectLiteralElement,\r\n  TSESTree.Property\r\n> & {\r\n  /** Indicates that computed property syntax is not allowed. */\r\n  computed: false;\r\n\r\n  /** Restricts the key to statically readable property names. */\r\n  key: SupportedPropertyKey;\r\n\r\n  /** Restricts the property to initializer syntax. */\r\n  kind: \"init\";\r\n\r\n  /** Indicates that method shorthand is not allowed. */\r\n  method: false;\r\n\r\n  /** Absolute range of the full property inside the source file. */\r\n  range: TSESTree.Range;\r\n\r\n  /** Expression value assigned to the property. */\r\n  value: SupportedPropertyValueRange & TSESTree.Expression;\r\n};\r\n/** Property keys supported by the fixer. */\r\ntype SupportedPropertyKey =\r\n  | (SupportedPropertyKeyRange & TSESTree.Identifier)\r\n  | (SupportedPropertyKeyRange & TSESTree.Literal);\r\n/** Stable property-key range metadata. */\r\ninterface SupportedPropertyKeyRange {\r\n  /** Absolute range of the property key inside the source file. */\r\n  range: TSESTree.Range;\r\n}\r\n/** Stable property-value range metadata. */\r\ninterface SupportedPropertyValueRange {\r\n  /** Absolute range of the property value inside the source file. */\r\n  range: TSESTree.Range;\r\n}\r\n/** Property-symbol lookup keyed by object literal property name. */\r\ntype TargetPropertyMap = ReadonlyMap<string, ts.Symbol>;\r\n\r\n/** Typed rule context used by the typed RuleCreator wrapper. */\r\ntype TypedRuleContext = Readonly<TSESLint.RuleContext<MessageIds, Options>>;\r\n\r\nexport type {\r\n  BuildMatchResultContext,\r\n  BuildPropertyReplacementContext,\r\n  CollectMatchContext,\r\n  CollectPropertyReplacementsContext,\r\n  FactoryFunctionExpression,\r\n  FactoryMatchInput,\r\n  MatchingSignatureReturnTypeContext,\r\n  MatchResult,\r\n  MessageIds,\r\n  MockFactoryArguments,\r\n  Options,\r\n  OuterCastContext,\r\n  ParserServices,\r\n  PropertyReplacement,\r\n  PropertyReplacementCollection,\r\n  ResolveFactoryTargetTypeContext,\r\n  ShorthandContext,\r\n  SignatureMatchInputs,\r\n  SupportedProperty,\r\n  TargetPropertyMap,\r\n  TypedRuleContext,\r\n};\r\n"]}

package/dist/domain/testing/require-aaa-sections/index.d.ts

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

package/dist/domain/testing/require-aaa-sections/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/require-aaa-sections/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/testing/require-aaa-sections/index.js

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

package/dist/domain/testing/require-aaa-sections/missing-section-fixes.d.ts

@@ -0,0 +1,17 @@
+import type { Rule } from "eslint";
+import type { AaaPhase, TestBlockAnalysis } from "../aaa/index.js";
+/**
+ * Builds autofix edits for each missing AAA section marker.
+ * @param analysis Parsed test-block analysis.
+ * @param missingSections Missing AAA phases to insert.
+ * @param fixer ESLint fixer instance.
+ * @returns Fixes that add the missing section comments.
+ * @example
+ * ```typescript
+ * const fixes = buildMissingSectionFixes({ newline: "\n", sourceText: "value" } as never, ["Arrange"], {} as never);
+ * void fixes;
+ * ```
+ */
+declare function buildMissingSectionFixes(analysis: TestBlockAnalysis, missingSections: readonly AaaPhase[], fixer: Rule.RuleFixer): Rule.Fix[];
+export { buildMissingSectionFixes };
+//# sourceMappingURL=missing-section-fixes.d.ts.map

package/dist/domain/testing/require-aaa-sections/missing-section-fixes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"missing-section-fixes.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/require-aaa-sections/missing-section-fixes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAmG1D;;;;;;;;;;;GAWG;AACH,iBAAS,wBAAwB,CAC/B,QAAQ,EAAE,iBAAiB,EAC3B,eAAe,EAAE,SAAS,QAAQ,EAAE,EACpC,KAAK,EAAE,IAAI,CAAC,SAAS,GACpB,IAAI,CAAC,GAAG,EAAE,CAWZ;AA4GD,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/domain/testing/require-aaa-sections/missing-section-fixes.js

@@ -0,0 +1,150 @@
+import { aaaPhaseOrder, getLineStartRange } from "../aaa/index.js";
+/**
+ * Groups missing phases by insertion offset.
+ * @param anchors Anchor statements available for insertion.
+ * @param missingSections Missing AAA phases to insert.
+ * @returns Map of source offsets to phases that should be inserted there.
+ * @example
+ * ```typescript
+ * const anchorMap = buildAnchorMap({ firstStatement: { range: [0, 1] } as never, lastStatement: { range: [2, 3] } as never, middleStatement: { range: [1, 2] } as never }, ["Arrange"]);
+ * void anchorMap;
+ * ```
+ */
+function buildAnchorMap(anchors, missingSections) {
+    const anchorMap = new Map();
+    for (const phase of missingSections) {
+        const anchorNode = getAnchorNode(anchors, phase);
+        const existing = anchorMap.get(anchorNode.range[0]) ?? [];
+        existing.push(phase);
+        anchorMap.set(anchorNode.range[0], existing);
+    }
+    return anchorMap;
+}
+/**
+ * Builds one autofix that inserts missing section markers before a statement.
+ * @param input Composite input for one missing-section fix.
+ * @returns Fix that inserts the missing section marker text.
+ * @example
+ * ```typescript
+ * const fix = buildMissingSectionFix({ analysis: { newline: "\n", sourceText: "value" } as never, fixer: {} as never, offset: 0, phases: ["Arrange"] });
+ * void fix;
+ * ```
+ */
+function buildMissingSectionFix(input) {
+    const { analysis, fixer, offset, phases } = input;
+    const sourceLines = analysis.sourceText.split(/\r\n|\n/u);
+    const sortedPhases = phases.toSorted((left, right) => aaaPhaseOrder[left] - aaaPhaseOrder[right]);
+    const statementLine = analysis.sourceText
+        .slice(0, offset)
+        .split(/\r\n|\n/u).length;
+    const lineStartRange = getLineStartRange(analysis.sourceText, statementLine);
+    const [previousLine = ""] = statementLine > 1
+        ? sourceLines.slice(statementLine - 2, statementLine - 1)
+        : [];
+    const needsLeadingBlankLine = shouldInsertLeadingBlankLine(sortedPhases, previousLine);
+    const [currentLine = ""] = sourceLines.slice(statementLine - 1, statementLine);
+    const indentation = getLineIndentation(currentLine);
+    return fixer.insertTextBeforeRange(lineStartRange, `${needsLeadingBlankLine ? analysis.newline : ""}${indentation}// ${sortedPhases.join(" & ")}${analysis.newline}`);
+}
+/**
+ * Builds autofix edits for each missing AAA section marker.
+ * @param analysis Parsed test-block analysis.
+ * @param missingSections Missing AAA phases to insert.
+ * @param fixer ESLint fixer instance.
+ * @returns Fixes that add the missing section comments.
+ * @example
+ * ```typescript
+ * const fixes = buildMissingSectionFixes({ newline: "\n", sourceText: "value" } as never, ["Arrange"], {} as never);
+ * void fixes;
+ * ```
+ */
+function buildMissingSectionFixes(analysis, missingSections, fixer) {
+    const anchors = getSectionAnchors(analysis);
+    if (anchors === void 0) {
+        return [];
+    }
+    return [...buildAnchorMap(anchors, missingSections).entries()].map(([offset, phases]) => buildMissingSectionFix({ analysis, fixer, offset, phases }));
+}
+/**
+ * Selects the anchor statement used for one missing AAA phase.
+ * @param anchors Anchor statements available for insertion.
+ * @param phase Missing phase being inserted.
+ * @returns Statement node used as the insertion anchor.
+ * @example
+ * ```typescript
+ * const anchor = getAnchorNode({ firstStatement: {} as never, lastStatement: {} as never, middleStatement: {} as never }, "Arrange");
+ * void anchor;
+ * ```
+ */
+function getAnchorNode(anchors, phase) {
+    switch (phase) {
+        case "Act": {
+            return anchors.middleStatement;
+        }
+        case "Arrange": {
+            return anchors.firstStatement;
+        }
+        case "Assert": {
+            return anchors.lastStatement;
+        }
+        default: {
+            return anchors.lastStatement;
+        }
+    }
+}
+/**
+ * Reads the indentation prefix from a source line.
+ * @param lineText Source line text.
+ * @returns Leading whitespace for the line.
+ * @example
+ * ```typescript
+ * const indentation = getLineIndentation("  value");
+ * void indentation;
+ * ```
+ */
+function getLineIndentation(lineText) {
+    const trimmedLine = lineText.trimStart();
+    return lineText.slice(0, lineText.length - trimmedLine.length);
+}
+/**
+ * Selects the statement nodes used as insertion anchors for missing sections.
+ * @param analysis Parsed test-block analysis.
+ * @returns Anchor statements for Arrange, Act, and Assert insertion.
+ * @example
+ * ```typescript
+ * const anchors = getSectionAnchors({ statements: [] } as never);
+ * void anchors;
+ * ```
+ */
+function getSectionAnchors(analysis) {
+    const [firstStatementEntry] = analysis.statements;
+    const middleStatementEntry = analysis.statements[Math.min(analysis.statements.length - 1, Math.floor(analysis.statements.length / 2))];
+    const lastStatementEntry = analysis.statements.at(-1);
+    if (firstStatementEntry === void 0 ||
+        middleStatementEntry === void 0 ||
+        lastStatementEntry === void 0) {
+        return void 0;
+    }
+    return {
+        firstStatement: firstStatementEntry.node,
+        lastStatement: lastStatementEntry.node,
+        middleStatement: middleStatementEntry.node,
+    };
+}
+/**
+ * Determines whether a missing section insertion needs a blank line prefix.
+ * @param phases Missing phases inserted at the same offset.
+ * @param previousLine Source line immediately above the insertion point.
+ * @returns Whether the inserted marker should start with a blank line.
+ * @example
+ * ```typescript
+ * const actual = shouldInsertLeadingBlankLine(["Act"], "run();");
+ * void actual;
+ * ```
+ */
+function shouldInsertLeadingBlankLine(phases, previousLine) {
+    return (phases.some((phase) => phase !== "Arrange") &&
+        previousLine.trim().length > 0);
+}
+export { buildMissingSectionFixes };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"missing-section-fixes.js","sourceRoot":"","sources":["../../../../src/domain/testing/require-aaa-sections/missing-section-fixes.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\r\n\r\nimport type { AaaPhase, TestBlockAnalysis } from \"../aaa\";\r\n\r\nimport { aaaPhaseOrder, getLineStartRange } from \"../aaa\";\r\n\r\n/** Composite input for building one missing-section fix. */\r\ninterface MissingSectionFixInput {\r\n  /** Parsed test-block analysis. */\r\n  analysis: TestBlockAnalysis;\r\n\r\n  /** ESLint fixer instance. */\r\n  fixer: Rule.RuleFixer;\r\n\r\n  /** Source offset where the section marker should be inserted. */\r\n  offset: number;\r\n\r\n  /** Missing phases that share the same insertion offset. */\r\n  phases: readonly AaaPhase[];\r\n}\r\n\r\n/** Anchor statements used to place missing AAA section comments. */\r\ninterface StatementAnchors {\r\n  /** First statement available for an Arrange insertion. */\r\n  firstStatement: TestBlockAnalysis[\"statements\"][number][\"node\"];\r\n\r\n  /** Last statement available for an Assert insertion. */\r\n  lastStatement: TestBlockAnalysis[\"statements\"][number][\"node\"];\r\n\r\n  /** Middle statement available for an Act insertion. */\r\n  middleStatement: TestBlockAnalysis[\"statements\"][number][\"node\"];\r\n}\r\n\r\n/**\r\n * Groups missing phases by insertion offset.\r\n * @param anchors Anchor statements available for insertion.\r\n * @param missingSections Missing AAA phases to insert.\r\n * @returns Map of source offsets to phases that should be inserted there.\r\n * @example\r\n * ```typescript\r\n * const anchorMap = buildAnchorMap({ firstStatement: { range: [0, 1] } as never, lastStatement: { range: [2, 3] } as never, middleStatement: { range: [1, 2] } as never }, [\"Arrange\"]);\r\n * void anchorMap;\r\n * ```\r\n */\r\nfunction buildAnchorMap(\r\n  anchors: StatementAnchors,\r\n  missingSections: readonly AaaPhase[],\r\n): Map<number, AaaPhase[]> {\r\n  const anchorMap = new Map<number, AaaPhase[]>();\r\n\r\n  for (const phase of missingSections) {\r\n    const anchorNode = getAnchorNode(anchors, phase);\r\n    const existing = anchorMap.get(anchorNode.range[0]) ?? [];\r\n\r\n    existing.push(phase);\r\n    anchorMap.set(anchorNode.range[0], existing);\r\n  }\r\n\r\n  return anchorMap;\r\n}\r\n\r\n/**\r\n * Builds one autofix that inserts missing section markers before a statement.\r\n * @param input Composite input for one missing-section fix.\r\n * @returns Fix that inserts the missing section marker text.\r\n * @example\r\n * ```typescript\r\n * const fix = buildMissingSectionFix({ analysis: { newline: \"\\n\", sourceText: \"value\" } as never, fixer: {} as never, offset: 0, phases: [\"Arrange\"] });\r\n * void fix;\r\n * ```\r\n */\r\nfunction buildMissingSectionFix(input: MissingSectionFixInput): Rule.Fix {\r\n  const { analysis, fixer, offset, phases } = input;\r\n  const sourceLines = analysis.sourceText.split(/\\r\\n|\\n/u);\r\n  const sortedPhases = phases.toSorted(\r\n    (left, right) => aaaPhaseOrder[left] - aaaPhaseOrder[right],\r\n  );\r\n  const statementLine = analysis.sourceText\r\n    .slice(0, offset)\r\n    .split(/\\r\\n|\\n/u).length;\r\n  const lineStartRange = getLineStartRange(analysis.sourceText, statementLine);\r\n  const [previousLine = \"\"] =\r\n    statementLine > 1\r\n      ? sourceLines.slice(statementLine - 2, statementLine - 1)\r\n      : [];\r\n  const needsLeadingBlankLine = shouldInsertLeadingBlankLine(\r\n    sortedPhases,\r\n    previousLine,\r\n  );\r\n  const [currentLine = \"\"] = sourceLines.slice(\r\n    statementLine - 1,\r\n    statementLine,\r\n  );\r\n  const indentation = getLineIndentation(currentLine);\r\n\r\n  return fixer.insertTextBeforeRange(\r\n    lineStartRange,\r\n    `${needsLeadingBlankLine ? analysis.newline : \"\"}${indentation}// ${sortedPhases.join(\" & \")}${analysis.newline}`,\r\n  );\r\n}\r\n\r\n/**\r\n * Builds autofix edits for each missing AAA section marker.\r\n * @param analysis Parsed test-block analysis.\r\n * @param missingSections Missing AAA phases to insert.\r\n * @param fixer ESLint fixer instance.\r\n * @returns Fixes that add the missing section comments.\r\n * @example\r\n * ```typescript\r\n * const fixes = buildMissingSectionFixes({ newline: \"\\n\", sourceText: \"value\" } as never, [\"Arrange\"], {} as never);\r\n * void fixes;\r\n * ```\r\n */\r\nfunction buildMissingSectionFixes(\r\n  analysis: TestBlockAnalysis,\r\n  missingSections: readonly AaaPhase[],\r\n  fixer: Rule.RuleFixer,\r\n): Rule.Fix[] {\r\n  const anchors = getSectionAnchors(analysis);\r\n\r\n  if (anchors === void 0) {\r\n    return [];\r\n  }\r\n\r\n  return [...buildAnchorMap(anchors, missingSections).entries()].map(\r\n    ([offset, phases]) =>\r\n      buildMissingSectionFix({ analysis, fixer, offset, phases }),\r\n  );\r\n}\r\n\r\n/**\r\n * Selects the anchor statement used for one missing AAA phase.\r\n * @param anchors Anchor statements available for insertion.\r\n * @param phase Missing phase being inserted.\r\n * @returns Statement node used as the insertion anchor.\r\n * @example\r\n * ```typescript\r\n * const anchor = getAnchorNode({ firstStatement: {} as never, lastStatement: {} as never, middleStatement: {} as never }, \"Arrange\");\r\n * void anchor;\r\n * ```\r\n */\r\nfunction getAnchorNode(\r\n  anchors: StatementAnchors,\r\n  phase: AaaPhase,\r\n): StatementAnchors[keyof StatementAnchors] {\r\n  switch (phase) {\r\n    case \"Act\": {\r\n      return anchors.middleStatement;\r\n    }\r\n    case \"Arrange\": {\r\n      return anchors.firstStatement;\r\n    }\r\n    case \"Assert\": {\r\n      return anchors.lastStatement;\r\n    }\r\n    default: {\r\n      return anchors.lastStatement;\r\n    }\r\n  }\r\n}\r\n\r\n/**\r\n * Reads the indentation prefix from a source line.\r\n * @param lineText Source line text.\r\n * @returns Leading whitespace for the line.\r\n * @example\r\n * ```typescript\r\n * const indentation = getLineIndentation(\"  value\");\r\n * void indentation;\r\n * ```\r\n */\r\nfunction getLineIndentation(lineText: string): string {\r\n  const trimmedLine = lineText.trimStart();\r\n\r\n  return lineText.slice(0, lineText.length - trimmedLine.length);\r\n}\r\n\r\n/**\r\n * Selects the statement nodes used as insertion anchors for missing sections.\r\n * @param analysis Parsed test-block analysis.\r\n * @returns Anchor statements for Arrange, Act, and Assert insertion.\r\n * @example\r\n * ```typescript\r\n * const anchors = getSectionAnchors({ statements: [] } as never);\r\n * void anchors;\r\n * ```\r\n */\r\nfunction getSectionAnchors(\r\n  analysis: TestBlockAnalysis,\r\n): StatementAnchors | undefined {\r\n  const [firstStatementEntry] = analysis.statements;\r\n  const middleStatementEntry =\r\n    analysis.statements[\r\n      Math.min(\r\n        analysis.statements.length - 1,\r\n        Math.floor(analysis.statements.length / 2),\r\n      )\r\n    ];\r\n  const lastStatementEntry = analysis.statements.at(-1);\r\n\r\n  if (\r\n    firstStatementEntry === void 0 ||\r\n    middleStatementEntry === void 0 ||\r\n    lastStatementEntry === void 0\r\n  ) {\r\n    return void 0;\r\n  }\r\n\r\n  return {\r\n    firstStatement: firstStatementEntry.node,\r\n    lastStatement: lastStatementEntry.node,\r\n    middleStatement: middleStatementEntry.node,\r\n  };\r\n}\r\n\r\n/**\r\n * Determines whether a missing section insertion needs a blank line prefix.\r\n * @param phases Missing phases inserted at the same offset.\r\n * @param previousLine Source line immediately above the insertion point.\r\n * @returns Whether the inserted marker should start with a blank line.\r\n * @example\r\n * ```typescript\r\n * const actual = shouldInsertLeadingBlankLine([\"Act\"], \"run();\");\r\n * void actual;\r\n * ```\r\n */\r\nfunction shouldInsertLeadingBlankLine(\r\n  phases: readonly AaaPhase[],\r\n  previousLine: string,\r\n): boolean {\r\n  return (\r\n    phases.some((phase) => phase !== \"Arrange\") &&\r\n    previousLine.trim().length > 0\r\n  );\r\n}\r\n\r\nexport { buildMissingSectionFixes };\r\n"]}

package/dist/{testing → domain/testing}/require-aaa-sections/rule.d.ts

@@ -1,4 +1,5 @@
 import type { Rule } from "eslint";
+/** Enforces explicit AAA section comments and spacing within supported test blocks. */
 declare const requireAaaSectionsRule: Rule.RuleModule;
 export { requireAaaSectionsRule };
 //# sourceMappingURL=rule.d.ts.map

package/dist/domain/testing/require-aaa-sections/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/require-aaa-sections/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAanC,uFAAuF;AACvF,QAAA,MAAM,sBAAsB,EAAE,IAAI,CAAC,UAkClC,CAAC;AA6IF,OAAO,EAAE,sBAAsB,EAAE,CAAC"}