@codeperfect/eslint-plugin 2.0.0 → 2.2.0

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

@@ -1,62 +0,0 @@
-import { ESLintUtils } from "@typescript-eslint/utils";
-import { createRuleDocumentation } from "../../custom-rule-documentation.js";
-import { collectMatch } from "./match.js";
-/**
- * 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;
-        return {
-            CallExpression(node) {
-                const match = collectMatch({
-                    callExpression: node,
-                    checker,
-                    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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kb21haW4vdGVzdGluZy9wcmVmZXItdml0ZXN0LWluY3JlbWVudGFsLWNhc3RzL3J1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBU3ZELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQzFFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFFdkM7Ozs7Ozs7O0dBUUc7QUFDSCxTQUFTLGlCQUFpQixDQUN4QixPQUF5QjtJQUV6QixJQUFJLENBQUM7UUFDSCxPQUFPLFdBQVcsQ0FBQyxpQkFBaUIsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNoRCxDQUFDO0lBQUMsTUFBTSxDQUFDO1FBQ1AsT0FBTyxLQUFLLENBQUMsQ0FBQztJQUNoQixDQUFDO0FBQ0gsQ0FBQztBQUVELG1GQUFtRjtBQUNuRixNQUFNLGdDQUFnQyxHQUFHLFdBQVcsQ0FBQyxXQUFXLENBQUMsV0FBVyxDQUcxRTtJQUNBLE1BQU0sQ0FBQyxPQUFPO1FBQ1osTUFBTSxRQUFRLEdBQUcsaUJBQWlCLENBQUMsT0FBTyxDQUFDLENBQUM7UUFFNUMsSUFBSSxRQUFRLEtBQUssS0FBSyxDQUFDLElBQUksUUFBUSxDQUFDLE9BQU8sS0FBSyxJQUFJLEVBQUUsQ0FBQztZQUNyRCxPQUFPLEVBQUUsQ0FBQztRQUNaLENBQUM7UUFFRCxNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMsT0FBTyxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBQ2xELE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDO1FBRTNDLE9BQU87WUFDTCxjQUFjLENBQUMsSUFBSTtnQkFDakIsTUFBTSxLQUFLLEdBQUcsWUFBWSxDQUFDO29CQUN6QixjQUFjLEVBQUUsSUFBSTtvQkFDcEIsT0FBTztvQkFDUCxRQUFRO29CQUNSLFVBQVU7aUJBQ1gsQ0FBQyxDQUFDO2dCQUVILElBQUksS0FBSyxLQUFLLEtBQUssQ0FBQyxFQUFFLENBQUM7b0JBQ3JCLE9BQU87Z0JBQ1QsQ0FBQztnQkFFRCxPQUFPLENBQUMsTUFBTSxDQUFDO29CQUNiLEdBQUcsRUFBRSxDQUFDLEtBQUssRUFBRSxFQUFFLENBQ2IsS0FBSyxDQUFDLGdCQUFnQixDQUNwQixLQUFLLENBQUMscUJBQXFCLEVBQzNCLEtBQUssQ0FBQyxlQUFlLENBQ3RCO29CQUNILFNBQVMsRUFBRSw4QkFBOEI7b0JBQ3pDLElBQUk7aUJBQ0wsQ0FBQyxDQUFDO1lBQ0wsQ0FBQztTQUNGLENBQUM7SUFDSixDQUFDO0lBQ0QsY0FBYyxFQUFFLEVBQUU7SUFDbEIsSUFBSSxFQUFFO1FBQ0osSUFBSSxFQUFFLHVCQUF1QixDQUMzQixpQ0FBaUMsRUFDakMsbUhBQW1ILENBQ3BIO1FBQ0QsT0FBTyxFQUFFLE1BQU07UUFDZixRQUFRLEVBQUU7WUFDUiw0QkFBNEIsRUFDMUIsbUdBQW1HO1NBQ3RHO1FBQ0QsTUFBTSxFQUFFLEVBQUU7UUFDVixJQUFJLEVBQUUsWUFBWTtLQUNuQjtJQUNELElBQUksRUFBRSxpQ0FBaUM7Q0FDeEMsQ0FBK0IsQ0FBQztBQUVqQyxPQUFPLEVBQUUsZ0NBQWdDLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUnVsZSB9IGZyb20gXCJlc2xpbnRcIjtcblxuaW1wb3J0IHsgRVNMaW50VXRpbHMgfSBmcm9tIFwiQHR5cGVzY3JpcHQtZXNsaW50L3V0aWxzXCI7XG5cbmltcG9ydCB0eXBlIHtcbiAgTWVzc2FnZUlkcyxcbiAgT3B0aW9ucyxcbiAgUGFyc2VyU2VydmljZXMsXG4gIFR5cGVkUnVsZUNvbnRleHQsXG59IGZyb20gXCIuL3R5cGVzXCI7XG5cbmltcG9ydCB7IGNyZWF0ZVJ1bGVEb2N1bWVudGF0aW9uIH0gZnJvbSBcIi4uLy4uL2N1c3RvbS1ydWxlLWRvY3VtZW50YXRpb25cIjtcbmltcG9ydCB7IGNvbGxlY3RNYXRjaCB9IGZyb20gXCIuL21hdGNoXCI7XG5cbi8qKlxuICogUmVzb2x2ZXMgVHlwZVNjcmlwdCBwYXJzZXIgc2VydmljZXMgd2hlbiB0aGUgcnVsZSBydW5zIG9uIGEgdHlwZWQgZmlsZS5cbiAqIEBwYXJhbSBjb250ZXh0IEVTTGludCBydWxlIGNvbnRleHQuXG4gKiBAcmV0dXJucyBQYXJzZXIgc2VydmljZXMgd2hlbiBUeXBlU2NyaXB0IHNlcnZpY2VzIGFyZSBhdmFpbGFibGUuXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogY29uc3Qgc2VydmljZXMgPSBnZXRQYXJzZXJTZXJ2aWNlcyhjb250ZXh0KTtcbiAqIGBgYFxuICovXG5mdW5jdGlvbiBnZXRQYXJzZXJTZXJ2aWNlcyhcbiAgY29udGV4dDogVHlwZWRSdWxlQ29udGV4dCxcbik6IFBhcnNlclNlcnZpY2VzIHwgdW5kZWZpbmVkIHtcbiAgdHJ5IHtcbiAgICByZXR1cm4gRVNMaW50VXRpbHMuZ2V0UGFyc2VyU2VydmljZXMoY29udGV4dCk7XG4gIH0gY2F0Y2gge1xuICAgIHJldHVybiB2b2lkIDA7XG4gIH1cbn1cblxuLyoqIEVuZm9yY2VzIG1pbmltYWwgbmVzdGVkIGNhc3RzIGZvciBgdmkubW9ja2AgYW5kIGB2aS5kb01vY2tgIGZhY3Rvcnkgb2JqZWN0cy4gKi9cbmNvbnN0IHByZWZlclZpdGVzdEluY3JlbWVudGFsQ2FzdHNSdWxlID0gRVNMaW50VXRpbHMuUnVsZUNyZWF0b3Iud2l0aG91dERvY3M8XG4gIE9wdGlvbnMsXG4gIE1lc3NhZ2VJZHNcbj4oe1xuICBjcmVhdGUoY29udGV4dCkge1xuICAgIGNvbnN0IHNlcnZpY2VzID0gZ2V0UGFyc2VyU2VydmljZXMoY29udGV4dCk7XG5cbiAgICBpZiAoc2VydmljZXMgPT09IHZvaWQgMCB8fCBzZXJ2aWNlcy5wcm9ncmFtID09PSBudWxsKSB7XG4gICAgICByZXR1cm4ge307XG4gICAgfVxuXG4gICAgY29uc3QgY2hlY2tlciA9IHNlcnZpY2VzLnByb2dyYW0uZ2V0VHlwZUNoZWNrZXIoKTtcbiAgICBjb25zdCBzb3VyY2VUZXh0ID0gY29udGV4dC5zb3VyY2VDb2RlLnRleHQ7XG5cbiAgICByZXR1cm4ge1xuICAgICAgQ2FsbEV4cHJlc3Npb24obm9kZSk6IHZvaWQge1xuICAgICAgICBjb25zdCBtYXRjaCA9IGNvbGxlY3RNYXRjaCh7XG4gICAgICAgICAgY2FsbEV4cHJlc3Npb246IG5vZGUsXG4gICAgICAgICAgY2hlY2tlcixcbiAgICAgICAgICBzZXJ2aWNlcyxcbiAgICAgICAgICBzb3VyY2VUZXh0LFxuICAgICAgICB9KTtcblxuICAgICAgICBpZiAobWF0Y2ggPT09IHZvaWQgMCkge1xuICAgICAgICAgIHJldHVybjtcbiAgICAgICAgfVxuXG4gICAgICAgIGNvbnRleHQucmVwb3J0KHtcbiAgICAgICAgICBmaXg6IChmaXhlcikgPT5cbiAgICAgICAgICAgIGZpeGVyLnJlcGxhY2VUZXh0UmFuZ2UoXG4gICAgICAgICAgICAgIG1hdGNoLnJldHVybkV4cHJlc3Npb25SYW5nZSxcbiAgICAgICAgICAgICAgbWF0Y2gucmVwbGFjZW1lbnRUZXh0LFxuICAgICAgICAgICAgKSxcbiAgICAgICAgICBtZXNzYWdlSWQ6IFwicHJlZmVyVml0ZXN0SW5jcmVtZW50YWxDYXN0c1wiLFxuICAgICAgICAgIG5vZGUsXG4gICAgICAgIH0pO1xuICAgICAgfSxcbiAgICB9O1xuICB9LFxuICBkZWZhdWx0T3B0aW9uczogW10sXG4gIG1ldGE6IHtcbiAgICBkb2NzOiBjcmVhdGVSdWxlRG9jdW1lbnRhdGlvbihcbiAgICAgIFwicHJlZmVyLXZpdGVzdC1pbmNyZW1lbnRhbC1jYXN0c1wiLFxuICAgICAgXCJQcmVmZXIgbWluaW1hbCBuZXN0ZWQgY2FzdHMgaW4gdmkubW9jay92aS5kb01vY2sgZmFjdG9yeSByZXR1cm4gb2JqZWN0cyB3aGVuIFR5cGVTY3JpcHQgcmVqZWN0cyB0aGUgbW9kdWxlIHNoYXBlLlwiLFxuICAgICksXG4gICAgZml4YWJsZTogXCJjb2RlXCIsXG4gICAgbWVzc2FnZXM6IHtcbiAgICAgIHByZWZlclZpdGVzdEluY3JlbWVudGFsQ2FzdHM6XG4gICAgICAgIFwiTm9ybWFsaXplIHRoZSBtb2NrIGZhY3RvcnkgdG8gdGhlIHNtYWxsZXN0IHN0YWJsZSBzZXQgb2YgbmVzdGVkIGNhc3RzIG5lZWRlZCBmb3IgdGhlIG1vZHVsZSB0eXBlLlwiLFxuICAgIH0sXG4gICAgc2NoZW1hOiBbXSxcbiAgICB0eXBlOiBcInN1Z2dlc3Rpb25cIixcbiAgfSxcbiAgbmFtZTogXCJwcmVmZXItdml0ZXN0LWluY3JlbWVudGFsLWNhc3RzXCIsXG59KSBhcyB1bmtub3duIGFzIFJ1bGUuUnVsZU1vZHVsZTtcblxuZXhwb3J0IHsgcHJlZmVyVml0ZXN0SW5jcmVtZW50YWxDYXN0c1J1bGUgfTtcbiJdfQ==

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

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

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

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

@@ -1,24 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,EAEV,gBAAgB,EAChB,+BAA+B,EAEhC,MAAM,SAAS,CAAC;AA2IjB;;;;;;;;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

@@ -1,113 +0,0 @@
-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  MatchingSignatureReturnTypeContext,\r\n  OuterCastContext,\r\n  ResolveFactoryTargetTypeContext,\r\n  SignatureMatchInputs,\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/**\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

@@ -1,36 +0,0 @@
-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

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

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