type-plus 4.9.1 → 4.10.0

package/ts/nominal-types/Flavor.spec.ts

@@ -1,51 +0,0 @@
-import { assertType, brand, CanAssign, Flavor, flavor, isType } from '..'
-
-test('underlying type can be assigned to Flavor', () => {
-  type PersonId = Flavor<'Person', number>
-  type BlogId = Flavor<'Blog', number>
-
-  let personId: PersonId = 1
-  let personId2: PersonId = 2
-
-  personId = personId2
-  personId2 = personId
-
-  const blogId: BlogId = 1
-
-  isType.f<CanAssign<typeof blogId, typeof personId>>()
-})
-
-describe('flavor()', () => {
-  test('basic use case', () => {
-    const a = flavor('a', { a: 1 as const })
-    const b = flavor('b', { b: 'b' })
-
-    isType.f<CanAssign<typeof a, typeof b>>()
-    assertType<1>(a.a)
-    assertType<string>(b.b)
-  })
-  test('same flavor of the same type can be assigned to each other', () => {
-    const a = flavor('a', { a: 1 })
-    let b = flavor('a', { a: 2 })
-    b = a
-    expect(b.a).toBe(1)
-  })
-  test('brand with the same name can be assigned to flavor', () => {
-    const b = brand('x', { a: 1 })
-    const f = flavor('x', { a: 1 })
-    isType.t<CanAssign<typeof b, typeof f>>()
-  })
-  test('without subject creates a typed flavor creator', () => {
-    const createPerson = flavor('person')
-    let person1 = createPerson(1)
-    let person2 = createPerson(2)
-
-    const createBlogPost = flavor('Blog')
-    const blogPost = createBlogPost(1)
-
-    person1 = person2
-    person2 = person1
-
-    isType.f<CanAssign<typeof blogPost, typeof person1>>()
-  })
-})

package/ts/nominal-types/nominalMatch.spec.ts

@@ -1,54 +0,0 @@
-import { brand, flavor, nominalMatch } from '..'
-
-describe('nominalMatches()', () => {
-  describe('Brand', () => {
-    test('value of same brand matches', () => {
-      const a = brand('x', 1)
-      const b = brand('x', 2)
-      expect(nominalMatch(a, b)).toBe(true)
-
-      const c = brand('x', { c: 3 })
-      const d = brand('x', { d: 4 })
-      expect(nominalMatch(c, d)).toBe(true)
-    })
-    test('work with null and undefined', () => {
-      const a = brand('x', undefined)
-      const b = brand('x', null)
-      expect(nominalMatch(a, b)).toBe(true)
-    })
-    test('different brand will not compile with nominalMatches()', () => {
-      // const a = brand('x', 1)
-      // const b = brand('y', 1)
-      // nominalMatches(a, b)  // <-- does not compile
-
-      // const c = brand('x', { a: 1 })
-      // const d = brand('y', { a: 1 })
-      // nominalMatches(c, d)  // <-- does not compile
-    })
-  })
-  describe('Flavor', () => {
-    test('value of same flavor matches', () => {
-      const a = flavor('x', 1)
-      const b = flavor('x', 2)
-      expect(nominalMatch(a, b)).toBe(true)
-
-      const c = flavor('x', { c: 3 })
-      const d = flavor('x', { d: 4 })
-      expect(nominalMatch(c, d)).toBe(true)
-    })
-    test('work with null and undefined', () => {
-      const a = flavor('x', undefined)
-      const b = flavor('x', null)
-      expect(nominalMatch(a, b)).toBe(true)
-    })
-    test('different flavor will not compile with nominalMatches()', () => {
-      // const a = flavor('x', 1)
-      // const b = flavor('y', 1)
-      // nominalMatches(a, b)  // <-- does not compile
-
-      // const c = flavor('x', { a: 1 })
-      // const d = flavor('y', { a: 1 })
-      // nominalMatches(c, d)  // <-- does not compile
-    })
-  })
-})

package/ts/object/ANotB.spec.ts

