type-plus 3.14.0 → 4.0.1

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/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 type { ANotB, BNotA, LeftJoin } from './ANotB'
+export type { AnyRecord } from './AnyRecord'
+export * from './everyKey'
+export type { ExcludePropType } from './ExcludePropType'
+export * from './facade'
+export * from './filterKey'
+export * from './findKey'
+export * from './forEachKey'
+export * from './getField'
+export * from './hasKey'
+export * from './hasProperty'
+export type { IsDisjoint } from './IsDisjoint'
+export type { IsRecord } from './IsRecord'
+export type { KeysOfOptional } from './KeyofOptional'
+export type { KeysWithDiffType } from './KeysWithDiffType'
+export type { KeyTypes } from './KeyTypes'
+export type { KnownKeys } from './KnownKeys'
+export * from './mapKey'
+export * from './mapProperties'
+export * from './omit'
+export type { OptionalKeys } from './OptionalKeys'
+export type { PartialOmit, PartialPick } from './Partial'
+export * from './pick'
+export type { RecursiveIntersect } from './RecursiveIntersect'
+export type { RecursivePartial } from './RecursivePartial'
+export type { RecursiveRequired } from './RecursiveRequired'
+export * from './reduceKey'
+export * from './replaceProperty'
+export type { RequiredExcept, RequiredPick } from './Required'
+export type { RequiredKeys } from './RequiredKeys'
+export * from './someKey'
+export type { SpreadRecord } from './SpreadRecord'
+export * from './typeOverrideIncompatible'
+export type { ValueOf } 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>)
+})

package/ts/object/pick.ts

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

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

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