@codeperfect/eslint-plugin 1.0.0 → 2.1.0

package/dist/domain/testing/prefer-vitest-incremental-casts/rule.input-shapes.js

@@ -0,0 +1,4 @@
+/** Suite name for the input-shape-focused companion spec. */
+const ruleInputShapesSuiteName = "prefer-vitest-incremental-casts rule input shapes";
+export { ruleInputShapesSuiteName };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5pbnB1dC1zaGFwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvcHJlZmVyLXZpdGVzdC1pbmNyZW1lbnRhbC1jYXN0cy9ydWxlLmlucHV0LXNoYXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw2REFBNkQ7QUFDN0QsTUFBTSx3QkFBd0IsR0FDNUIsbURBQW1ELENBQUM7QUFFdEQsT0FBTyxFQUFFLHdCQUF3QixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogU3VpdGUgbmFtZSBmb3IgdGhlIGlucHV0LXNoYXBlLWZvY3VzZWQgY29tcGFuaW9uIHNwZWMuICovXHJcbmNvbnN0IHJ1bGVJbnB1dFNoYXBlc1N1aXRlTmFtZSA9XHJcbiAgXCJwcmVmZXItdml0ZXN0LWluY3JlbWVudGFsLWNhc3RzIHJ1bGUgaW5wdXQgc2hhcGVzXCI7XHJcblxyXG5leHBvcnQgeyBydWxlSW5wdXRTaGFwZXNTdWl0ZU5hbWUgfTtcclxuIl19

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