@@ -1,78 +0,0 @@
-import { ANotB, assertType, BNotA, IsDisjoint, LeftJoin } from '..'
-
-describe('ANotB<A, B>', () => {
-  test('same type returns never', () => {
-    const actual = { a: 1 } as ANotB<{ a: 1 }, { a: 1 }>
-    assertType<never>(actual)
-  })
-
-  test('disjoint returns A', () => {
-    type A = { a: 1 }
-    const actual = { a: 1 } as ANotB<A, { b: 2 }>
-    assertType<A>(actual)
-  })
-
-  test('remove properties in B from A', () => {
-    type A = { a: 1, b: 2, c: 3 }
-    type B = { c: 3, d: 4 }
-    const actual = { a: 1 } as ANotB<A, B>
-
-    assertType<Pick<A, 'a' | 'b'>>(actual)
-    assertType.isTrue(true as IsDisjoint<B, typeof actual>)
-  })
-
-  test('same property different type returns the type in A', () => {
-    type A = { a: 1 }
-    type B = { a: string }
-    const actual = { a: 1 } as ANotB<A, B>
-    assertType<A>(actual)
-  })
-});
-
-describe('BNotA<A, B>', () => {
-  test('same type returns never', () => {
-    const actual = { a: 1 } as BNotA<{ a: 1 }, { a: 1 }>
-    assertType<never>(actual)
-  })
-
-  test('disjoint returns B', () => {
-    type A = { a: 1 }
-    type B = { b: 2 }
-    const actual = { b: 2 } as BNotA<A, B>
-    assertType<B>(actual)
-  })
-
-  test('remove properties in A from B', () => {
-    type A = { c: 3, d: 4 }
-    type B = { a: 1, b: 2, c: 3 }
-    const actual = { a: 1 } as BNotA<A, B>
-
-    assertType<Pick<B, 'a' | 'b'>>(actual)
-    assertType.isTrue(true as IsDisjoint<A, typeof actual>)
-  })
-
-  test('same property different type returns the type in B', () => {
-    type A = { a: 1 }
-    type B = { a: string }
-    const actual = { a: 'a' } as BNotA<A, B>
-    assertType<B>(actual)
-  })
-});
-
-describe('LeftJoin', () => {
-  test('same type returns A', () => {
-    const actual = {} as LeftJoin<{ a: 1 }, { a: 1 }>
-    assertType<{ a: 1 }>(actual)
-  })
-
-  test('disjoint returns A & B', () => {
-    const actual = {} as LeftJoin<{ a: 1 }, { b: 1 }>
-    assertType<{ a: 1, b: 1 }>(actual)
-  })
-
-  test('replaces property in A with property in B', () => {
-    type Orig = { type: 'a' | 'b', value: string }
-    const actual = {} as LeftJoin<Orig, { value: number }>
-    assertType<{ type: 'a' | 'b', value: number }>(actual)
-  })
-});

package/ts/object/ExcludePropType.spec.ts

@@ -1,13 +0,0 @@
-import { assertType, ExcludePropType } from '..'
-
-test('exclude type R from properties of T', () => {
-  interface Customer {
-    name: string,
-    age: number | null,
-  }
-
-  type CustomerAgeNotNull = ExcludePropType<Customer, null>
-
-  const x: CustomerAgeNotNull = { name: '', age: 0 }
-  assertType.isNumber(x.age)
-})

package/ts/object/IsDisjoint.spec.ts

@@ -1,25 +0,0 @@
-import { isType, IsDisjoint } from '..'
-
-test('disjoint returns true', () => {
-  type A = { a: 1 }
-  type B = { b: 1 }
-  isType.t<IsDisjoint<A, B>>()
-})
-
-test('same type returns false', () => {
-  type A = { a: 1 }
-  type B = { a: 1 }
-  isType.f<IsDisjoint<A, B>>()
-})
-
-test('A subset of B returns false', () => {
-  type A = { a: 1 }
-  type B = { a: 1, b: 1 }
-  isType.f<IsDisjoint<A, B>>()
-})
-
-test('B subset of A returns false', () => {
-  type A = { a: 1, b: 1 }
-  type B = { a: 1 }
-  isType.f<IsDisjoint<A, B>>()
-})

package/ts/object/IsRecord.spec.ts

@@ -1,22 +0,0 @@
-import { assertType, IsRecord } from '..'
-
-test('boolean, number, string, null, undefined, symbol are not record', () => {
-  assertType.isFalse(false as IsRecord<undefined>)
-  assertType.isFalse(false as IsRecord<null>)
-  assertType.isFalse(false as IsRecord<boolean>)
-  assertType.isFalse(false as IsRecord<number>)
-  assertType.isFalse(false as IsRecord<string>)
-  assertType.isFalse(false as IsRecord<symbol>)
-})
-
-test('array is not record', () => {
-  assertType.isFalse(false as IsRecord<[]>)
-})
-
-test('object is record', () => {
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  assertType.isTrue(true as IsRecord<{}>)
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  assertType.isTrue(true as IsRecord<object>)
-  assertType.isTrue(true as IsRecord<{ a: string }>)
-})

