/** Try to simplify `&` out of an object type */ export type Remap = {} & { [P in keyof Extract]: Extract[P] } export type LoosePick = {} & Pick export type LooseAccess = K extends keyof T ? T[K] : never export type Pick = {} & { [P in K]: T[P] } export type Omit = Pick> export type Partial = {} & { [P in keyof T]?: T[P] | undefined } export type Overwrite = Remap & U> export type MergeUnknown = Remap> export type MergeDefaults> = Remap< Omit & Partial>> > export type OneOrMore = T | readonly T[] export type Falsy = false | null | undefined // https://github.com/microsoft/TypeScript/issues/14829#issuecomment-504042546 export type NoInfer = [T][T extends any ? 0 : never] export type StaticProps = Omit export interface Lookup { [key: string]: T } /** Intersected with other object types to allow for unknown properties */ export interface UnknownProps extends Lookup {} /** Use `[T] extends [Any]` to know if a type parameter is `any` */ export class Any { private _: never } export type AnyFn = any[], Out = any> = ( ...args: In ) => Out /** Ensure the given type is an object type */ export type ObjectType = T extends object ? T : {} /** Pick keys from a union of objects */ export type UnionPick = Pick< T extends any ? Intersect : never, // @ts-ignore K > extends infer Result ? Result & object : never export type StringKeys = string & keyof T /** Get the keys of each object type in a given union */ export type AllKeys = T extends any ? keyof T : never /** Merge all object types in a given union. Property types are unioned. */ // export type CombineObjects = UnionPick> export type CombineObjects = UnionPick> extends infer Result ? Result & object : never /** * Given a union of object types, find which ones contain the given * property and merge their types with a union. */ export type CombineProp = T extends any ? P extends keyof T ? T[P] : never : never /** Convert a union to an intersection */ export type Intersect = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never export type Exclusive = AllKeys extends infer K ? T extends any ? Remap< LoosePick & { [P in Exclude]?: undefined } > : never : never /** An object that needs to be manually disposed of */ export interface Disposable { dispose(): void }