type-plus 3.13.0 → 4.0.0

package/src/object/ValueOf.spec.ts

@@ -1,36 +0,0 @@
-import { isType, ValueOf } from '..'
-
-test('work with primitive type', () => {
-  type A = ValueOf<string>
-  isType.equal<false, never, A>()
-})
-
-test('If all values has the same type, the result is of that type', () => {
-  const HTTP_METHOD = {
-    GET: 'GET',
-    POST: 'POST',
-    DELETE: 'DELETE',
-    PUT: 'PUT',
-  }
-  type A = ValueOf<typeof HTTP_METHOD>
-  isType.equal<true, string, A>()
-})
-
-test('If value has multiple types, the result is the union of those types', () => {
-  const logLevel = {
-    none: '0',
-    error: '1',
-    warn: 2,
-    info: 3,
-    debug: 4,
-  }
-  type A = ValueOf<typeof logLevel>
-  isType.equal<true, string | number, A>()
-})
-
-test('literal types are preserved', () => {
-  type L = { a: 1, b: 2, c: 'a', d: 'b' }
-  type A = ValueOf<L>
-  isType.equal<true, 1 | 2 | 'a' | 'b', A>()
-})
-

package/src/object/facade.ts

@@ -1,39 +0,0 @@
-import { AnyRecord } from './AnyRecord'
-
-/**
- * creates a facade of the subject.
- */
-export function facade<T extends AnyRecord, P1 extends keyof T>(subject: T, prop1: P1): Pick<T, P1>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T>(subject: T, prop1: P1, prop2: P2): Pick<T, P1 | P2>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T, P11 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
-export function facade<T extends AnyRecord, P1 extends keyof T, P2 extends keyof T, P3 extends keyof T, P4 extends keyof T, P5 extends keyof T, P6 extends keyof T, P7 extends keyof T, P8 extends keyof T, P9 extends keyof T, P10 extends keyof T, P11 extends keyof T, P12 extends keyof T>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11, prop12: P12): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
-export function facade<T extends AnyRecord>(subject: T, ...props: (keyof T)[]) {
-  return props.reduce((p, k) => {
-    const prop = subject[k]
-    if (typeof prop === 'function') {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
-      p[k] = prop.bind(subject)
-    }
-    else {
-      Object.defineProperty(p, k, {
-        get() {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-          return subject[k]
-        },
-        set(value: any) {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-assignment
-          return subject[k] = value
-        },
-      })
-    }
-    return p
-  }, {} as T)
-}

package/src/object/getField.spec.ts

@@ -1,21 +0,0 @@
-import { getField } from '..'
-
-test('support undefined', () => {
-  const sub: { a: number } | undefined = { a: 1 }
-  expect(getField(sub, 'a')).toBe(1)
-})
-
-test('support null', () => {
-  const sub: { a: number } | null = { a: 1 }
-  expect(getField(sub, 'a')).toBe(1)
-})
-
-test('can specify default value', () => {
-  const sub: { a?: number } = { a: undefined }
-  expect(getField(sub, 'a', 2)).toBe(2)
-})
-
-test('get from union keys', () => {
-  const sub: { a: number, b: string } | { a: number, c: string } = { a: 1, b: 'b' }
-  expect(getField(sub, 'b')).toBe('b')
-})

package/src/object/getField.ts

@@ -1,21 +0,0 @@
-import { UnionKeys } from '../UnionKeys'
-
-export function getField<
-  T,
-  TX extends Exclude<T, undefined | null>,
-  K extends UnionKeys<TX>,
-  >(subject: T, key: K): TX[K]
-export function getField<
-  T,
-  TX extends Exclude<T, undefined | null>,
-  K extends UnionKeys<TX>,
-  DV extends Exclude<TX[K], undefined>
->(subject: T, key: K, defaultValue: DV): DV
-export function getField<
-  T,
-  TX extends Exclude<T, undefined | null>,
-  K extends UnionKeys<TX>,
-  DV extends Exclude<TX[K], undefined>
->(subject: T, key: K, defaultValue?: DV) {
-  return subject && (subject as { [k in K]: TX[K] | DV })[key] || defaultValue
-}

package/src/object/hasKey.ts

@@ -1,7 +0,0 @@
-import { AnyRecord } from './AnyRecord'
-
-export type HasKey<T, K, Then = true, Else = false> = K extends keyof T ? Then : Else
-
-export function hasKey<T extends AnyRecord, K extends string>(subject: T, ...keys: K[]): HasKey<T, K> {
-  return !keys.some(key => !subject[key]) as unknown as HasKey<T, K>
-}

