type-challenges / type-challenges Goto Github PK

type MyOmit<T, K> = {
  [k in Exclude<keyof T, K>]: T[k]
}

const arr = ['foo', 'bar'] as const

type union = ArrayToUnion<typeof arr> // expect to be 'foo' | 'bar'

type MyExclude<T, U> =  T extends U ? never : T;

type MyReadonly<T> = { readonly [K in keyof T]: T[K] }

type First<T extends any[]> = T extends [infer H, ...infer _] ? H : never

type MyPick<T, K extends keyof T> = {
  [k in K]: T[k]
}

type Length<T extends {readonly [x: number]: any; readonly length: number;}> = T['length'] 

type GetReadonlyKeys<T> = Exclude<{
  [K in keyof T]: Equal<{ [k in K]: T[K] }, { -readonly [k in K]: T[K] }> extends true ? never : K
}[keyof T], undefined>;

type Pop<T extends any[]> = T extends [...infer P, any] ? P : never

type MyReadonly<T> = {
  readonly [k in keyof T]: T[k]
}

type MyExclude<T, U> = any

import { Equal, Expect, ExpectFalse, NotEqual } from '@type-challenges/utils'

type cases = [
    Expect<Equal<MyExclude<"a" | "b" | "c", "a">, Exclude<"a" | "b" | "c", "a">>>,
    Expect<Equal<MyExclude<"a" | "b" | "c", "a" | "b">, Exclude<"a" | "b" | "c", "a" | "b">>>,
    Expect<Equal<MyExclude<string | number | (() => void), Function>, Exclude<string | number | (() => void), Function>>>,
]

type MyExclude<A, B> = A extends B ? never : A;

type MyOmit<T, K extends keyof T> = { [S in MyExclude<keyof T, K>]: T[S] }

type TupleToUnion<T> = T extends any[] ? T[number] : never;

declare function SimpleVue<D, C, M>(options: {
  data: () => D,
  computed: C,
  methods: M,
  // methods: { [k in keyof M]: (this: ThisType<D & C & M>) => M[k] },
} & ThisType<D & { [k in keyof C]: C[k] extends (...args: any[]) => any ? ReturnType<C[k]> : never } & M>): any

type Unshift<T> = T extends [infer K, ...infer U] ? U : unknown
type Head<T> = T extends [infer K, ...infer U] ? K : unknown

type Curried<T, R> = T extends Array<any>
  ? T['length'] extends 1
    ? (args: Head<T>) => R
    : (args: Head<T>) => Curried<Unshift<T>, R>
  : never

declare function Currying<T extends unknown[], R>(fn: (...args: T) => R): Curried<T, R>

/**
 * ReadonlyKeys
 * @desc Get union type of keys that are readonly in object type `T`
 * Credit: Matt McCutchen
 * https://stackoverflow.com/questions/52443276/how-to-exclude-getter-only-properties-from-type-in-typescript
 * @example
 *   type Props = { readonly foo: string; bar: number };
 *
 *   // Expect: "foo"
 *   type Keys = ReadonlyKeys<Props>;
 */
export type ReadonlyKeys<T extends object> = {
  [P in keyof T]-?: IfEquals<
    { [Q in P]: T[P] },
    { -readonly [Q in P]: T[P] },
    never,
    P
  >
}[keyof T]

type IfEquals<X, Y, A = X, B = never> = 
  (<T>() => T extends X ? 1 : 2) extends 
  (<T>() => T extends Y ? 1 : 2) ? A : B

type GetReadonlyKeys<T extends Object> = {
  [K in keyof T]: 
    (<S>() => S extends { [Z in K]: T[Z] } ? 2 : 1) extends 
    (<S>() => S extends { -readonly [Z in K]: T[Z] } ? 2: 1) ? never : K
}[keyof T]

type GetComputed<C> = C extends Record<string, (...args: any[]) => any> 
  ? { [S in keyof C]: ReturnType<C[S]> } 
  : never

declare function SimpleVue<D, C, M>(
  options: {
    data: () => D,
    computed: C,
    methods: M,
  } & ThisType<D & M & GetComputed<C>>
): any

