I have this type.
type Deposit {
num1: number;
num2: number;
}
type Nice {
num: number;
deposit: Deposit;
}
Now, I use Nice, but I need to somehow extend it and I want its deposit to be including more fields. In the end, like this:
type Deposit {
num1: number;
num2: number;
num3: string;
num4: string;
}
type Nice {
num: number;
deposit: Deposit;
}
But, I can't change Deposit or Nice types since they come from the library.
You can create a custom child type using the extends keyword and just place it in a common types.ts file, then import the type from there instead of importing it from the library directly.
// src/types.ts
import { Deposit as DepositBase, Nice as NiceBase } from 'some-lib';
export interface Deposit extends DepositBase {
num3: string;
num4: string;
}
export interface Nice extends NiceBase {
deposit: Deposit;
}
Then, to use it:
// src/some-lib-wrapper.ts
import * as someLib from 'some-lib';
import { Deposit, Nice } from './types'; // our extended types
// you can "re-type" the library functions in this wrapper module
// to use our custom extended types
export function makeDeposit(nice: Nice): Deposit {
/* call someLib.makeDeposit here... */
}
// src/index.ts
import { makeDeposit } from './some-lib-wrapper'; // use the wrapped version
// with our extended types
import { Deposit, Nice } from './types';
// use your custom wrapped functions & types
makeDeposit(...);
interface DepositExtended { deposit: Deposit; extra: { num3: string; num4: string } }, but I think as long as the extended types are purely additive (they're not removing/overwriting library types with more strict types) it should be safe to use extends as shown above.You can use helper type for extending existing property:
type Deposit = {
num1: number;
num2: number;
}
type Nice = {
num: number;
deposit: Deposit;
}
type ExtendProp<Obj, Prop, NewValue> = {
[P in keyof Obj]: P extends Prop ? Obj[P] & NewValue : Obj[P]
}
type Result = ExtendProp<Nice, 'deposit', { foo: 'bar' }> // { deposit: Deposit & { foo: 'bar'; };