package/ts/object/KeyTypes.spec.ts

@@ -1,9 +0,0 @@
-import { KeyTypes } from '..'
-
-test('contains type of all keys', () => {
-  acceptKeys('a')
-  acceptKeys(1)
-  acceptKeys(Symbol())
-
-  function acceptKeys(k: KeyTypes) { return k }
-})

package/ts/object/KeyofOptional.spec.ts

@@ -1,8 +0,0 @@
-import { assertType, IsEqual, KeysOfOptional } from '..'
-
-test('get keys from optional type', () => {
-  type X = { o?: { a: string, b: string } }
-  type A = KeysOfOptional<X['o']>
-
-  assertType.isTrue(true as IsEqual<'a' | 'b', A>)
-})

package/ts/object/KeysWithDiffType.spec.ts

@@ -1,21 +0,0 @@
-import { assertType, KeysWithDiffType } from '..'
-
-test('disjoint type gets never', () => {
-  type A = { a: 1 }
-  type B = { b: 2 }
-  const actual = 'a' as KeysWithDiffType<A, B>
-  assertType<never>(actual)
-})
-
-test('key with same type is not included', () => {
-  type A = { a: 1 }
-  const actual = 'a' as KeysWithDiffType<A, A>
-  assertType<never>(actual)
-})
-
-test('key with different type is returned', () => {
-  type A = { a: 1 }
-  type B = { a: 2 }
-  const actual = 'a' as KeysWithDiffType<A, B>
-  assertType<'a'>(actual)
-})

package/ts/object/KnownKeys.spec.ts

@@ -1,39 +0,0 @@
-import { assertType, KnownKeys } from '..'
-
-test('pick out only known keys', () => {
-  type A = {
-    a?: boolean,
-    b?: number,
-    [k: string]: any,
-  }
-
-  const input: A = {}
-  const actual = getKnownKeys(input)
-  assertType<'a' | 'b'>(actual)
-})
-
-test('primitive type yields never', () => {
-  assertType<never>(getKnownKeys(undefined))
-  assertType<never>(getKnownKeys(true))
-  assertType<never>(getKnownKeys(false))
-  assertType<never>(getKnownKeys(null))
-  assertType<never>(getKnownKeys('str'))
-  assertType<never>(getKnownKeys(1))
-  assertType<never>(getKnownKeys({}))
-  assertType<never>(getKnownKeys([]))
-})
-
-test('literal gets keys', () => {
-  assertType<'a'>(getKnownKeys({ a: 1 }))
-})
-
-test('empty record yields never', () => {
-  const x: Record<any, any> = {}
-  const actual = getKnownKeys(x)
-  assertType<never>(actual)
-})
-
-
-function getKnownKeys<T>(_value: T): KnownKeys<T> {
-  return {} as unknown as KnownKeys<T>
-}

package/ts/object/OptionalKeys.spec.ts

@@ -1,23 +0,0 @@
-import { assertType, IsEqual, OptionalKeys } from '..'
-
-test('extract optional keys from object', () => {
-  type X = { a?: string, b: string }
-
-  assertType.isTrue(true as IsEqual<'a', OptionalKeys<X>>)
-})
-test('work with union type', () => {
-  type X = { a?: string, b: string } | { c: string, d?: string }
-
-  type A = OptionalKeys<X>
-  assertType.isTrue(true as IsEqual<'a' | 'd', A>)
-})
-test('no optional keys returns never', () => {
-  type X = { b: string }
-
-  assertType.isTrue(true as IsEqual<never, OptionalKeys<X>>)
-})
-test('keys with undefined value is not optional', () => {
-  type X = { a: string | undefined }
-
-  assertType.isTrue(true as IsEqual<never, OptionalKeys<X>>)
-})

package/ts/object/Partial.spec.ts

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

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

