type-plus 4.9.1 → 4.10.2

package/ts/array/DropMatch.spec.ts

@@ -1,234 +0,0 @@
-import { drop, DropMatch, DropNull, DropNullable, DropUndefined, isType } from '..'
-
-describe('DropMatch<A, C>', () => {
-  describe('A is array', () => {
-    test('drop all types gets never[]', () => {
-      type A = DropMatch<Array<string>, string>
-      isType.equal<true, never[], A>()
-
-      type B = DropMatch<Array<string | boolean>, string | boolean>
-      isType.equal<true, never[], B>()
-    })
-
-    test('drop undefined and null from array', () => {
-      type A = DropMatch<Array<string | undefined>, undefined>
-      isType.equal<true, string[], A>()
-
-      type B = DropMatch<Array<string | number | undefined>, undefined>
-      isType.equal<true, Array<string | number>, B>()
-
-      type C = DropMatch<Array<string | number | undefined | null>, undefined | null>
-      isType.equal<true, Array<string | number>, C>()
-    })
-
-    test('can get undefined and null array when other types dropped', () => {
-      type A = DropMatch<Array<string | undefined>, string>
-      isType.equal<true, undefined[], A>()
-
-      type B = DropMatch<Array<string | number | null>, string>
-      isType.equal<true, Array<number | null>, B>()
-    })
-
-    test('unmatched criteria returns original', () => {
-      type Actual = DropMatch<Array<string | undefined>, number>
-
-      isType.equal<true, Array<string | undefined>, Actual>()
-    })
-
-    test('drop all narrow types', () => {
-      type A = DropMatch<Array<1 | 2 | 3>, number>
-      isType.equal<true, never[], A>()
-
-      type B = DropMatch<Array<1 | 2 | 3 | string>, number>
-      isType.equal<true, string[], B>()
-    })
-
-
-    test('will not drop widen type', () => {
-      type A = DropMatch<Array<number>, 1>
-      isType.equal<true, number[], A>()
-
-      type B = DropMatch<Array<string | 'foo'>, 'foo'>
-      isType.equal<true, string[], B>()
-
-      // C is currently `string[] | string[]` (TypeScript 4.6.2)
-      // It does not collapse to `string[]`
-      // type C = DropMatch<Array<string | 'foo'>, 'foo' | 'boo'>
-      // Here `string[] | string[]` literal collapses to `string[]`
-      // commenting this out as it will likely be improved in future versions of TypeScript
-      // isType.equal<true, string[] | string[], C>()
-    })
-  })
-
-  describe('A is Tuple', () => {
-    test('empty tuple', () => {
-      type A = DropMatch<[], undefined>
-      isType.equal<true, [], A>()
-    })
-
-    test('drop undefined from tuple', () => {
-      type A = DropMatch<[undefined], undefined>
-      isType.equal<true, [], A>()
-
-      type B = DropMatch<[1, undefined], undefined>
-      isType.equal<true, [1], B>()
-
-      type C = DropMatch<[1, undefined, 3], undefined>
-      isType.equal<true, [1, 3], C>()
-
-      type D = DropMatch<[1, string | undefined, 3], undefined>
-      isType.equal<true, [1, string, 3], D>()
-    })
-
-    test('drop undefined from readonly tuple', () => {
-      type A = DropMatch<readonly [undefined], undefined>
-      isType.equal<true, [], A>()
-
-      type B = DropMatch<[1, undefined], undefined>
-      isType.equal<true, [1], B>()
-
-      type C = DropMatch<[1, undefined, 3], undefined>
-      isType.equal<true, [1, 3], C>()
-
-      type D = DropMatch<[1, string | undefined, 3], undefined>
-      isType.equal<true, [1, string, 3], D>()
-    })
-
-    test('drop undefined keep null', () => {
-      type A = DropMatch<[undefined | null], undefined>
-      isType.equal<true, [null], A>()
-    })
-
-    test('drop null keep undefined', () => {
-      type A = DropMatch<[undefined | null], null>
-      isType.equal<true, [undefined], A>()
-    })
-
-    test('drop both null and undefined', () => {
-      type A = DropMatch<[undefined | null], null | undefined>
-      isType.equal<true, [], A>()
-
-      type B = DropMatch<[undefined | null | string], null | undefined>
-      isType.equal<true, [string], B>()
-    })
-
-    test('get original if not matched', () => {
-      type A = DropMatch<[1], undefined>
-      isType.equal<true, [1], A>()
-
-      type B = DropMatch<[1], undefined | string>
-      isType.equal<true, [1], B>()
-
-      type C = DropMatch<[1, 2, 3, 4], 5>
-      isType.equal<true, [1, 2, 3, 4], C>()
-    })
-
-    test('drop narrow type', () => {
-      type C = DropMatch<[1], number>
-      isType.equal<true, [], C>()
-    })
-
-    test('keep widen type', () => {
-      type D = DropMatch<[number], 1>
-      isType.equal<true, [number], D>()
-    })
-
-    test('drop type from tuple', () => {
-      type A = DropMatch<[1], 1>
-      isType.equal<true, [], A>()
-
-      type B = DropMatch<[number | string], number>
-      isType.equal<true, [string], B>()
-
-      type C = DropMatch<[1, undefined, 3], 1>
-      isType.equal<true, [undefined, 3], C>()
-
-      type D = DropMatch<[1, string | undefined, 3], 3>
-      isType.equal<true, [1, string | undefined], D>()
-    })
-
-    test('drop multiple types', () => {
-      type Actual = DropMatch<[1, 2, 3, 4], 2 | 4>
-      isType.equal<true, [1, 3], Actual>()
-    })
-
-    test('drop undefined and null', () => {
-      type Actual = DropMatch<[1, undefined, 3, null], undefined | null>
-      isType.equal<true, [1, 3], Actual>()
-    })
-  })
-})
-
-describe('DropUndefined<A>', () => {
-  test('drop from array type', () => {
-    type A = DropUndefined<Array<string | undefined>>
-    isType.equal<true, string[], A>()
-
-    type B = DropUndefined<Array<string | number>>
-    isType.equal<true, Array<string | number>, B>()
-
-    type C = DropUndefined<Array<string | number | undefined | null>>
-    isType.equal<true, Array<string | number | null>, C>()
-  })
-
-  test('drop from tuple type', () => {
-    type A = DropUndefined<[string, undefined, number, null]>
-    isType.equal<true, [string, number, null], A>()
-  })
-})
-
-describe('DropNull<A>', () => {
-  test('drop from array type', () => {
-    type A = DropNull<Array<string | null>>
-    isType.equal<true, string[], A>()
-
-    type B = DropNull<Array<string | number>>
-    isType.equal<true, Array<string | number>, B>()
-
-    type C = DropNull<Array<string | number | undefined | null>>
-    isType.equal<true, Array<string | number | undefined>, C>()
-  })
-
-  test('drop from tuple type', () => {
-    type A = DropNull<[string, undefined, number, null]>
-    isType.equal<true, [string, undefined, number], A>()
-  })
-})
-
-describe('DropNullable<A>', () => {
-  test('drop from array type', () => {
-    type A = DropNullable<Array<string | null>>
-    isType.equal<true, string[], A>()
-
-    type B = DropNullable<Array<string | number>>
-    isType.equal<true, Array<string | number>, B>()
-
-    type C = DropNullable<Array<string | number | undefined | null>>
-    isType.equal<true, Array<string | number>, C>()
-  })
-
-  test('drop from tuple type', () => {
-    type A = DropNullable<[string, undefined, number, null]>
-    isType.equal<true, [string, number], A>()
-  })
-})
-
-
-describe('drop()', () => {
-  test('array', () => {
-    const a = drop([1, 'a', 3, 4], 'a')
-    expect(a).toEqual([1, 3, 4])
-    isType.equal<true, number[], typeof a>()
-  })
-  test('tuple', () => {
-    const a = drop([1, 2, 3, 4] as const, 1 as const)
-    expect(a).toEqual([2, 3, 4])
-    isType.equal<true, [2, 3, 4], typeof a>()
-  })
-
-  test('drop undefined from tuple', () => {
-    const a = drop([1, undefined, 3, undefined, 4] as const, undefined)
-    expect(a).toEqual([1, 3, 4])
-    isType.equal<true, [1, 3, 4], typeof a>()
-  })
-})

