type-plus 4.8.2 → 4.10.0

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

package/ts/array/reduceWhile.spec.ts

@@ -1,27 +0,0 @@
-import { reduceWhile } from '..'
-
-describe('reduceWhile()', () => {
-  test('with true predicate act like normal reduce', () => {
-    const array = ['a', 'b', 'c']
-    const params: any[] = []
-
-    array.reduce((p, v, i, a) => (params.push([p, v, i, a]), p += v), '')
-    expect(reduceWhile(
-      () => true,
-      (p, v, i, a) => {
-        expect([p, v, i, a]).toEqual(params.shift())
-        return p += v
-      },
-      '',
-      array
-    )).toEqual('abc');
-  })
-  test('terminate early with predicate', () => {
-    expect(reduceWhile(
-      (p, v) => p < v,
-      (p, v) => p += v,
-      -2,
-      [3, 2, 1]
-    )).toEqual(3)
-  })
-})