package/src/object/hasProperty.spec.ts

@@ -1,15 +0,0 @@
-import { hasProperty } from '..'
-
-test('hasProperty', () => {
-  type X = { name: string } & ({ a: 1 } | { b: 2 })
-
-  const x: X = { name: 'n', a: 1 }
-
-  if (hasProperty(x, 'a'))
-    expect(x.a).toBe(1)
-
-  const y: X = { name: 'n', b: 2 }
-
-  if (hasProperty(y, 'b'))
-    expect(y.b).toBe(2)
-})

package/src/object/index.ts

@@ -1,35 +0,0 @@
-export * from '../object/IsDisjoint'
-export * from './ANotB'
-export * from './AnyRecord'
-export * from './everyKey'
-export * from './ExcludePropType'
-export * from './facade'
-export * from './filterKey'
-export * from './findKey'
-export * from './forEachKey'
-export * from './getField'
-export * from './hasKey'
-export * from './hasProperty'
-export * from './IsRecord'
-export * from './KeyofOptional'
-export * from './KeysWithDiffType'
-export * from './KeyTypes'
-export * from './KnownKeys'
-export * from './mapKey'
-export * from './mapProperties'
-export * from './omit'
-export * from './OptionalKeys'
-export * from './Partial'
-export * from './pick'
-export * from './RecursiveIntersect'
-export * from './RecursivePartial'
-export * from './RecursiveRequired'
-export * from './reduceKey'
-export * from './replaceProperty'
-export * from './Required'
-export * from './RequiredKeys'
-export * from './someKey'
-export * from './SpreadRecord'
-export * from './typeOverrideIncompatible'
-export * from './ValueOf'
-

package/src/object/mapProperties.spec.ts

@@ -1,27 +0,0 @@
-import { mapProperties } from '..'
-
-test('basic usage', () => {
-  const actual = mapProperties({ a: 1, b: 2 }, (v, k) => k + String((v * 2)))
-  expect(actual).toEqual({ a: 'a2', b: 'b4' })
-})
-
-test('mixed type', () => {
-  const actual = mapProperties({ a: 1, b: 'b' }, (v, k) => k + String(v))
-  expect(actual).toEqual({ a: 'a1', b: 'bb' })
-})
-
-test('extract value from prop', () => {
-  const actual = mapProperties({ a: { foo: 'x' }, b: { foo: 'y' } }, (v) => v.foo)
-  expect(actual).toEqual({ a: 'x', b: 'y' })
-})
-
-test('parent props are not mapped', () => {
-  class Boo {
-    shared(v: number) { return v * 2 }
-    own = (v: number) => v * 3
-  }
-  const boo = new Boo()
-
-  const actual = mapProperties(boo, (v) => v(2))
-  expect(actual).toEqual({ own: 6 })
-})

package/src/object/omit.spec.ts

@@ -1,104 +0,0 @@
-import { assertType, Equal, Except, Omit, omit } from '..'
-
-describe('Omit', () => {
-  test('work with primitive types', () => {
-    type N = Omit<number, 'toFixed'>
-    assertType.isFunction((() => ({})) as N['toExponential'])
-  })
-
-  test('Remove properties', () => {
-    type Foo = {
-      a: number,
-      b: string,
-      c: boolean,
-    }
-
-    type Actual = Omit<Foo, 'c'>
-    const a: Actual = { a: 0, b: '' }
-    assertType.isNumber(a.a)
-    assertType.isString(a.b)
-
-    type Revert = Omit<Foo, keyof Actual>
-    const r: Revert = { c: false }
-    assertType.isBoolean(r.c)
-  })
-
-  test('distributive omit', () => {
-    type Action = InvokeAction | ReturnAction
-
-    type InvokeAction = {
-      type: 'invoke',
-      id: string,
-      payload: string[],
-    }
-
-    type ReturnAction = {
-      type: 'return',
-      id: string,
-      payload: string,
-    }
-
-    const x: Omit<Action, 'id'> = { type: 'return', payload: '' }
-
-    const actions: Action[] = []
-
-    actions.push({ ...x, id: '1' })
-  })
-
-  test('distributive Omit with disjoined keys', () => {
-    type Union = {
-      type: 'A',
-      foo: string,
-    } | {
-      type: 'B',
-      foo: string,
-      bar: string,
-    }
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    type Id<T> = {} & { [P in keyof T]: T[P] }
-    let x: Id<Omit<Union, 'bar'>> = { type: 'A', foo: 'foo' }
-    x = { type: 'B', foo: 'bar' }
-    expect(x.foo).toBe('bar')
-  })
-
-  test('intersection types with generic', () => {
-    type Foo = { a: string, b: string }
-    function foo<T>(input: Omit<Foo & T, 'a'>): void {
-      assertType.isString(input.b)
-    }
-    foo({ b: '1' })
-  })
-
-  test('omit properties from object', () => {
-    const actual = omit({ a: 1, b: 2 }, 'a')
-
-    expect(actual).toEqual({ b: 2 })
-  })
-
-  test('omit all', () => {
-    const actual = omit({ a: 1 }, 'a')
-
-    expect(actual).toEqual({})
-    assertType.isTrue(true as Equal<keyof typeof actual, never>)
-  })
-})
-
-describe('Except()', () => {
-  test('Remove properties', () => {
-    type Foo = {
-      a: number,
-      b: string,
-      c: boolean,
-    }
-
-    type Actual = Except<Foo, 'c'>
-    const a: Actual = { a: 0, b: '' }
-    assertType.isNumber(a.a)
-    assertType.isString(a.b)
-
-    // tslint:disable-next-line: deprecation
-    type Revert = Except<Foo, keyof Actual>
-    const r: Revert = { c: false }
-    assertType.isBoolean(r.c)
-  })
-})

