TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
Foo to be parameterized for the MapArgs. I came up with a solution like this but is there a nicer way?
- Mapped types work over tuples, which is great, but they have to be "homomorphic" or it will get weird, i.e.
{ [K in keyof T]: whatever }
- You need the
& keyof Tto let TS know that you can indexTwith the type you get from your mapping. This has the handy side-effect of turning bad keys intonever. However, the constraint onKin the function is enough to give you an error if you try to use the wrong key.
interface LoginFormStateType {
account: { username: string; password: string };
errors: { [key in LoginFormStateType['account']]?: string };
}The error this gives is that
Type '{ username: string; password: string; }' is not assignable to type 'string | number | symbol'.keyof in your mapped type index
foo(obj, 'deep', 'nested', 'child'). I solved that by having a bunch of overloads for different nested levels, like:const foo = <T, K1 extends keyof T, K2 extends keyof T[K1], K3 extends keyof T[K1][K2]>(obj: T, k1: K1, k2: K2, k3: K3)Is there a way to do recursive look-ups like this without overloading?
Howdy!!! I usually find a way to hack things in typescript and this is the first one I've really gotten stuck on. I'm assuming it's going to be a "doh" moment and I just don't know wha to search for.
Let's say you have a merchant who sells items. All possible items are known, so we represent those as an enum:
enum Items {
Necklace = "Necklace",
GolfBall = "GolfBall",
Yarn = "Yarn",
}Each merchant has a subset of items, and for each of those they have a price and a variant. But let's say you're adding types to an existing project, and need to define the types for something that looks like this:
const merchant = {
prices: {
[Items.Necklace]: 50,
},
variants: {
[Items.Necklace]: "Gold",
},
}Basically, both prices and quantity could be typed as Record<Items, T>
But the keys of both prices and variant will always be the same. E.g. there will never be a "GolfBall" variant when there is no GolfBall price, and vice versa.
I've been trying to go down this rabbit hole, and I think I'm close, but no cigar:
type Merchant<T extends keyof Items> {
prices: Record<typeof Items[T], number>;
variants: Record<typeof Items[T], string>;
}As well as:
type Merchant<T extends Items[]> {
prices: {
[key in T]: number;
}
variants: {
[key in T]: string;
}
}To no avail. Please tell me why I'm an idiot and where I need to look to get this right :)
Is it possible to enforce TS to pick a certain overload depending on whether you're providing an anonymous function with no type information (= I want TS to do type inference), vs providing a function that already has type information (= I want to check some constraints on the function parameters).
Basically I only want to do type-inference if type information is missing, otherwise not.
To provide a bit of contest, I have something like this:
interface ValidateFn<ErrorType> = {
<Dependencies, FormData, ExternalData>(
context: ModelContext<any>,
dependencies: Dependencies,
validatorFn: ValidatorFn<
ExtractDependencies<Dependencies>,
FormData,
ExternalData,
ErrorType
>
): ValidateDefinition<ErrorType>;
};I want TS to infer the ValidatorFn when you provide an anonymous function to it. However now if you provide a pre-typed function, I want to check that the first argument (the first generic type passed to ValidatorFn) is compatible with the Dependencies. Basically I need a "ExtractDependencies<Dependencies> extends arg 1 of ValidatorFn`, but not sure how to do that properly
ValidatorFn as a generic type for the ValidateFn with a Validator extends ValidatorFn<...>, but then I lose type inference for anonymous functions
also tried reverting the logic, i.e. instead of using unboxed ExtractDependencies for ValidatorFn, I make sure that Dependencies extends a boxed type of the args:
<
ValidatorInput,
Dependencies extends WithOptionalAnyModelContext<ValidatorInput>,
FormData,
ExternalData
>(
context: ModelContext<any>,
dependencies: Dependencies,
validatorFn: ValidatorFn<ValidatorInput, FormData, ExternalData, ErrorType>
): ValidateDefinition<ErrorType>;With this the type constraint for pre-typed funcs works perfectly, but then the type inference does not work
S can't be used to type Record<S, string>
tsc -b doesn't convert aliases symlinked paths into relatives path (like babel does through babel-module-resolver).
I don't know how to satisfy this generic type :(
function foo<T extends (string | number)>(value: T): T {
if (typeof value === 'string') return '5';
if (typeof value === 'number') return 5;
}I'm getting error on both return statements: https://www.typescriptlang.org/play/?ssl=1&ssc=1&pln=4&pc=2#code/GYVwdgxgLglg9mABMOcA8AVRBTAHlbMAEwGdEAKEqAJxjAHNEAfRMEAWwCNtqBKAPnIA3AIYAbENgBciDLxlYA3gChEaxDGAUoATwAO2OFtETsiALyXEAciq0G13omrYoIakmsBWawG5V6pra+obG4pIWVtZsXDyOzq7uSF7+AL5AA
