mapValues.ts

/**
 * Recursively maps values of an object
 *
 * @param object the target object
 * @param transformation a mapping function, which is applied recursively to the deepest values
 */
function mapValues<O, K extends keyof O, R>(object: O, transformation: RecursiveTransform<O[K], R>): MappedObject<O, R> {
    return Object.entries(object).reduce((prev, [key, value]) => {
        prev[key] = typeof value === 'object' ? mapValues(value, transformation) : transformation(value);
        return prev;
    }, {} as any)
}

type MappedObject<O, R> = { [key in keyof O]: ResultValue<O, key, R>}

type RecursiveTransform<V, R> = (value: NestedValue<V>) => R

type NestedValue<V> = V extends {[p: string]: infer U}
    ? NestedValue<U>
    : V

type ResultValue<O, K extends keyof O, R> = O[K] extends {[p: string]: infer U}
    ? { [key in keyof O[K]]: ResultValue<O[K], key, R>}
    : R

// example

const foo = {
    bar: 'hello',
    baz: 1,
    qux: {
        a: 'a',
    }
}

const result = mapValues(foo, (value) => typeof value === 'number' ? value : value.length)
// typeof result === { bar: number, baz: number, qux: { a: number } }

console.log(result)