Update 2018-10: @MattMcCutchen has figured out that it is possible to detect readonly fields (invalidating the struck-out passage below), as shown in this answer. Here is a way to build it: type IfEquals<X, Y, A=X, B=never> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : … Read more
I don’t think there’s a way (or at least not a clean way) to have the type of one class property to depend on the current value of another property. You’re better off combining both these properties into a single object: type LoadState<T> = { state: “loading”, } | { state: “loaded”, data: T } … Read more
You can do this in 3.1 using Tuples in rest parameters and spread expressions const foo = <T extends string | number>( first: T, …a: (T extends string ? [boolean] : [undefined?]) ) => undefined; foo(‘foo’, true); // ok, as intended foo(2, true); // not ok, as intended foo(2, undefined); // ok, as intended foo(2); … Read more
There’s a built-in helper for that type AnyCompProps = React.ComponentProps<typeof AnyComp> And it also works for native DOM elements: type DivProps = React.ComponentProps<“div”> https://stackoverflow.com/a/55005902/82609
You asked for it. Let’s do some type manipulation to detect if a given type is a union or not. The way it works is to use the distributive property of conditional types to spread out a union to constituents, and then notice that each constituent is narrower than the union. If that isn’t true, … Read more
I think what you are actually looking for is a discriminated union. IObject should itself be a union: export type IObject = { type: “checked” parameters: IParametersCheck } | { type: “counter” parameters: IParametersCounter } export type ObjectType = IObject[‘type’] //// in case you need this union export type ObjectParameters = IObject[‘parameters’] //// in case … Read more
With infer, the compiler ensures that you have declared all type variables explicitly: type MyType<T> = T extends infer R ? R : never; type T1 = MyType<{b: string}> // T1 is { b: string; } Here we declare a new type variable R in MyType, which gets inferred from T. (Note, that infer is … Read more