package/ts/array/Filter.spec.ts

@@ -1,107 +0,0 @@
-import { Filter, isType, KeepMatch } from '..'
-
-describe('Filter<A, C>', () => {
-  describe('A is array', () => {
-    test('array matching criteria gets itself', () => {
-      type Actual = Filter<string[], string>
-      isType.equal<true, string[], Actual>()
-    })
-
-    test('array not matching criteria gets never[]', () => {
-      type Actual = Filter<string[], number>
-      isType.equal<true, never[], Actual>()
-    })
-
-    test('remove unmatched type form array', () => {
-      type Actual = Filter<Array<string | number>, string>
-
-      isType.equal<true, string[], Actual>()
-    })
-
-    test('remove undefined and null', () => {
-      type Actual = Filter<Array<string | undefined | null>, string>
-      isType.equal<true, string[], Actual>()
-    })
-
-    test('can filter with undefined and null', () => {
-      type Actual = Filter<Array<string | undefined | null>, undefined | null>
-      // Array<undefined | null> is destructured to undefined[] | null[] by TypeScript
-      isType.equal<true, undefined[] | null[], Actual>()
-    })
-
-    test('work with never[]', () => {
-      type Actual = Filter<never[], undefined>
-      isType.equal<true, never[], Actual>()
-    })
-  })
-
-  describe(`A is Tuple`, () => {
-    test('matching criteria', () => {
-      type Actual = Filter<[1, 2, 3, 4], 2 | 4>
-      isType.equal<true, [2, 4], Actual>()
-    })
-
-    test('no match gets never[]', () => {
-      type Actual = Filter<[1, 2, 3, 4], 5>
-      isType.equal<true, never[], Actual>()
-    })
-
-    test('matching undefined and null', () => {
-      type Actual = Filter<[1, undefined, 3, null], undefined | null>
-      isType.equal<true, [undefined, null], Actual>()
-    })
-  })
-})
-
-describe('KeepMatch<A, C>', () => {
-  describe('A is array', () => {
-    test('array matching criteria gets itself', () => {
-      type Actual = KeepMatch<string[], string>
-      isType.equal<true, string[], Actual>()
-    })
-
-    test('array not matching criteria gets never[]', () => {
-      type Actual = KeepMatch<string[], number>
-      isType.equal<true, never[], Actual>()
-    })
-
-    test('remove unmatched type form array', () => {
-      type Actual = KeepMatch<Array<string | number>, string>
-
-      isType.equal<true, string[], Actual>()
-    })
-
-    test('remove undefined and null', () => {
-      type Actual = KeepMatch<Array<string | undefined | null>, string>
-      isType.equal<true, string[], Actual>()
-    })
-
-    test('can filter with undefined and null', () => {
-      type Actual = KeepMatch<Array<string | undefined | null>, undefined | null>
-      // Array<undefined | null> is destructured to undefined[] | null[] by TypeScript
-      isType.equal<true, undefined[] | null[], Actual>()
-    })
-
-    test('work with never[]', () => {
-      type Actual = KeepMatch<never[], undefined>
-      isType.equal<true, never[], Actual>()
-    })
-  })
-
-  describe(`A is Tuple`, () => {
-    test('matching criteria', () => {
-      type Actual = KeepMatch<[1, 2, 3, 4], 2 | 4>
-      isType.equal<true, [2, 4], Actual>()
-    })
-
-    test('no match gets never[]', () => {
-      type Actual = KeepMatch<[1, 2, 3, 4], 5>
-      isType.equal<true, never[], Actual>()
-    })
-
-    test('matching undefined and null', () => {
-      type Actual = KeepMatch<[1, undefined, 3, null], undefined | null>
-      isType.equal<true, [undefined, null], Actual>()
-    })
-  })
-})

