I am looking to create a reusable RxJS operator that can map from object T to Q. This will be used to convert dates formats. T & Q are therefore different types but only in regard to the properties, the keys remain the same for both.

我希望创建一个可重复使用的RxJS操作符，可以从对象T映射到Q。这将用于转换日期格式。因此，T&Q是不同的类型，但仅就属性而言，两者的键保持相同。

I think for the most part I am there but running into some typing issues that I can't resolve.

我想在很大程度上我在那里，但遇到了一些我无法解决的打字问题。

export function convertDateTimeToluxon<T extends object, Q extends Record<keyof T, any>>(): (source: Observable<T>) => Observable<Q> {
    return (source: Observable<T>): Observable<Q> => source.pipe(
        map((object: T): Q => {
            const convertedObj: Q = {} as Q;
            Object.keys(object).forEach((key: string) => {
                const typedKeyT: keyof T = key as keyof T;
                if(Datetime.isDateTime(object[typedKeyT])) {
                    convertedObj[typedKeyT] = DateTime.fromISO(object[typedKeyT]);
                } else {
                    convertedObj[typedKeyT] = object[typedKeyT];
                }
            })
            return convertedObj;
        })
    )
}
}

The issue occurs on the 2 assignment lines

问题发生在两个分配行上

convertedObj[typedKeyT] = DateTime.fromISO(object[typedKeyT]);
convertedObj[typedKeyT] = object[typedKeyT];

转换对象[类型键T]=DateTime.FromISO(对象[类型键T])；转换对象[类型键T]=对象[类型键T]；

Where TypeScript is complaining that T[key of T] is not assignable to Q[key of T] - I assume this is to do with the any type in the record at the top?

TypeScrip抱怨T[T的键]不能分配给Q[T的键]-我假设这与顶部记录中的Any类型有关？

Answer - this is what i have come up with for the time being, sure it could be improved!

回答--这就是我目前所想出来的，当然可以改进！

Part of this is taken from geoffreys answer below

这部分摘自Geoffreys下面的回答

export function convertDateTimeToLuxon<T extends Record<keyof T, any>, Q extends Record<keyof T, any>>(): (source: Observable<T>) => Observable<Q> {
    return (source: Observable<T>): Observable<Q> => source.pipe(
        map((object: T): Q => {
            const convertedObj: Q = {} as Q;
            Object.keys(object).forEach((key) => {
                const typedKeyT: keyof T = key as keyof T;
                if (DateTime.isDateTime(object[typedKeyT])) {
                    convertedObj[typedKeyT] = DateTime.fromISO(object[typedKeyT]) as Q[keyof T];
                } else {
                    convertedObj[typedKeyT] = object[typedKeyT];
                }
            })
            return convertedObj;
        })
    )
}

T extends Record<PropertyKey, any> solves it. (I also removed unnecessary annotations in a few places):

T扩展记录 解决它。(我还删除了几处不必要的注释)：

function convertDateTimeToluxon <T extends Record<PropertyKey, any>, Q extends Record<keyof T, any>>() {
    return (source: Observable<T>): Observable<Q> => source.pipe(
        map((object: T) => {
            const convertedObj = {} as Q;
            Object.keys(object).forEach((key: string) => {
                const typedKeyT = key as keyof T;
                if(Datetime.isDateTime(object[typedKeyT])) {
                    convertedObj[typedKeyT] = DateTime.fromISO(object[typedKeyT]);
                } else {
                    convertedObj[typedKeyT] = object[typedKeyT];
                }
            })
            return convertedObj;
        })
    );
}

I'm not sure why this works though. I noticed that object was generally requiring more annotations.

不过，我不确定这为什么会奏效。我注意到该对象通常需要更多的注释。