Typescript merge deep function without type 'any'

How to convert [this answer][1] to typescript without using the type 'any'?

Currently (not working) try:

export function isObject(item: object): boolean {
return !!item && typeof item === "object" && !Array.isArray(item);
}
export function mergeDeep(target: object, ...sources: object[]): object {
if (!sources?.length) return target;
const source = sources.shift();
if (isObject(target) && isObject(source)) {
for (const key in source) {
const sk = source[key];
if (isObject(sk)) {
if (!target[key]) Object.assign(target, { [key]: {} });
mergeDeep(target[key], sk);
} else {
Object.assign(target, { [key]: source[key] });
}
}
}
return mergeDeep(target, ...sources);
}
const obj1 = {
one: {
two: {
keep: "yes!",
change: "should not see me",
},
three: {
four: {
keep: "yes!",
change: "should not see me",
},
},
},
};
const obj2 = {
one: {
two: {
change: "NICE 1!!",
},
three: {
four: {
change: "NICE 2!!",
},
},
},
};
console.log(JSON.stringify(mergeDeep(obj1, obj2), null, 2));

If you don't really care about using very strong types and you just want to get things to compile without the unsafe any type, you can use the safer unknown type. And for isObject() you can mark it as a custom type guard function, so that the result will narrow the input to an object type which allows any property key to be accessed:

function isObject(item: unknown): item is Record<string, unknown> {
return !!item && typeof item === "object" && !Array.isArray(item);
}
function mergeDeep(target: unknown, ...sources: unknown[]): unknown {
if (!sources?.length) return target;
const source = sources.shift();
if (isObject(target) && isObject(source)) {
for (const key in source) {
const sk = source[key];
if (isObject(sk)) {
let tk = target[key];
if (!tk) tk = target[key] = {};
mergeDeep(tk, sk);
} else {
Object.assign(target, { [key]: source[key] });
}
}
}
return mergeDeep(target, ...sources);
}

That's pretty much the same thing but I changed target[key] to a saved tk variable because the compiler can't easily tell what happens to an indexed access like that if the key is an arbitrary string. See microsoft/TypeScript#10530 for the relevant open issue about that.

Note that when you're done, the output is just of type unknown. You might want the output type to be something more closely tied to the input, so that, for example, mergeDeep({a: 123}).a is known to exist and be of type number. But that's out of scope for the question as asked.

Playground link to code