type-plus 3.13.0 → 4.0.0

package/ts/object/Partial.spec.ts

@@ -0,0 +1,49 @@
+import { assertType, PartialExcept, PartialOmit, PartialPick } from '..'
+
+test('work on primitive type', () => {
+  type Foo = PartialPick<number, 'toFixed'>
+  const x: Foo = 1
+  assertType<typeof x['toFixed']>(1 as unknown as 1['toFixed'] | undefined)
+})
+
+test('make picked properties optional', () => {
+  type Foo = {
+    a: number,
+    b: number,
+    c: number,
+  }
+
+  const y: PartialPick<Foo, 'a'> = { b: 1, c: 2 }
+
+  y.a = undefined
+  assertType.noUndefined(y.b)
+  assertType.noUndefined(y.c)
+})
+
+test('make not specified properties optional', () => {
+  type Foo = {
+    a: number,
+    b: number,
+    c: number,
+  }
+
+  const y: PartialExcept<Foo, 'a'> = { a: 1 }
+  assertType.noUndefined(y.a)
+  y.b = undefined
+  y.c = undefined
+})
+
+
+test('make not specified properties optional', () => {
+  type Foo = {
+    a: number,
+    b: number,
+    c: number,
+  }
+
+  const y: PartialOmit<Foo, 'a'> = { a: 1 }
+
+  assertType.noUndefined(y.a)
+  y.b = undefined
+  y.c = undefined
+})

package/ts/object/RecursiveIntersect.spec.ts

@@ -0,0 +1,39 @@
+import { RecursiveIntersect } from '..'
+
+test('add object type to types', () => {
+  type U = { u: number }
+
+  acceptU(addU('a'))
+  acceptU(addU(1))
+  acceptU(addU(true))
+  // acceptU(addU(1n))
+  acceptU(addU(undefined))
+  acceptU(addU(null))
+
+  const obj = addU({ x: 1 })
+  acceptU(obj)
+  acceptU(obj.x)
+
+  const comObj = addU({ array: ['a'] })
+  acceptU(comObj)
+  acceptU(comObj.array)
+  acceptU(comObj.array[0])
+
+  const arr = addU(['1'])
+  acceptU(arr)
+  acceptU(arr[0])
+
+  // Not supported
+  // const comArr = addU([{ x: 1 }])
+  // acceptU(comArr)
+  // acceptU(comArr[0])
+  // acceptU(comArr[0].x)
+
+  function addU<T>(x: T): RecursiveIntersect<T, U> {
+    return x as any as RecursiveIntersect<T, U>
+  }
+
+  function acceptU(x: U) {
+    return x
+  }
+})

package/ts/object/Required.spec.ts

@@ -0,0 +1,29 @@
+import { assertType, RequiredExcept, RequiredPick } from '..'
+
+test('make picked properties required', () => {
+  type Foo = {
+    a?: number,
+    b?: number,
+    c: number,
+  }
+
+  const y: RequiredPick<Foo, 'a'> = { a: 1, c: 2 }
+
+  assertType.noUndefined(y.a)
+  y.b = undefined
+  assertType.noUndefined(y.c)
+})
+
+test('make not picked properties required', () => {
+  type Foo = {
+    a?: number,
+    b?: number,
+    c: number,
+  }
+
+  const y: RequiredExcept<Foo, 'a'> = { b: 1, c: 2 }
+
+  y.a = undefined
+  assertType.noUndefined(y.b)
+  assertType.noUndefined(y.c)
+})

package/ts/object/SpreadRecord.spec.ts

@@ -0,0 +1,14 @@
+import { assertType, Equal, SpreadRecord } from '..'
+
+test('records are combined as intersection', () => {
+  type S = SpreadRecord<{ a: number }, { b: string }>
+  assertType.isTrue(true as Equal<S, { a: number } & { b: string }>)
+})
+
+test('Property in B overrides A', () => {
+  type A = { a: number }
+  type B = { a: string, b: string }
+  type S = SpreadRecord<A, B>
+
+  assertType.isTrue(true as Equal<S, { a: string, b: string }>)
+})

package/ts/object/SpreadRecord.ts

@@ -0,0 +1,6 @@
+import { Omit } from '../object'
+
+export type SpreadRecord<
+A extends Record<any, any>,
+B extends Record<any, any>
+> = Omit<A, Extract<keyof A, keyof B>> & B

package/ts/object/ValueOf.spec.ts

@@ -0,0 +1,36 @@
+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/ts/object/facade.ts

@@ -0,0 +1,39 @@
+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/ts/object/getField.spec.ts

@@ -0,0 +1,21 @@
+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/ts/object/getField.ts

@@ -0,0 +1,21 @@
+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 unknown as { [k in K]: TX[K] | DV })[key] || defaultValue
+}

package/ts/object/hasKey.ts

@@ -0,0 +1,7 @@
+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/ts/object/hasProperty.spec.ts

@@ -0,0 +1,15 @@
+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/ts/object/index.ts

@@ -0,0 +1,35 @@
+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/ts/object/mapProperties.spec.ts

@@ -0,0 +1,27 @@
+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/ts/object/omit.spec.ts

@@ -0,0 +1,104 @@
+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/ts/object/omit.ts

@@ -0,0 +1,36 @@
+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/ts/object/pick.spec.ts

@@ -0,0 +1,66 @@
+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>)
+})