@@ -1,57 +0,0 @@
-import t from 'assert'
-import { RecursiveRequired } from '..'
-
-test('simple optional property becomes required', () => {
-  type SimpleOptional = {
-    x?: string,
-  }
-
-  const actual: RecursiveRequired<SimpleOptional> = { x: '' }
-  t.strictEqual(actual.x.length, 0)
-})
-
-test('deep optional object property becomes required', () => {
-  type DeepOptonal = {
-    x: {
-      y?: string,
-    },
-  }
-
-  const actual: RecursiveRequired<DeepOptonal> = { x: { y: '' } }
-  t.strictEqual(actual.x.y.length, 0)
-})
-
-test('deep optional array property becomes required', () => {
-  type DeepArrayOptonal = {
-    x: {
-      y?: string,
-    }[],
-  }
-
-  const actual: RecursiveRequired<DeepArrayOptonal> = { x: [{ y: '' }] }
-  t.strictEqual(actual.x[0].y.length, 0)
-})
-
-// Not supported
-
-// test('simple optional array property becomes required', () => {
-//   type SimpleArrayOptonal = Array<{ y?: string }>
-
-
-//   let actual: RecursiveRequired<SimpleArrayOptonal> = [{ y: '' }]
-//   t.strictEqual(actual[0].y.length, 0)
-// })
-
-// test('deep optional tuple property becomes required', () => {
-//   type DeepArrayOptonal = {
-//     x: [{
-//       y?: string
-//     }, {
-//       z?: string
-//     }]
-//   }
-
-//   let actual: RecursiveRequired<DeepArrayOptonal> = { x: [{ y: '' }, { z: '' }] }
-//   t.strictEqual(actual.x[0].y.length, 0)
-//   t.strictEqual(actual.x[1].z.length, 0)
-// })

package/ts/object/Required.spec.ts

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

@@ -1,24 +0,0 @@
-import { assertType, IsEqual, RequiredKeys } from '..'
-
-test('extract required keys from object', () => {
-  type X = { a?: string, b: string }
-
-  type A = RequiredKeys<X>
-  assertType.isTrue(true as IsEqual<'b', A>)
-})
-test('work with union type', () => {
-  type X = { a?: string, b: string } | { c: string, d?: string }
-
-  type A = RequiredKeys<X>
-  assertType.isTrue(true as IsEqual<'b' | 'c', A>)
-})
-test('no required keys returns never', () => {
-  type X = { b?: string }
-
-  assertType.isTrue(true as IsEqual<never, RequiredKeys<X>>)
-})
-test('keys with undefined value is required', () => {
-  type X = { a: string | undefined }
-
-  assertType.isTrue(true as IsEqual<'a', RequiredKeys<X>>)
-})

package/ts/object/SpreadRecord.spec.ts

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

@@ -1,11 +0,0 @@
-import { everyKey } from '..'
-
-test('predicate key can be used as indexer of the subject', () => {
-  const subject = { a: 1, b: 2, c: 3 }
-  expect(everyKey(subject, key => typeof subject[key] === 'number')).toBe(true)
-})
-
-test('type this arg', () => {
-  const subject = { b: 2 }
-  expect(everyKey(subject, function () { return this.a === 1 }, { a: 1 })).toBe(true)
-})

package/ts/object/facade.spec.ts

@@ -1,22 +0,0 @@
-import { facade } from '..'
-
-test('facade on property', () => {
-  const subject = { a: 1, b: 2, c: 3 }
-
-  const actual = facade(subject, 'a', 'b')
-  expect(actual.a).toBe(1)
-  expect(actual.b).toBe(2)
-
-  actual.b = 4
-  expect(subject.b).toBe(4)
-})
-
-test('facade on function', () => {
-  const subject = {
-    a: 1,
-    foo() { return this.a },
-  }
-
-  const actual = facade(subject, 'foo')
-  expect(actual.foo()).toBe(1)
-})

package/ts/object/filterKey.spec.ts

@@ -1,8 +0,0 @@
-import t from 'assert'
-import { filterKey } from '..'
-
-test(`return type is 'keyof subject'`, () => {
-  const subject = { a: 1, b: 2, c: 3 }
-  const actual = filterKey(subject, key => subject[key] > 1)
-  t.deepStrictEqual(actual, ['b', 'c'])
-})

package/ts/object/findKey.spec.ts

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

package/ts/object/forEachKey.spec.ts

@@ -1,9 +0,0 @@
-import t from 'assert'
-import { forEachKey } from '..'
-
-test('predicate key can be used as indexer of the subject', () => {
-  const subject = { a: 1, b: 2, c: 3 }
-  let actual = 0
-  forEachKey(subject, key => actual += subject[key])
-  t.strictEqual(actual, 6)
-})