If you want to achieve strict typing on overload definitions and looser types on the implementation signature, consider using function overloads combined with generics. This way, you can maintain good type safety even without passing in the object being updated as an argument. However, keep in mind that altering the signature for the implementation won't be possible without casting it to a looser type.
Here's an example of how this approach could work:
function updateWidget<K extends keyof Widget>(
key: K,
value: Widget[K],
property: false,
): Widget;
function updateWidget<K extends keyof Widget["properties"]>(
key: K,
value: Widget["properties"],
property: true,
): Widget;
function updateWidget(
key: string,
value: unknown,
property: boolean,
) {
if (property) {
widget.properties[key] = value;
} else {
(widget as Record<string,unknown>)[key] = value;
}
return widget;
}
Using a flag like 'property' to determine which properties to access may not be the most straightforward solution, and managing the typings can become cumbersome.
Instead, consider a generic update object function like this:
type Obj = Record<PropertyKey, unknown>;
const update =
<T extends Obj>(obj: T) =>
<K extends keyof T>(key: K, value: T[K] | ((current: T[K]) => T[K])) => {
const current = obj[key];
if (value instanceof Function) {
return { ...obj, [key]: value(current) };
}
return { ...obj, [key]: value };
};
You can then call this function like so:
const updated = update(widget)('properties',(p)=>({...p, 'any':5}))
This method is versatile and can be used for other objects as well. You can chain updates like this:
const next = update(widget)("properties", (p) => update(p)("field", "value"));
For further experimentation, check out the playground.