package/ts/array/FindFirst.spec.ts

@@ -1,27 +0,0 @@
-import { assertType, Equal, FindFirst } from '..'
-
-test('pick first type matching criteria', () => {
-  type Actual = FindFirst<[true, 1, 'x', 3], number>
-  assertType.isTrue(true as Equal<1, Actual>)
-})
-
-test('no match gets never', () => {
-  type Actual = FindFirst<[true, 1, 'x'], 2>
-  assertType.isTrue(true as Equal<never, Actual>)
-})
-
-test('pick object', () => {
-  type Actual = FindFirst<[
-    { name: 'a', type: 1 },
-    { name: 'b', type: 2 },
-    { name: 'c', type: 3 },
-    { name: 'b', type: 4 },
-  ], { name: 'b' }>['type']
-  assertType.isTrue(true as Equal<2, Actual>)
-})
-
-test('generic', () => {
-  const s: string[] = ['a', 'b', 'c']
-  type Actual = FindFirst<typeof s, string>
-  assertType.isTrue(true as Equal<string, Actual>)
-})

package/ts/array/FindLast.spec.ts

@@ -1,27 +0,0 @@
-import { assertType, Equal, FindLast } from '..'
-
-test('pick last type matching criteria', () => {
-  type Actual = FindLast<[true, 1, 'x', 3], number>
-  assertType.isTrue(true as Equal<3, Actual>)
-})
-
-test('no match gets never', () => {
-  type Actual = FindLast<[true, 1, 'x'], 2>
-  assertType.isTrue(true as Equal<never, Actual>)
-})
-
-test('pick object', () => {
-  type Actual = FindLast<[
-    { name: 'a', type: 1 },
-    { name: 'b', type: 2 },
-    { name: 'c', type: 3 },
-    { name: 'b', type: 4 },
-  ], { name: 'b' }>['type']
-  assertType.isTrue(true as Equal<4, Actual>)
-})
-
-test('works on array type', () => {
-  const s: string[] = ['a', 'b', 'c']
-  type Actual = FindLast<typeof s, string>
-  assertType.isTrue(true as Equal<string, Actual>)
-})

