我正在尝试实现一个函数，该函数将Map类的所有内容序列化为对象。我的意思是我试图创建一个函数，如果接收到一个对象，它将检查每个属性，如果其中一些是一个Map，它将返回一个对象。同样，如果函数接收到一个Map数组，将返回一个对象数组。
我创建了这些类型：

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;

这种类型的作品完美，这里的测试，你可以看到，类型的工作：

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' }],
};

我遇到的问题是在函数mapToObject上（其他函数只是助手）：

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]][];
}

我认为函数mapToObject在JavaScript中可以正常工作，但是我遇到了类型错误。例如，我在第一个reducer上有一个错误，如果输入是一个Map，那么我使用reduce方法将条目转换为对象。这里的问题是，我试图输入初始对象，所以我是ReturnMapToObject<T>，但TypeScript解释为T可以是任何东西，但不是，它只能是一个Map。
这是我在执行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>

如果TypeScript正确识别Map示例中的T，如果acc为：Record<string | number | symbol, unknown>，因为它在ReturnMapToObject上定义，如果T扩展Map，那么它将返回一个Record。