@@ -0,0 +1,88 @@
+import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
+import { createRuleDocumentation } from "../../custom-rule-documentation.js";
+import { collectMatch } from "./match.js";
+/**
+ * Builds a map of namespace import aliases for the current source file.
+ * @param sourceCode Source code object from the ESLint rule context.
+ * @returns Map of module specifier to namespace alias name.
+ * @example
+ * ```typescript
+ * const namespaceImports = getNamespaceImports(context.sourceCode);
+ * ```
+ */
+function getNamespaceImports(sourceCode) {
+    const result = new Map();
+    for (const node of sourceCode.ast.body) {
+        if (node.type === TSESTree.AST_NODE_TYPES.ImportDeclaration &&
+            typeof node.source.value === "string") {
+            for (const specifier of node.specifiers) {
+                if (specifier.type === TSESTree.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                    result.set(node.source.value, specifier.local.name);
+                    break;
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Resolves TypeScript parser services when the rule runs on a typed file.
+ * @param context ESLint rule context.
+ * @returns Parser services when TypeScript services are available.
+ * @example
+ * ```typescript
+ * const services = getParserServices(context);
+ * ```
+ */
+function getParserServices(context) {
+    try {
+        return ESLintUtils.getParserServices(context);
+    }
+    catch {
+        return void 0;
+    }
+}
+/** Enforces minimal nested casts for `vi.mock` and `vi.doMock` factory objects. */
+const preferVitestIncrementalCastsRule = ESLintUtils.RuleCreator.withoutDocs({
+    create(context) {
+        const services = getParserServices(context);
+        if (services === void 0 || services.program === null) {
+            return {};
+        }
+        const checker = services.program.getTypeChecker();
+        const sourceText = context.sourceCode.text;
+        const namespaceImports = getNamespaceImports(context.sourceCode);
+        return {
+            CallExpression(node) {
+                const match = collectMatch({
+                    callExpression: node,
+                    checker,
+                    namespaceImports,
+                    services,
+                    sourceText,
+                });
+                if (match === void 0) {
+                    return;
+                }
+                context.report({
+                    fix: (fixer) => fixer.replaceTextRange(match.returnExpressionRange, match.replacementText),
+                    messageId: "preferVitestIncrementalCasts",
+                    node,
+                });
+            },
+        };
+    },
+    defaultOptions: [],
+    meta: {
+        docs: createRuleDocumentation("prefer-vitest-incremental-casts", "Prefer minimal nested casts in vi.mock/vi.doMock factory return objects when TypeScript rejects the module shape."),
+        fixable: "code",
+        messages: {
+            preferVitestIncrementalCasts: "Normalize the mock factory to the smallest stable set of nested casts needed for the module type.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+    name: "prefer-vitest-incremental-casts",
+});
+export { preferVitestIncrementalCastsRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/testing/prefer-vitest-incremental-casts/rule.signature-fallback.d.ts

@@ -0,0 +1,4 @@
+/** Suite name for the signature-fallback companion spec. */
+declare const ruleSignatureFallbackSuiteName = "prefer-vitest-incremental-casts rule signature fallback";
+export { ruleSignatureFallbackSuiteName };
+//# sourceMappingURL=rule.signature-fallback.d.ts.map

package/dist/domain/testing/prefer-vitest-incremental-casts/rule.signature-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.signature-fallback.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/rule.signature-fallback.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,QAAA,MAAM,8BAA8B,4DACuB,CAAC;AAE5D,OAAO,EAAE,8BAA8B,EAAE,CAAC"}

package/dist/domain/testing/prefer-vitest-incremental-casts/rule.signature-fallback.js

@@ -0,0 +1,4 @@
+/** Suite name for the signature-fallback companion spec. */
+const ruleSignatureFallbackSuiteName = "prefer-vitest-incremental-casts rule signature fallback";
+export { ruleSignatureFallbackSuiteName };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5zaWduYXR1cmUtZmFsbGJhY2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvcHJlZmVyLXZpdGVzdC1pbmNyZW1lbnRhbC1jYXN0cy9ydWxlLnNpZ25hdHVyZS1mYWxsYmFjay50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw0REFBNEQ7QUFDNUQsTUFBTSw4QkFBOEIsR0FDbEMseURBQXlELENBQUM7QUFFNUQsT0FBTyxFQUFFLDhCQUE4QixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogU3VpdGUgbmFtZSBmb3IgdGhlIHNpZ25hdHVyZS1mYWxsYmFjayBjb21wYW5pb24gc3BlYy4gKi9cclxuY29uc3QgcnVsZVNpZ25hdHVyZUZhbGxiYWNrU3VpdGVOYW1lID1cclxuICBcInByZWZlci12aXRlc3QtaW5jcmVtZW50YWwtY2FzdHMgcnVsZSBzaWduYXR1cmUgZmFsbGJhY2tcIjtcclxuXHJcbmV4cG9ydCB7IHJ1bGVTaWduYXR1cmVGYWxsYmFja1N1aXRlTmFtZSB9O1xyXG4iXX0=

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

@@ -0,0 +1,24 @@
+import type * as ts from "typescript";
+import type { OuterCastContext, ResolveFactoryTargetTypeContext } from "./types.js";
+/**
+ * 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);
+ * ```
+ */
+declare function isOuterCastRequired(context: OuterCastContext): boolean;
+/**
+ * Resolves the target type the factory object should satisfy.
+ * @param context Type-resolution inputs for the current mock factory.
+ * @returns Target type for the rewritten object literal.
+ * @example
+ * ```typescript
+ * const targetType = resolveFactoryTargetType(context);
+ * ```
+ */
+declare function resolveFactoryTargetType(context: ResolveFactoryTargetTypeContext): ts.Type | undefined;
+export { isOuterCastRequired, resolveFactoryTargetType };
+//# sourceMappingURL=type-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"type-helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/type-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAItC,OAAO,KAAK,EACV,gBAAgB,EAChB,+BAA+B,EAChC,MAAM,SAAS,CAAC;AA4KjB;;;;;;;;GAQG;AACH,iBAAS,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAE/D;AAED;;;;;;;;GAQG;AACH,iBAAS,wBAAwB,CAC/B,OAAO,EAAE,+BAA+B,GACvC,EAAE,CAAC,IAAI,GAAG,SAAS,CAKrB;AAED,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,CAAC"}

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

@@ -0,0 +1,113 @@
+import { SignatureKind } from "typescript";
+import { isOuterCastRequired as isOuterCastRequiredImpl, normalizeObjectLikeType, resolveFactoryReturnType, } from "./type-shape-helpers.js";
+/**
+ * Reads the contextual type assigned to the returned mock object literal.
+ * @param context Type-resolution inputs for the current mock factory.
+ * @returns Contextual object-like type when TypeScript provides one.
+ * @example
+ * ```typescript
+ * const targetType = getContextualFactoryTargetType(context);
+ * ```
+ */
+function getContextualFactoryTargetType(context) {
+    const { checker, objectExpression, services } = context;
+    return normalizeObjectLikeType(checker, checker.getContextualType(services.esTreeNodeToTSNodeMap.get(objectExpression)));
+}
+/**
+ * Resolves the factory return type for one compatible mock signature.
+ * @param context Inputs required to inspect one callable signature.
+ * @returns Normalized object-like return type when the signature matches.
+ * @example
+ * ```typescript
+ * const returnType = getMatchingSignatureReturnType(context);
+ * ```
+ */
+function getMatchingSignatureReturnType(context) {
+    const { checker, firstArgument, firstArgumentType, signature, tsFactoryArgument, } = context;
+    const [specifierParameter, factoryParameter] = signature.getParameters();
+    if (specifierParameter === void 0 || factoryParameter === void 0) {
+        return void 0;
+    }
+    const specifierParameterType = checker.getTypeOfSymbolAtLocation(specifierParameter, firstArgument);
+    if (!checker.isTypeAssignableTo(firstArgumentType, specifierParameterType)) {
+        return void 0;
+    }
+    return resolveFactoryReturnType(checker, checker.getTypeOfSymbolAtLocation(factoryParameter, tsFactoryArgument));
+}
+/**
+ * Resolves a target type by matching the mock call against callable signatures.
+ * @param context Type-resolution inputs for the current mock factory.
+ * @returns Object-like return type inferred from the matched signature.
+ * @example
+ * ```typescript
+ * const targetType = getSignatureFactoryTargetType(context);
+ * ```
+ */
+function getSignatureFactoryTargetType(context) {
+    const signatureMatchInputs = getSignatureMatchInputs(context);
+    if (signatureMatchInputs === void 0) {
+        return void 0;
+    }
+    for (const signature of context.checker.getSignaturesOfType(signatureMatchInputs.calleeType, SignatureKind.Call)) {
+        const returnType = getMatchingSignatureReturnType({
+            checker: context.checker,
+            firstArgument: signatureMatchInputs.firstArgument,
+            firstArgumentType: signatureMatchInputs.firstArgumentType,
+            signature,
+            tsFactoryArgument: signatureMatchInputs.tsFactoryArgument,
+        });
+        if (returnType !== void 0) {
+            return returnType;
+        }
+    }
+    return void 0;
+}
+/**
+ * Collects the TypeScript nodes and types needed for signature matching.
+ * @param context Type-resolution inputs for the current mock factory.
+ * @returns Normalized signature-matching inputs when the call has a first argument.
+ * @example
+ * ```typescript
+ * const inputs = getSignatureMatchInputs(context);
+ * ```
+ */
+function getSignatureMatchInputs(context) {
+    const tsCallExpression = context.services.esTreeNodeToTSNodeMap.get(context.callExpression);
+    const [firstArgument] = tsCallExpression.arguments;
+    if (firstArgument === void 0) {
+        return void 0;
+    }
+    return {
+        calleeType: context.checker.getTypeAtLocation(tsCallExpression.expression),
+        firstArgument,
+        firstArgumentType: context.checker.getTypeAtLocation(firstArgument),
+        tsFactoryArgument: context.services.esTreeNodeToTSNodeMap.get(context.factoryArgument),
+    };
+}
+/**
+ * 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) {
+    return isOuterCastRequiredImpl(context);
+}
+/**
+ * Resolves the target type the factory object should satisfy.
+ * @param context Type-resolution inputs for the current mock factory.
+ * @returns Target type for the rewritten object literal.
+ * @example
+ * ```typescript
+ * const targetType = resolveFactoryTargetType(context);
+ * ```
+ */
+function resolveFactoryTargetType(context) {
+    return (getContextualFactoryTargetType(context) ??
+        getSignatureFactoryTargetType(context));
+}
+export { isOuterCastRequired, resolveFactoryTargetType };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type-helpers.js","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/type-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as ts from \"typescript\";\r\n\r\nimport { SignatureKind } from \"typescript\";\r\n\r\nimport type {\r\n  OuterCastContext,\r\n  ResolveFactoryTargetTypeContext,\r\n} from \"./types\";\r\n\r\nimport {\r\n  isOuterCastRequired as isOuterCastRequiredImpl,\r\n  normalizeObjectLikeType,\r\n  resolveFactoryReturnType,\r\n} from \"./type-shape-helpers\";\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/** 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\r\n/**\r\n * Reads the contextual type assigned to the returned mock object literal.\r\n * @param context Type-resolution inputs for the current mock factory.\r\n * @returns Contextual object-like type when TypeScript provides one.\r\n * @example\r\n * ```typescript\r\n * const targetType = getContextualFactoryTargetType(context);\r\n * ```\r\n */\r\nfunction getContextualFactoryTargetType(\r\n  context: ResolveFactoryTargetTypeContext,\r\n): ts.Type | undefined {\r\n  const { checker, objectExpression, services } = context;\r\n\r\n  return normalizeObjectLikeType(\r\n    checker,\r\n    checker.getContextualType(\r\n      services.esTreeNodeToTSNodeMap.get(objectExpression),\r\n    ),\r\n  );\r\n}\r\n\r\n/**\r\n * Resolves the factory return type for one compatible mock signature.\r\n * @param context Inputs required to inspect one callable signature.\r\n * @returns Normalized object-like return type when the signature matches.\r\n * @example\r\n * ```typescript\r\n * const returnType = getMatchingSignatureReturnType(context);\r\n * ```\r\n */\r\nfunction getMatchingSignatureReturnType(\r\n  context: MatchingSignatureReturnTypeContext,\r\n): ts.Type | undefined {\r\n  const {\r\n    checker,\r\n    firstArgument,\r\n    firstArgumentType,\r\n    signature,\r\n    tsFactoryArgument,\r\n  } = context;\r\n  const [specifierParameter, factoryParameter] = signature.getParameters();\r\n\r\n  if (specifierParameter === void 0 || factoryParameter === void 0) {\r\n    return void 0;\r\n  }\r\n\r\n  const specifierParameterType = checker.getTypeOfSymbolAtLocation(\r\n    specifierParameter,\r\n    firstArgument,\r\n  );\r\n\r\n  if (!checker.isTypeAssignableTo(firstArgumentType, specifierParameterType)) {\r\n    return void 0;\r\n  }\r\n\r\n  return resolveFactoryReturnType(\r\n    checker,\r\n    checker.getTypeOfSymbolAtLocation(factoryParameter, tsFactoryArgument),\r\n  );\r\n}\r\n\r\n/**\r\n * Resolves a target type by matching the mock call against callable signatures.\r\n * @param context Type-resolution inputs for the current mock factory.\r\n * @returns Object-like return type inferred from the matched signature.\r\n * @example\r\n * ```typescript\r\n * const targetType = getSignatureFactoryTargetType(context);\r\n * ```\r\n */\r\nfunction getSignatureFactoryTargetType(\r\n  context: ResolveFactoryTargetTypeContext,\r\n): ts.Type | undefined {\r\n  const signatureMatchInputs = getSignatureMatchInputs(context);\r\n\r\n  if (signatureMatchInputs === void 0) {\r\n    return void 0;\r\n  }\r\n\r\n  for (const signature of context.checker.getSignaturesOfType(\r\n    signatureMatchInputs.calleeType,\r\n    SignatureKind.Call,\r\n  )) {\r\n    const returnType = getMatchingSignatureReturnType({\r\n      checker: context.checker,\r\n      firstArgument: signatureMatchInputs.firstArgument,\r\n      firstArgumentType: signatureMatchInputs.firstArgumentType,\r\n      signature,\r\n      tsFactoryArgument: signatureMatchInputs.tsFactoryArgument,\r\n    });\r\n\r\n    if (returnType !== void 0) {\r\n      return returnType;\r\n    }\r\n  }\r\n\r\n  return void 0;\r\n}\r\n\r\n/**\r\n * Collects the TypeScript nodes and types needed for signature matching.\r\n * @param context Type-resolution inputs for the current mock factory.\r\n * @returns Normalized signature-matching inputs when the call has a first argument.\r\n * @example\r\n * ```typescript\r\n * const inputs = getSignatureMatchInputs(context);\r\n * ```\r\n */\r\nfunction getSignatureMatchInputs(\r\n  context: ResolveFactoryTargetTypeContext,\r\n): SignatureMatchInputs | undefined {\r\n  const tsCallExpression = context.services.esTreeNodeToTSNodeMap.get(\r\n    context.callExpression,\r\n  );\r\n  const [firstArgument] = tsCallExpression.arguments;\r\n\r\n  if (firstArgument === void 0) {\r\n    return void 0;\r\n  }\r\n\r\n  return {\r\n    calleeType: context.checker.getTypeAtLocation(tsCallExpression.expression),\r\n    firstArgument,\r\n    firstArgumentType: context.checker.getTypeAtLocation(firstArgument),\r\n    tsFactoryArgument: context.services.esTreeNodeToTSNodeMap.get(\r\n      context.factoryArgument,\r\n    ),\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  return isOuterCastRequiredImpl(context);\r\n}\r\n\r\n/**\r\n * Resolves the target type the factory object should satisfy.\r\n * @param context Type-resolution inputs for the current mock factory.\r\n * @returns Target type for the rewritten object literal.\r\n * @example\r\n * ```typescript\r\n * const targetType = resolveFactoryTargetType(context);\r\n * ```\r\n */\r\nfunction resolveFactoryTargetType(\r\n  context: ResolveFactoryTargetTypeContext,\r\n): ts.Type | undefined {\r\n  return (\r\n    getContextualFactoryTargetType(context) ??\r\n    getSignatureFactoryTargetType(context)\r\n  );\r\n}\r\n\r\nexport { isOuterCastRequired, resolveFactoryTargetType };\r\n"]}

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

@@ -0,0 +1,36 @@
+import type * as ts from "typescript";
+import type { OuterCastContext } from "./types.js";
+/**
+ * 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);
+ * ```
+ */
+declare function isOuterCastRequired(context: OuterCastContext): boolean;
+/**
+ * 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);
+ * ```
+ */
+declare function normalizeObjectLikeType(checker: ts.TypeChecker, targetType: ts.Type | undefined): ts.Type | undefined;
+/**
+ * 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);
+ * ```
+ */
+declare function resolveFactoryReturnType(checker: ts.TypeChecker, factoryParameterType: ts.Type): ts.Type | undefined;
+export { isOuterCastRequired, normalizeObjectLikeType, resolveFactoryReturnType, };
+//# sourceMappingURL=type-shape-helpers.d.ts.map

package/dist/domain/testing/prefer-vitest-incremental-casts/type-shape-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-shape-helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/prefer-vitest-incremental-casts/type-shape-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAYtC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAoGhD;;;;;;;;GAQG;AACH,iBAAS,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAoB/D;AAED;;;;;;;;;GASG;AACH,iBAAS,uBAAuB,CAC9B,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,UAAU,EAAE,EAAE,CAAC,IAAI,GAAG,SAAS,GAC9B,EAAE,CAAC,IAAI,GAAG,SAAS,CAqBrB;AAED;;;;;;;;;GASG;AACH,iBAAS,wBAAwB,CAC/B,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,oBAAoB,EAAE,EAAE,CAAC,IAAI,GAC5B,EAAE,CAAC,IAAI,GAAG,SAAS,CAgBrB;AAED,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACvB,wBAAwB,GACzB,CAAC"}

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