package/ts/array/Head.spec.ts

@@ -1,21 +0,0 @@
-import { assertType, Equal, Head } from '..'
-
-test('get first type', () => {
-  type S = [1, 'a', 'b']
-  type A = Head<S>
-
-  assertType.isTrue(true as Equal<A, 1>)
-})
-
-test('empty tuple gets never', () => {
-  type S = []
-  type A = Head<S>
-
-  assertType.isTrue(true as Equal<A, never>)
-})
-
-test('array gets same type', () => {
-  type A = Head<string[]>
-
-  assertType.isTrue(true as Equal<A, string>)
-})

package/ts/array/IntersectOfProps.spec.ts

@@ -1,14 +0,0 @@
-import { assertType, Equal, IntersectOfProps } from '..'
-
-test('get property from single value tuple', () => {
-  type S = [{ a: number }]
-  type A = IntersectOfProps<S, 'a'>
-
-  assertType.isTrue(true as Equal<A, number>)
-})
-
-test('get property from multiple values', () => {
-  type S = [{ a: { x: number } }, { a: { y: string } }]
-  type A = IntersectOfProps<S, 'a'>
-  assertType.isTrue(true as Equal<A, { x: number } & { y: string }>)
-})

package/ts/array/Last.spec.ts

@@ -1,32 +0,0 @@
-import { AnyFunction, isType } from '..'
-import { Last } from './Last'
-
-test('any array', () => {
-  type A = Last<any[]>
-  isType.equal<true, any, A>()
-})
-
-test('never array', () => {
-  type A = Last<never[]>
-  isType.equal<true, never, A>()
-})
-
-test('typed array', () => {
-  type A = Last<string[]>
-  isType.equal<true, string, A>()
-})
-
-test('function array', () => {
-  type A = Last<AnyFunction[]>
-  isType.equal<true, AnyFunction, A>()
-})
-
-test('empty tuple gets undefined', () => {
-  type A = Last<[]>
-  isType.equal<true, undefined, A>()
-})
-
-test('tuple with function', () => {
-  type A = Last<[number, AnyFunction]>
-  isType.equal<true, AnyFunction, A>()
-})

