type-plus 4.9.1 → 4.10.0

package/ts/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/ts/object/hasKey.spec.ts

@@ -1,29 +0,0 @@
-import { assertType, HasKey, hasKey } from '..'
-
-describe('HasKey<T, K>', () => {
-  test('true if has key', () => {
-    type Foo = { a: 1, b: 2 }
-    assertType.isTrue(true as HasKey<Foo, 'a'>)
-  })
-
-  test('false if do not have key', () => {
-    type Foo = { a: 1, b: 2 }
-    assertType.isFalse(false as HasKey<Foo, 'c'>)
-  })
-});
-
-describe('hasKey()', () => {
-  test('true if has key', () => {
-    const subject = { a: 1, b: 2 }
-
-    expect(hasKey(subject, 'a')).toBeTruthy()
-    expect(hasKey(subject, 'b')).toBeTruthy()
-    expect(hasKey(subject, 'a', 'b')).toBeTruthy()
-  })
-  test('false if do not have key', () => {
-    const subject = { a: 1, b: 2 }
-
-    expect(hasKey(subject, 'c')).toBeFalsy()
-    expect(hasKey(subject, 'a', 'c')).toBeFalsy()
-  })
-});

package/ts/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/ts/object/mapKey.spec.ts

@@ -1,8 +0,0 @@
-import a from 'assertron'
-import { mapKey } from '..'
-
-test('predicate key can be used as indexer of the subject', () => {
-  const subject = { a: 1, b: 2, c: 3 }
-  const actual = mapKey(subject, key => subject[key] + 1)
-  a.satisfies(actual, [2, 3, 4])
-})

package/ts/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/ts/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/ts/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/ts/object/record.spec.ts

@@ -1,54 +0,0 @@
-import { isType, KeyTypes, record } from '..'
-
-test('create an empty record with value default to unknown', () => {
-  const a = record()
-  a[1] = 2
-  a['a'] = 'b'
-  a[Symbol()] = true
-  isType.equal<true, Record<KeyTypes, unknown>, typeof a>()
-})
-
-test('specify key and value types', () => {
-  const a = record<string, number>()
-  // even though the key type is string,
-  // by default JavaScript will cast number index to string
-  // so TypeScript also allows it.
-  a[1] = 2
-  a['a'] = 3
-  isType.equal<true, Record<string, number>, typeof a>()
-})
-
-test('no prototype', () => {
-  const a = record()
-  expect(Object.getPrototypeOf(a)).toBeNull()
-})
-
-test('infer type from initial value, the key type is widen', () => {
-  const stringRecord = record({ a: 1 })
-  isType.equal<true, Record<string, number>, typeof stringRecord>()
-
-  const numberRecord = record({ 1: 3 })
-  isType.equal<true, Record<number, number>, typeof numberRecord>()
-
-  const stringConstRecord = record({ a: 1 } as const)
-  isType.equal<true, Record<string, 1>, typeof stringConstRecord>()
-
-  const stringConstRecord2 = record({ a: 1 as const })
-  isType.equal<true, Record<string, 1>, typeof stringConstRecord2>()
-
-  const stringConstRecord3 = record({ a: 1 as const, b: 'b' })
-  isType.equal<true, Record<string, 1 | string>, typeof stringConstRecord3>()
-
-  const stringConstRecord4 = record({ a: 1 as const, b: 'b' as const })
-  isType.equal<true, Record<string, 1 | 'b'>, typeof stringConstRecord4>()
-})
-
-test('no prototype with initial value', () => {
-  const a = record({ a: 1 })
-  expect(Object.getPrototypeOf(a)).toBeNull()
-})
-
-test('Object.keys() gets the keys of the initial value', () => {
-  const a = record({ a: 1, b: 2 })
-  expect(Object.keys(a)).toEqual(['a', 'b'])
-})

package/ts/object/reduceKey.spec.ts

@@ -1,18 +0,0 @@
-import t from 'assert'
-import { reduceKey } from '..'
-
-test('predicate key can be used as indexer of the subject', () => {
-  const subject = { a: 1, b: 2, c: 3 }
-  const actual = reduceKey(subject, (p, k) => p += subject[k], 'a')
-  t.strictEqual(actual, 'a123')
-})
-
-// currently k: never but it somehow works.
-// Can't find a way to get k to be a more reasonable type that works with `subject[k]`
-// So leaving it as is for now.
-test('key type is string if subject type is plain object', () => {
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  const subject: {} = { a: 1 }
-  const actual = reduceKey(subject, (p, k) => p += subject[k], 'a')
-  t.strictEqual(actual, 'a1')
-})

package/ts/object/replaceProperty.spec.ts

@@ -1,16 +0,0 @@
-import { assertType, replaceProperty, ReplaceProperty } from '..'
-
-test('replaceProperty()', () => {
-  const subject = { a: 1, b: 2 } as const
-  const actual = replaceProperty(subject, 'a', () => 1)
-  assertType<{ a: () => 1, b: 2 }>(actual)
-  expect(actual.a()).toBe(1)
-})
-
-test('ReplaceProperty<>', () => {
-  const subject = { a: 1, b: 2 }
-
-  const actual = subject as ReplaceProperty<typeof subject, 'a', 1>
-
-  assertType<{ a: 1, b: number }>(actual)
-})

package/ts/object/someKey.spec.ts

