Generics inside if not taking the proper type

I'm trying to achieve a function that serialize everything that is a Map class to an object. What I meant with that is: I'm trying to create a function that if receives an object will check every attribute and if some of them is a Map it will return an object there. Also in case that the function receives an Array of Map will return an Array of objects.

I have created this types:

type InputMapToObject =
    | Map<keyof any, unknown>
    | Record<keyof any, unknown>
    | unknown[];

type ReturnMapToObject<T extends InputMapToObject> = T extends Map<
    infer KMap extends keyof any,
    infer VMap
>
    ? Record<
          KMap,
          VMap extends InputMapToObject ? ReturnMapToObject<VMap> : VMap
      >
    : T extends object
    ? {
          [P in keyof T]: T[P] extends InputMapToObject
              ? ReturnMapToObject<T[P]>
              : T[P];
      }
    : T extends (infer VArray)[]
    ? VArray extends InputMapToObject
        ? ReturnMapToObject<VArray>[]
        : VArray[]
    : never;

This type works perfect, here a test where you can see that the type is working:

interface TestingType {
    testMap: Map<string, number>;
    testArray: Array<number>;
    testArray2: Array<Map<string, string>>;
}

const test: ReturnMapToObject<TestingType> = {
    testMap: {
        string: 0,
    },
    testArray: [0],
    testArray2: [{ string: 'string' }],
};

The problem that I have is on the function mapToObject (the other functions are just helpers):

export function mapToObject<T extends InputMapToObject>(
    itemToConvert: T
): ReturnMapToObject<T> {
    if (itemToConvert instanceof Map) {
        return [...itemToConvert.entries()].reduce((acc, [key, value]) => {
            acc[key] = value;
            return acc;
        }, {} as ReturnMapToObject<T>);
    }

    if (Array.isArray(itemToConvert)) {
        return itemToConvert.map((item) => {
            if (isRecursiveValue(item)) {
                return mapToObject(item);
            }
            return item;
        });
    }

    return getObjectEntries(itemToConvert).reduce((acc, [key, value]) => {
        if (isRecursiveValue(value)) {
            acc[key] = mapToObject(value);
        } else {
            acc[key] = value;
        }

        return acc;
    }, {} as ReturnMapToObject<T>);
}

function isRecursiveValue(item: any): item is InputMapToObject {
    if (item instanceof Map) return true;
    if (Array.isArray(item)) return true;
    if (item && typeof item === 'object') return true;
    return false;
}

function getObjectEntries<T extends Record<any, any>>(
    value: T
): [keyof any, T[keyof T]][] {
    return Object.entries(value) as [keyof any, T[keyof T]][];
}

I think the function mapToObject would work as expected with JavaScript, but I'm having type errors. For example I do have an error on the first reducer.If the input is a Map then I use the reduce method to convert the entries to a object. The problem there is that I try to type the initial object, so I do as ReturnMapToObject<T> but TypeScript is interpreting as that T could be anything but not, it can only be a Map.

This is the error that I'm getting doing acc[key] = value:

Element implicitly has an 'any' type because expression of type 'string | number | symbol' can't be used to index type 'object | unknown[] | Record<string | number | symbol, unknown>'.
  No index signature with a parameter of type 'string' was found on type 'object | unknown[] | Record<string | number | symbol, unknown>'.ts(7053)
(parameter) acc: object | unknown[] | Record<string | number | symbol, unknown>

If TypeScript would recognize properly that T inside the Map instance if acc would be: Record<string | number | symbol, unknown> because as it's defined on the ReturnMapToObject if T extends Map then it will return a Record.

TypeScript can't narrow or re-constrain generic type parameters via control flow analysis. So when you check, for example, itemToConvert instanceof Map, the apparent type of itemToConvert can be narrowed from T to (something like) T & Map, but the type parameter T itself stays the same.

This is for a good reason: you can think of a type as something like the set of all possible acceptable values. Let's take the type string. If I say that the value s is of generic type S extends string, and I check that s === "abc", now I know that the value s is "abc", but I really don't know anything more about the type S. Maybe S is the string literal type "abc", or maybe it's a union of such types like "abc" | "def" | "ghi", or maybe it's string. All of those would be consistent with s === "abc". It's like if I pull a marble (value) out of a bag (type) and then check the color of the marble, that tells me a lot about the marble, and very little about the bag and the colors of marbles it contains.

So you can't just "narrow" a generic type parameter the way you narrow the apparent type of a value, at least not without adding new features to the language. One such feature is requested at microsoft/TypeScript#27808, in which you'd be able to say something like T oneof InputMapToObject meaning that T is known to be exactly one of the (presumed mutually exclusive) union members of InputMapToObject. Then when you check whether itemToConvert instanceof Map, you can say that T itself is either Map<keyof any, unknown> or oneof Record<keyof any, unknown> | unknown[], and the rest of the code might compile as intended. But for now it's not part of the language.

This limitation is really obvious and painful when you try to implement a generic function that returns a conditional type depending on the generic type parameters, like you're doing with ReturnMapToObject<T>. There's another open feature request for generic conditional function implementations at microsoft/TypeScript#33912, and again, it's not yet part of the langauge.

Until and unless something changes here, you'll have to work around it. Assuming you don't want to completely refactor things, the most expedient workaround is to use something like type assertions to just tell the compiler not to complain. This is reasonable if you're sure that the implementation is correct but the compiler isn't... and it also means you need to be careful, since the compiler can't catch your mistakes if you do this.

Here's one way to do the assertions:

export function mapToObject<T extends InputMapToObject>(
    itemToConvert: T
): ReturnMapToObject<T> {
    if (itemToConvert instanceof Map) {
        return [...itemToConvert.entries()].reduce((acc, [key, value]) => {
            acc[key] = value;
            return acc;
        }, {} as any); // <-- just use any
    }

    if (Array.isArray(itemToConvert)) {
        return itemToConvert.map((item) => {
            if (isRecursiveValue(item)) {
                return mapToObject(item);
            }
            return item;
        }) as ReturnMapToObject<T>; // <-- just assert
    }

    return getObjectEntries(itemToConvert).reduce((acc, [key, value]) => {
        if (isRecursiveValue(value)) {
            acc[key] = mapToObject(value);
        } else {
            acc[key] = value;
        }

        return acc;
    }, {} as any); // just use any
}

You could try more accurate types other than the any type, which might catch some egregious errors. And/or you could make your function a single-call-signature overload which also allows a looser implementation than the call signature(s):

function mapToObject<T extends InputMapToObject>(
    itemToConvert: T
): ReturnMapToObject<T>;

function mapToObject<T extends InputMapToObject>(itemToConvert: T):
    ReturnMapToObject<InputMapToObject> {

    if (itemToConvert instanceof Map) {
        return [...itemToConvert.entries()].
            reduce<Record<keyof any, unknown>>((acc, [key, value]) => {
                acc[key] = value;
                return acc;
            }, {});
    }

    if (Array.isArray(itemToConvert)) {
        return itemToConvert.map((item) => {
            if (isRecursiveValue(item)) {
                return mapToObject(item);
            }
            return item;
        })
    }

    return getObjectEntries(itemToConvert).
        reduce<Record<keyof any, unknown>>((acc, [key, value]) => {
            if (isRecursiveValue(value)) {
                acc[key] = mapToObject(value);
            } else {
                acc[key] = value;
            }
            return acc;
        }, {});
}

There are any of a number of such workarounds, but if you want to keep your current implementation, all of them will require that you loosen some of the type checking to avoid these (presumably) false warnings.

Playground link to code