package/ts/array/PadLeft.spec.ts

@@ -1,26 +0,0 @@
-import { isType, PadLeft } from '..'
-
-test('zero length returns the same', () => {
-  isType.equal<true, [], PadLeft<[], 0>>()
-})
-
-test('pad with any by default', () => {
-  isType.equal<true, [any, any], PadLeft<[], 2>>()
-  isType.equal<true, [any, any, 1, 2, 3], PadLeft<[1, 2, 3], 5>>()
-})
-
-test('pad length less than tuple length is ignored', () => {
-  isType.equal<true, [1, 2, 3], PadLeft<[1, 2, 3], 2>>()
-})
-
-test('pad elements before array', () => {
-  isType.equal<true, [any, any, any, ...string[]], PadLeft<string[], 3>>()
-})
-
-test('override PadWith', () => {
-  isType.equal<true, [{ a: 1 }, { a: 1 }, 1, 2, 3], PadLeft<[1, 2, 3], 5, { a: 1 }>>()
-})
-
-test('pad and array value type is the same returns array', () => {
-  isType.equal<true, string[], PadLeft<string[], 3, string>>()
-})

package/ts/array/Reverse.spec.ts

@@ -1,17 +0,0 @@
-import { isType, Reverse } from '..'
-
-test('empty array gets itself', () => {
-  isType.equal<true, [], Reverse<[]>>()
-})
-
-test('array type gets itself', () => {
-  isType.equal<true, string[], Reverse<string[]>>()
-})
-
-test('single element array gets itself', () => {
-  isType.equal<true, [1], Reverse<[1]>>()
-})
-
-test('multi elements', () => {
-  isType.equal<true, [4, 3, 2, 1], Reverse<[1, 2, 3, 4]>>()
-})

package/ts/array/Some.spec.ts

@@ -1,79 +0,0 @@
-import { isType, Some } from '..'
-
-test('empty array', () => {
-  isType.equal<true, false, Some<[], any>>()
-})
-
-test('typed array', () => {
-  isType.equal<true, true, Some<string[], any>>()
-  isType.equal<true, true, Some<string[], string>>()
-  isType.equal<true, false, Some<string[], number>>()
-})
-
-test('contain single returns true', () => {
-  isType.equal<true, true, Some<['a', 1], 1>>()
-})
-
-test('not contain returns false', () => {
-  isType.equal<true, false, Some<['a', 'b', 'c'], 1>>()
-})
-
-test('number', () => {
-  isType.equal<true, true, Some<['a', number], number>>()
-  isType.equal<true, true, Some<['a', 1], 1>>()
-  isType.equal<true, true, Some<['a', 777], 777>>()
-
-  isType.equal<true, false, Some<['a', number], 1>>()
-  isType.equal<true, true, Some<['a', 12345], number>>()
-  isType.equal<true, true, Some<['a', -12345], number>>()
-  isType.equal<true, false, Some<['a', 1], 2>>()
-})
-
-test('boolean', () => {
-  isType.equal<true, true, Some<['a', boolean], boolean>>()
-  isType.equal<true, true, Some<['a', true], true>>()
-  isType.equal<true, true, Some<['a', false], false>>()
-
-  isType.equal<true, true, Some<['a', false, boolean], boolean>>()
-  isType.equal<true, true, Some<['a', boolean, false], boolean>>()
-  isType.equal<true, true, Some<['a', boolean, true], true>>()
-  isType.equal<true, true, Some<['a', true, boolean], true>>()
-
-  isType.equal<true, true, Some<['a', true], boolean>>()
-  isType.equal<true, true, Some<['a', false], boolean>>()
-  isType.equal<true, false, Some<['a', boolean], true>>()
-  isType.equal<true, false, Some<['a', boolean], false>>()
-})
-
-test('string', () => {
-  isType.equal<true, true, Some<[1, 2, 3, string], string>>()
-  isType.equal<true, true, Some<[1, 2, 3, 'a'], 'a'>>()
-  isType.equal<true, true, Some<[1, 2, 3, 'a', 'a'], 'a'>>()
-
-  isType.equal<true, true, Some<[1, 2, 3, 'a'], string>>()
-  isType.equal<true, true, Some<[1, 2, 3, 'a'], string>>()
-  isType.equal<true, false, Some<[1, 2, 3, string], 'a'>>()
-  isType.equal<true, false, Some<[1, 2, 3, 'a'], 'ab'>>()
-})
-
-describe('strict mode', () => {
-  test('ensure number boolean string does not match literals', () => {
-    isType.equal<true, true, Some<[boolean], boolean, 'strict'>>()
-    isType.equal<true, true, Some<[number], number, 'strict'>>()
-    isType.equal<true, true, Some<[string], string, 'strict'>>()
-
-    isType.equal<true, false, Some<['a', true], boolean, 'strict'>>()
-    isType.equal<true, false, Some<['a', 1], number, 'strict'>>()
-    isType.equal<true, false, Some<[1, 2, 3, 'a'], string, 'strict'>>()
-  })
-
-  test('typed array', () => {
-    isType.equal<true, true, Some<boolean[], boolean, 'strict'>>()
-    isType.equal<true, true, Some<number[], number, 'strict'>>()
-    isType.equal<true, true, Some<string[], string, 'strict'>>()
-
-    isType.equal<true, false, Some<true[], boolean, 'strict'>>()
-    isType.equal<true, false, Some<1[], number, 'strict'>>()
-    isType.equal<true, false, Some<'a'[], string, 'strict'>>()
-  })
-})