package/src/object/omit.ts

@@ -1,36 +0,0 @@
-import { AnyRecord, reduceByKey } from '../object'
-import { UnionKeys } from '../UnionKeys'
-import { Pick } from './pick'
-
-// by Titian Cernicova-Dragomir
-// https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347
-// type-zoo
-export type Omit<T, K extends UnionKeys<T>> = T extends T
-  ? keyof T extends K
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  ? {}
-  : Pick<T, Exclude<keyof T, K>> : never
-
-/**
- * @deprecated replaced by `Omit`
- */
-export type Except<T, K extends keyof T> = Omit<T, K>
-
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Omit<T, P1>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2): Omit<T, P1 | P2>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3): Omit<T, P1 | P2 | P3>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Omit<T, P1 | P2 | P3 | P4>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Omit<T, P1 | P2 | P3 | P4 | P5>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Omit<T, P1 | P2 | P3 | P4 | P5 | P6>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
-export function omit<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>, P12 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11, prop12: P12): Omit<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
-export function omit<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
-  return reduceByKey(subject, (p, k) => {
-    if (props.indexOf(k) === -1) p[k] = subject[k]
-    return p
-  }, {} as AnyRecord)
-}

package/src/object/pick.spec.ts

@@ -1,66 +0,0 @@
-import { assertType, canAssign, Equal, Pick, pick } from '..'
-
-test('pick properties from object', () => {
-  const actual = pick({ a: 1, b: 2 }, 'a')
-
-  expect(actual).toEqual({ a: 1 })
-})
-
-test('distributive pick', () => {
-  type Action = InvokeAction | ReturnAction
-
-  type InvokeAction = {
-    type: 'invoke',
-    id: string,
-    payload: string[],
-  }
-
-  type ReturnAction = {
-    type: 'return',
-    id: string,
-    payload: string,
-  }
-
-  const x: Pick<Action, 'type' | 'payload'> = { type: 'invoke', payload: [] }
-
-  const actions: Action[] = []
-
-  actions.push({ ...x, id: '1' })
-})
-
-test('distributive pick with disjoined keys', () => {
-  type Union = {
-    type: 'A',
-    foo: string,
-  } | {
-    type: 'B',
-    foo: string,
-    bar: string,
-  }
-  type Id<T> = { [P in keyof T]: T[P] }
-  let x: Id<Pick<Union, 'type' | 'bar'>> = { type: 'A' }
-  x = { type: 'B', bar: 'bar' }
-
-  expect(x.bar).toBe('bar')
-})
-
-test('intersection types with generic', () => {
-  type Foo = { a: string, b: string }
-  function foo<T>(input: Pick<Foo & T, 'a'>): void {
-    assertType.isString(input.a)
-  }
-  foo({ a: '1' })
-})
-
-test('optional property remains optional', () => {
-  type Foo = { a?: string, b: string }
-  type A = Pick<Foo, 'a'>
-  assertType.isTrue(canAssign<A>()({}))
-})
-
-test('pick never gets empty object', () => {
-  type A = { a: number }
-  type S = Pick<A, never>
-  type K = keyof S
-  assertType.isTrue(true as Equal<K, never>)
-})