const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise<string>((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

// expected to be `Promise<[number, number, string]>`
const p = Promise.all([promise1, promise2, promise3] as const)

declare function PromiseAll(promises: any[]): any

import { Equal, Expect } from '@type-challenges/utils'

const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise<string>((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

type cases = [
  Expect<Equal<PromiseAll([promise1, promise2, promise3] as const), Promise<[3, 42, string]>>>
]

type Curried<T extends (...args: any) => any> = {
  0: T extends (...args: [infer A]) => infer R ? (arg: A) => R : never,
  1: T extends (...args: [infer A, ...infer Args]) => infer R ? (arg: A) => Curried<(...args: Args) => R> : never,
}[T extends (...args: [any]) => any ? 0 : 1]

declare function Currying<T extends (...args: any) => any>(fn: T): Curried<T>

type MyOmit<T, K> = Pick<T, Exclude<keyof T, K>>

type I = GetRequired<{ foo: number, bar?: string }> // expected to be { foo: number }

type GetRequired<T> = any

import { Equal, Expect, ExpectFalse, NotEqual } from '@type-challenges/utils'

type cases = [
    Expect<Equal<GetRequired<{ foo: number, bar?: string }>, { foo: number }>>,
    Expect<Equal<GetRequired<{ foo: undefined, bar?: undefined }>, { foo: undefined }>>,
]

type MyPick<T, K extends keyof T> = { [S in K]: T[S] }

type MyPick<T, K> = {
  [k in keyof T & K]: T[k]
}

type Length<T extends ReadonlyArray<any>> = T['length'] 

type YourType = any

import { Equal, Expect, ExpectFalse, NotEqual } from '@type-challenges/utils'

type cases = [
  Expect<Equal<true, true>>
]

type TupleToUnion<T> = T[number & keyof T]

type MyPick<T, K extends keyof T> = { [S in K]: T[S] }

type DeepReadonly<T> = {
  readonly [k in keyof T]: T[k] extends Record<any, any>
    ? T[k] extends Function
      ? T[k]
      : DeepReadonly<T[k]>
    : T[k]
}

type I = Union2Intersection<'foo' | 42 | true> // expected to be 'foo' & 42 & true

type UnionToIntersection<U> = any

import { Equal, Expect, ExpectFalse, NotEqual } from '@type-challenges/utils'

type cases = [
    Expect<Equal<UnionToIntersection<'foo' | 42 | true>, 'foo' & 42 & true>>,
    Expect<Equal<UnionToIntersection<(() => 'foo') | ((i: 42) => true)>, (() => 'foo') & ((i: 42) => true)>>,
]

type Unshift<T extends any[], K> =
    ((a: K, ...args: T) => void) extends ((...args: infer U) => void)
    ? U : never;

type Reverse<T extends any[], Target extends any[] = []> = {
    0: Target;
    1: (
        ((...args: T) => void) extends ((a: infer First, ...args: infer Rest) => void)
        ? Reverse<Rest, Unshift<Target, First>> : never
    );
}[T extends [any, ...any[]] ? 1 : 0];

type Pop<T extends any[]> =
    ((...args: Reverse<T>) => void) extends ((a: any, ...args: infer K) => void)
    ? Reverse<K> : never;

type ReadonlyKeys<T, R extends { [K in keyof T]: any } = Readonly<T>> = {
    [K in keyof T]: Equal<Pick<T, K>, Pick<R, K>> extends true ? K : never
}[keyof T]

type Last<T extends any[]> = T extends [...infer _, infer L] ? L : never

type MyReadonly<T> = { readonly [K in keyof T]: T[K]}

type Chainable<T = {}> = {
  option<K extends string | number | symbol, U>(key: K , value: U): Chainable<T & { [k in K]: U }>
  get(): { [k in keyof T]: T[k] }
}

export type TupleToUnion<T> = T extends Array<infer ITEMS> ? ITEMS : never

type Pop<T extends any[]> = T extends [...infer I, infer _] ? I : never

type First<T extends any[]> = T extends [infer P, ...any[]] ? P : never

type TupleToObject<T extends ReadonlyArray<string | number>> = {
  [k in T[number]]: k
}

type Chainable<O = {}> = {
  option<K extends string, V>(key: K, value: V): Chainable<O & { [k in K]: V }>
  get(): O
}

type MyReturnType<T> = T extends (...args: any) => infer R ? R : never

type First<T extends any[]> = T extends [infer F, ...any[]] ? F : never;

type Diff<T extends string | number | symbol, U extends string | number | symbol> =
    ({[P in T]: P } & {[P in U]: never } & { [x: string]: never })[T];  
type MyOmit<T, K extends keyof T> = Pick<T, Diff<keyof T, K>>;

interface Cat {
  type: 'cat'
  breeds: 'Abyssinian' | 'Shorthair' | 'Curl' | 'Bengal'
}

interface Dog {
  type: 'dog'
  breeds: 'Hound' | 'Brittany' | 'Bulldog' | 'Boxer'
  color: 'brown' | 'white' | 'black'
}

const MyDog = LookUp<Cat | Dog, 'dog'> // expected to be `Dog`

type LookUp<U, T> = any

import { Equal, Expect } from '@type-challenges/utils'

interface Cat {
  type: 'cat'
  breeds: 'Abyssinian' | 'Shorthair' | 'Curl' | 'Bengal'
}

interface Dog {
  type: 'dog'
  breeds: 'Hound' | 'Brittany' | 'Bulldog' | 'Boxer'
  color: 'brown' | 'white' | 'black'
}

type Animal = Cat | Dog

type cases = [
  Expect<Equal<LookUp<Animal, 'dog'>, Dog>>,
  Expect<Equal<LookUp<Animal, 'cat'>, Cat>>,
]

type Chainable<Options = {}> = {
  option<K extends string, V>(key: K, value: V): Chainable<Options & { [S in K]: V }>
  get(): Options
}

type MyReturnType<T extends Function> =
  T extends (...args: any) => infer R
    ? R
    : never

type Diff<A, B> = A extends B ? never : A

type MyReadonly2<T, K extends keyof T = keyof T> =
  { readonly [S in K]: T[S] }
  & { [S in Diff<keyof T, K>]: T[S] }

type TupleToObject<T extends readonly any[]> = { [K in T[number]]: K }

type I = GetOptional<{ foo: number, bar?: string }> // expected to be { bar?: string }

type GetOptional<T> = any

import { Equal, Expect, ExpectFalse, NotEqual } from '@type-challenges/utils'

type cases = [
    Expect<Equal<GetOptional<{ foo: number, bar?: string }>, { bar?: string }>>,
    Expect<Equal<GetOptional<{ foo: undefined, bar?: undefined }>, { bar?: undefined }>>,
]