package/ts/array/Tail.spec.ts

@@ -1,32 +0,0 @@
-import { isType, Tail } from '..'
-
-test('get tail types', () => {
-  type S = [1, 'a', 'b']
-  type A = Tail<S>
-
-  isType.equal<true, ['a', 'b'], A>()
-})
-
-test('empty tuple gets never', () => {
-  type S = []
-  type A = Tail<S>
-
-  isType.equal<true, never, A>()
-})
-
-test('array gets same type', () => {
-  type A = Tail<string[]>
-
-  isType.equal<true, string[], A>()
-})
-
-test('union array', () => {
-  type A = Tail<Array<string | boolean>>
-
-  isType.equal<true, Array<string | boolean>, A>()
-})
-
-test('tuple with rest', () => {
-  type A = Tail<[number, ...string[]]>
-  isType.equal<true, string[], A>()
-})

package/ts/array/UnionOfProps.spec.ts

@@ -1,14 +0,0 @@
-import { assertType, Equal, UnionOfProps } from '..'
-
-test('get property from single value tuple', () => {
-  type S = [{ a: number }]
-  type A = UnionOfProps<S, 'a'>
-
-  assertType.isTrue(true as Equal<A, number>)
-})
-
-test('get property from multiple values', () => {
-  type S = [{ a: 'a' }, { a: 'b' }]
-  type A = UnionOfProps<S, 'a'>
-  assertType.isTrue(true as Equal<A, 'a' | 'b'>)
-})

package/ts/array/UnionOfValues.spec.ts

@@ -1,11 +0,0 @@
-import { UnionOfValues, assertType, Equal } from '..'
-
-test('get value of generic array', () => {
-  type Actual = UnionOfValues<string[]>
-  assertType.isTrue(true as Equal<string, Actual>)
-})
-
-test('tuple get union type of values', () => {
-  type Actual = UnionOfValues<[string, boolean]>
-  assertType.isTrue(true as Equal<string | boolean, Actual>)
-})

package/ts/array/literalArray.spec.ts

@@ -1,7 +0,0 @@
-import { isType, literalArray } from '..'
-
-test('entries in array are restricted to the input literals', () => {
-  const actual = literalArray('a', 'b')
-
-  isType.equal<true, Array<'a' | 'b'>, typeof actual>()
-})