package/src/object/pick.ts

@@ -1,35 +0,0 @@
-import { UnionKeys } from '../UnionKeys'
-import { AnyRecord } from './AnyRecord'
-import { reduceByKey } from './reduceKey'
-
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Pick<T, P1>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2): Pick<T, P1 | P2>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>, P12 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11, prop12: P12): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
-export function pick<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
-  return reduceByKey(subject, (p, k) => {
-    if (props.indexOf(k) >= 0) p[k] = subject[k]
-    return p
-  }, {} as T)
-}
-
-/**
- * Pick properties `K` from `T`.
- * Works with union.
- *
- * Original type by Titian Cernicova-Dragomir
- * @see <https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347>
- */
-export type Pick<T, K extends UnionKeys<T>> = T extends unknown ? Pick._<T, keyof T & K> : never
-
-export namespace Pick {
-  export type _<T, K extends keyof T> = { [P in K]: T[P] }
-}

package/src/object/typeOverrideIncompatible.spec.ts

@@ -1,24 +0,0 @@
-import { typeOverrideIncompatible } from '..'
-
-test('same type override has no property', () => {
-  type A = { a: 1 }
-  const transform = typeOverrideIncompatible<A>()
-
-  // TODO: find a way to assert `override` has no property
-  transform({ a: 1 }, {})
-})
-
-test('disjoint type override is A', () => {
-  type A = { a: 1 }
-  const transform = typeOverrideIncompatible<A>()
-
-  transform({ b: 2 }, { a: 1 })
-})
-
-test('intersect type override is ANotB', () => {
-  const a = { a: 1, b: 2 } as const
-  const b = { b: 3, c: 3 } as const
-  const transform = typeOverrideIncompatible<typeof a>()
-
-  transform(b, { a: 1, b: 2 })
-})

package/src/object/typeOverrideIncompatible.ts

@@ -1,10 +0,0 @@
-import { ANotB, AnyRecord } from '.'
-
-export function typeOverrideIncompatible<A extends AnyRecord>() {
-  return function <B extends AnyRecord>(source: B, override: ANotB<A, B>): A {
-    return {
-      ...source,
-      ...override,
-    }
-  }
-}

package/src/predicates/CanAssign.spec.ts

@@ -1,57 +0,0 @@
-import { assertType, CanAssign, canAssign } from '..'
-
-describe('CanAssign<A, B>', () => {
-  test('literal type to widen', () => {
-    assertType.isTrue(true as CanAssign<1, number>)
-    assertType.isTrue(true as CanAssign<1, 1>)
-    assertType.isTrue(true as CanAssign<number, number>)
-    assertType.isTrue(true as CanAssign<'a', string>)
-    assertType.isTrue(true as CanAssign<'a', 'a'>)
-    assertType.isTrue(true as CanAssign<string, string>)
-    assertType.isTrue(true as CanAssign<false, boolean>)
-    assertType.isTrue(true as CanAssign<true, boolean>)
-    assertType.isTrue(true as CanAssign<boolean, boolean>)
-  })
-  test('base type to literal type fails', () => {
-    assertType.isFalse(false as CanAssign<number, 1>)
-    assertType.isFalse(false as CanAssign<string, 'a'>)
-    assertType.isFalse(false as CanAssign<true, false>)
-    assertType.isFalse(false as CanAssign<false, true>)
-    assertType.isFalse(false as CanAssign<boolean, false>)
-    assertType.isFalse(false as CanAssign<boolean, true>)
-  })
-  test('super set to sub set', () => {
-    assertType.isTrue(true as CanAssign<{ a: string, b: number }, { a: string }>)
-  })
-  test('sub set to super set fail', () => {
-    assertType.isFalse(false as CanAssign<{ a: string }, { a: string, b: number }>)
-  })
-})
-
-describe('canAssign()', () => {
-  describe('without subject', () => {
-    test('returns a function that check type at compile time', () => {
-      assertType.isTrue(canAssign<{ a: string }>()({ a: 'a' }))
-      assertType.isTrue(canAssign<{ a: string }>()({ a: 'a', b: 'b' }))
-
-      // fails at compile time
-      // canAssign<{ a: string }>()({ a: 1 })
-    })
-    test('work with falsy value such as empty string', () => {
-      const s = ''
-      assertType.isTrue(canAssign<''>()(s))
-    })
-    test('work with undefined', () => {
-      assertType.isTrue(canAssign<number | undefined>()(undefined))
-    })
-    test('canAssign false', () => {
-      const t = canAssign<{ a: string }>(false)
-      assertType.isTrue(t(undefined))
-      assertType.isTrue(t({ a: 1 }))
-
-      // these fails
-      // t({ a: '' })
-      // t({ a: '', b: '' })
-    })
-  })
-})

