type-plus 4.8.2 → 4.10.0

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 }>>()
-})
-

package/ts/predicates/index.spec.ts

@@ -1,73 +0,0 @@
-import { IsAny, IsBoolean, IsLiteral, isType, PrimitiveTypes } from '..'
-
-describe('IsLiteral<T>', () => {
-  test('`number` is not literal', () => {
-    isType.equal<true, false, IsLiteral<number>>()
-  })
-
-  test('numeric literals are literals', () => {
-    isType.equal<true, true, IsLiteral<1>>()
-    isType.equal<true, true, IsLiteral<12345>>()
-  })
-
-  test('`string` is not literal', () => {
-    isType.equal<true, false, IsLiteral<string>>()
-  })
-
-  test('string literals are literals', () => {
-    isType.equal<true, true, IsLiteral<'1'>>()
-    isType.equal<true, true, IsLiteral<'abc'>>()
-  })
-
-  test('override Then/Else', () => {
-    isType.equal<true, 'yes', IsLiteral<'1', 'yes'>>()
-    isType.equal<true, 'no', IsLiteral<string, 'yes', 'no'>>()
-  })
-})
-
-describe('IsBoolean<T>', () => {
-  test('boolean/true/false', () => {
-    isType.equal<true, true, IsBoolean<boolean>>()
-    isType.equal<true, false, IsBoolean<false>>()
-    isType.equal<true, false, IsBoolean<true>>()
-  })
-  test('override Then/Else', () => {
-    isType.equal<true, 'yes', IsBoolean<boolean, 'yes'>>()
-    isType.equal<true, 'no', IsBoolean<1, 'yes', 'no'>>()
-  })
-})
-
-describe('IsAny<T>', () => {
-  test('any is true', () => {
-    isType.equal<true, true, IsAny<any>>()
-  })
-
-  test('string is false', () => {
-    isType.equal<true, false, IsAny<string>>()
-  })
-
-  test('other singular types are false', () => {
-    isType.equal<true, false, IsAny<undefined>>()
-    isType.equal<true, false, IsAny<null>>()
-    isType.equal<true, false, IsAny<number>>()
-    isType.equal<true, false, IsAny<boolean>>()
-    isType.equal<true, false, IsAny<string>>()
-    isType.equal<true, false, IsAny<symbol>>()
-    isType.equal<true, false, IsAny<unknown>>()
-    isType.equal<true, false, IsAny<never>>()
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    isType.equal<true, false, IsAny<{}>>()
-    isType.equal<true, false, IsAny<void>>()
-  })
-
-  test('union types are false', () => {
-    isType.equal<true, false, IsAny<
-      undefined | null | number | boolean | string |
-      // eslint-disable-next-line @typescript-eslint/ban-types
-      symbol | unknown | never | void | object>>()
-  })
-
-  test('union of all types is true', () => {
-    isType.equal<true, true, IsAny<PrimitiveTypes>>()
-  })
-})