@@ -1,6 +0,0 @@
-import { someKey } from '..'
-
-test('predicate key can be used as indexer of the subject', () => {
-  const subject = { a: 1, b: 2, c: 3 }
-  expect(someKey(subject, key => subject[key] === 2)).toBe(true)
-})

package/ts/object/split.spec.ts

@@ -1,119 +0,0 @@
-import { isType, split } from '..'
-
-const target = { a: 0, b: '', c: false }
-
-test('can use undefined as default', () => {
-  const [{ a }] = split(target, { a: undefined })
-
-  isType.equal<true, number, typeof a>()
-  expect(a).toBe(0)
-})
-
-test('can specify default with the same type', () => {
-  const [{ a }] = split(target, { a: 2 })
-
-  isType.equal<true, typeof a, number>()
-  expect(a).toBe(0)
-})
-
-test('specifying default removes undefined and null from the type', () => {
-  type S = { a?: number | null, b: number }
-  const s: S = { b: 2 }
-
-  const [{ a }] = split(s, { a: 1 })
-  expect(a).toBe(1)
-
-  isType.equal<true, number, typeof a>()
-})
-
-test('can default with null', () => {
-  const s: { a?: number | null } = {}
-  const [{ a }] = split(s, { a: null })
-
-  expect(a).toBe(null)
-
-  isType.equal<true, number | null, typeof a>()
-})
-
-test('remove optional/undefined when default is provided', () => {
-  interface S {
-    variant?: 'abc' | 'def'
-  }
-  const s: S = {}
-  const [a] = split(s, { variant: 'def' })
-  isType.equal<true, 'abc' | 'def', typeof a.variant>()
-})
-
-test('keep undefined when default is undefined', () => {
-  interface S {
-    variant?: 'abc' | 'def'
-  }
-  const s: S = {}
-  const [a] = split(s, { variant: undefined })
-  isType.equal<true, 'abc' | 'def' | undefined, typeof a.variant>()
-})
-
-
-test('can default with false', () => {
-  const s: { a?: number | boolean } = {}
-  const [{ a }] = split(s, { a: false })
-
-  expect(a).toBe(false)
-
-  isType.equal<true, number | boolean, typeof a>()
-})
-
-test('can default with empty string', () => {
-  const s: { a?: number | null | string } = {}
-  const [{ a }] = split(s, { a: '' })
-
-  expect(a).toBe('')
-
-  isType.equal<true, number | string, typeof a>()
-})
-
-test('keep falsy value other than undefined and null', () => {
-  expect(split({ a: '' }, { a: 'a' })[0].a).toBe('')
-  expect(split({ a: false }, { a: true })[0].a).toBe(false)
-
-  expect(split({ a: null as string | null }, { a: 'a' })[0].a).toBe('a')
-  expect(split({ a: undefined as string | undefined }, { a: 'a' })[0].a).toBe('a')
-})
-
-test('can specify default as one of the intersect types', () => {
-  const [a] = split({ a: undefined as number | string | undefined }, { a: '2' })
-
-  isType.equal<true, typeof a, { a: number | string }>()
-  expect(a).toEqual({ a: '2' })
-})
-
-test('get remaining props in the last entry', () => {
-  const [, r] = split(target, { a: undefined })
-
-  isType.equal<true, typeof r, { b: string, c: boolean }>()
-  expect(r).toEqual({ b: '', c: false })
-})
-
-test('work with simple Record', () => {
-  const [a] = split({} as Record<string, string>, { a: 'a' })
-
-  isType.equal<true, typeof a, { a: string }>()
-  expect(a).toEqual({ a: 'a' })
-})
-
-test('can specify multiple splitters', () => {
-  const t = { r: 'r' } as { a?: string, b?: string, c?: string, r?: string }
-  const [a, b, c, r] = split(t,
-    { a: 'a' },
-    { b: 'b' },
-    { c: 'c' }
-  )
-  isType.equal<true, typeof a, { a: string }>()
-  isType.equal<true, typeof b, { b: string }>()
-  isType.equal<true, typeof c, { c: string }>()
-  isType.equal<true, typeof r, { r?: string | undefined }>()
-  expect(a).toEqual({ a: 'a' })
-  expect(b).toEqual({ b: 'b' })
-  expect(c).toEqual({ c: 'c' })
-  expect(r).toEqual({ r: 'r' })
-})

package/ts/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/ts/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/ts/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/ts/predicates/If.spec.ts

@@ -1,14 +0,0 @@
-import { assertType, If, isType } from '..'
-
-test('true gets Then', () => {
-  assertType<If<true, 2, 3>>(2)
-})
-
-test('false gets Else', () => {
-  assertType<If<false, 2, 3>>(3)
-})
-
-test('Then defaults to true and Else defaults to false', () => {
-  isType.t<If<true>>()
-  isType.f<If<false>>()
-})

package/ts/predicates/IsEmptyObject.spec.ts

@@ -1,15 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-types */
-import { IsEmptyObject } from '..'
-import { isType } from './isType'
-
-test('true for {}', () => {
-  isType.t<IsEmptyObject<{}>>()
-})
-test('false for everything else', () => {
-  isType.f<IsEmptyObject<undefined>>()
-  isType.f<IsEmptyObject<false>>()
-  isType.f<IsEmptyObject<0>>()
-  isType.f<IsEmptyObject<''>>()
-  isType.f<IsEmptyObject<{ a: 1 }>>()
-})
-