package/src/predicates/Equal.spec.ts

@@ -1,71 +0,0 @@
-import { assertType, Equal, NotEqual } from '..'
-
-describe('TypeEquals', () => {
-  test('match', () => {
-    assertType.isTrue(true as Equal<false, false>)
-  })
-
-  test('not match', () => {
-    assertType.isFalse(false as Equal<string, number>)
-  })
-
-  test('literal is not equal to widen type', () => {
-    assertType.isFalse(false as Equal<1, number>)
-    assertType.isFalse(false as Equal<number, 1>)
-  })
-
-  test('super set and sub set are not equal', () => {
-    assertType.isFalse(false as Equal<{ a: 1 }, { a: 1, b: 2 }>)
-    assertType.isFalse(false as Equal<{ a: 1, b: 2 }, { a: 1 }>)
-  })
-
-  test('boolean', () => {
-    assertType.isTrue(true as Equal<boolean, boolean>)
-    assertType.isTrue(true as Equal<true, true>)
-    assertType.isTrue(true as Equal<false, false>)
-    assertType.isFalse(false as Equal<boolean, true>)
-    assertType.isFalse(false as Equal<true, boolean>)
-    assertType.isFalse(false as Equal<boolean, false>)
-    assertType.isFalse(false as Equal<false, boolean>)
-    assertType.isFalse(false as Equal<false, true>)
-    assertType.isFalse(false as Equal<true, false>)
-  })
-
-  test('same type is true', () => {
-    assertType.isTrue(true as Equal<{ a: 1 }, { a: 1 }>)
-  })
-
-  test('different type is false', () => {
-    assertType.isFalse(false as Equal<{ a: 1 }, { b: 1 }>)
-  })
-
-  test('A subset of B is false', () => {
-    assertType.isFalse(false as Equal<{ a: 1 }, { a: 1, b: 1 }>)
-  })
-
-  test('B subset of A is false', () => {
-    assertType.isFalse(false as Equal<{ a: 1, b: 1 }, { a: 1 }>)
-  })
-
-  test('disjoin is false', () => {
-    assertType.isFalse(false as Equal<{ b: 1 }, { a: 1 }>)
-  })
-
-  test('overlap is false', () => {
-    assertType.isFalse(false as Equal<{ a: 1, b: 1 }, { a: 1, c: 2 }>)
-  })
-})
-
-describe('TypeNotEquals', () => {
-  test('boolean', () => {
-    assertType.isFalse(false as NotEqual<boolean, boolean>)
-    assertType.isFalse(false as NotEqual<true, true>)
-    assertType.isFalse(false as NotEqual<false, false>)
-    assertType.isTrue(true as NotEqual<boolean, true>)
-    assertType.isTrue(true as NotEqual<true, boolean>)
-    assertType.isTrue(true as NotEqual<boolean, false>)
-    assertType.isTrue(true as NotEqual<false, boolean>)
-    assertType.isTrue(true as NotEqual<false, true>)
-    assertType.isTrue(true as NotEqual<true, false>)
-  })
-})

package/src/predicates/Equal.ts

@@ -1,14 +0,0 @@
-/**
- * Checks if two types are equal.
- * Borrow from `typepark`.
- * The simple `A extends B ? B extends A ? true : false : false`
- * does not work with boolean type.
- */
-export type Equal<A, B, Then = true, Else = false> =
-  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
-  ? Then : Else
-export type IsEqual<A, B> = Equal<A, B>
-
-export type NotEqual<A, B, Then = true, Else = false> =
-  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? Else : Then
-export type IsNotEqual<A, B> = NotEqual<A, B>

package/src/predicates/Extends.ts

@@ -1,4 +0,0 @@
-export type Extendable<A, B> = A extends B ? A : never
-export type NotExtendable<A, B> = A extends B ? never : A
-export type IsExtend<A, B, Then = true, Else = false> = A extends B ? Then : Else
-export type IsNotExtend<A, B, Then = true, Else = false> = A extends B ? Else : Then