type-plus 3.12.2 → 3.15.0

package/src/math/Max.spec.ts

@@ -1,35 +0,0 @@
-import { isType, Max } from '..'
-
-test('only support positive and whole number', () => {
-  isType.equal<true, never, Max<0.1, 1>>()
-  isType.equal<true, never, Max<-1, 1>>()
-  isType.equal<true, never, Max<1, 0.1>>()
-  isType.equal<true, never, Max<1, -1>>()
-})
-
-test('number gets never', () => {
-  isType.equal<true, never, Max<number, 1>>()
-  isType.equal<true, never, Max<1, number>>()
-})
-
-test('override Fail case', () => {
-  isType.equal<true, number, Max<number, 1, number>>()
-})
-
-test('same number', () => {
-  isType.equal<true, 123, Max<123, 123>>()
-})
-
-test('same number of digits', () => {
-  isType.equal<true, 124, Max<123, 124>>()
-  isType.equal<true, 126, Max<126, 124>>()
-  isType.equal<true, 224, Max<126, 224>>()
-  isType.equal<true, 726, Max<726, 224>>()
-})
-
-test('more digits win', () => {
-  isType.equal<true, 123, Max<123, 22>>()
-  isType.equal<true, 223, Max<12, 223>>()
-  isType.equal<true, 1234567891011, Max<1234567891011, 123>>()
-  isType.equal<true, 1234567891011, Max<123, 1234567891011>>()
-})

package/src/math/Max.ts

@@ -1,31 +0,0 @@
-import { Head, Tail } from '../array'
-import { And, Equal } from '../predicates'
-import { Digit, DigitArray } from './Digit'
-import { IsPositive } from './IsPositive'
-import { IsWhole } from './IsWhole'
-
-export type Max<A extends number, B extends number, Fail = never> =
-  And<IsPositive<A>, IsWhole<A>> extends false ? Fail :
-  And<IsPositive<B>, IsWhole<B>> extends false ? Fail :
-  number extends A ? Fail :
-  number extends B ? Fail :
-  Equal<A, B> extends true ? A :
-  MaxOnPositiveWhole<A, B>
-
-type MaxOnPositiveWhole<A extends number, B extends number> = (
-  DigitArray.FromNumber<A> extends infer DA ? DA extends number[] ?
-  DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ?
-  MaxOnDigitArray<DA, DB> extends DA ? A : B
-  : never : never
-  : never : never
-)
-
-type MaxOnDigitArray<DA extends number[], DB extends number[]> =
-  Equal<DA['length'], DB['length']> extends true
-  ? (Equal<Head<DA>, Head<DB>> extends true
-    ? (Tail<DA> extends infer TDA ? TDA extends number[] ?
-      MaxOnDigitArray<TDA, Tail<DB>> extends TDA ? DA : DB
-      : never : never)
-    : Digit.GreaterThan<Head<DA>, Head<DB>> extends true ? DA : DB)
-  : MaxOnPositiveWhole<DA['length'], DB['length']> extends DA['length'] ? DA : DB
-

package/src/math/README.md

@@ -1,7 +0,0 @@
-# Math
-
-## References
-
-- [Implementing Arithmetic Within TypeScript’s Type System](https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f)
-- [typepark](https://github.com/kgtkr/typepark)
-- [typical](https://github.com/KiaraGrouwstra/typical/tree/master/src)

package/src/math/Subtract.spec.ts

@@ -1,40 +0,0 @@
-import { isType, Subtract } from '..'
-
-test('only support positive and whole number', () => {
-  isType.equal<true, never, Subtract<0.1, 1>>()
-  isType.equal<true, never, Subtract<-1, 1>>()
-  isType.equal<true, never, Subtract<1, 0.1>>()
-  isType.equal<true, never, Subtract<1, -1>>()
-})
-
-test('number gets Fail', () => {
-  isType.equal<true, never, Subtract<number, 1>>()
-  isType.equal<true, never, Subtract<1, number>>()
-})
-
-test('override Fail case', () => {
-  isType.equal<true, number, Subtract<number, 1, number>>()
-})
-
-test('single digit', () => {
-  isType.equal<true, 0, Subtract<0, 0>>()
-  isType.equal<true, 0, Subtract<1, 1>>()
-  isType.equal<true, 0, Subtract<2, 2>>()
-  isType.equal<true, 0, Subtract<3, 3>>()
-  isType.equal<true, 0, Subtract<4, 4>>()
-  isType.equal<true, 0, Subtract<5, 5>>()
-  isType.equal<true, 0, Subtract<6, 6>>()
-  isType.equal<true, 0, Subtract<7, 7>>()
-  isType.equal<true, 0, Subtract<8, 8>>()
-  isType.equal<true, 0, Subtract<9, 9>>()
-})
-
-test('multi digits', () => {
-  isType.equal<true, 100, Subtract<123, 23>>()
-  isType.equal<true, 6543, Subtract<7777, 1234>>()
-})
-
-test('negative results gets Fail', () => {
-  isType.equal<true, 'no~~', Subtract<1, 2, 'no~~'>>()
-  isType.equal<true, never, Subtract<12345, 12346>>()
-})

package/src/math/Subtract.ts

@@ -1,40 +0,0 @@
-import { PadLeft, Some, Tail } from '../array'
-import { And } from '../predicates'
-import { Digit, DigitArray } from './Digit'
-import { IsPositive } from './IsPositive'
-import { IsWhole } from './IsWhole'
-import { Max } from './Max'
-
-export type Subtract<A extends number, B extends number, Fail = never> =
-  And<
-    And<IsPositive<A>, IsWhole<A>>,
-    And<IsPositive<B>, IsWhole<B>>
-  > extends true
-  ? (DigitArray.Shift10<DigitArray.FromNumber<A>> extends infer DA ? DA extends number[] ?
-    DigitArray.FromNumber<B> extends infer DB ? DB extends number[] ?
-    Max<DA['length'], DB['length']> extends infer M ? M extends number ?
-    PadLeft<DA, M, 0> extends infer PDA ? PDA extends number[] ?
-    PadLeft<DB, M, 0> extends infer PDB ? PDB extends number[] ?
-    SubtractDigitArray<[], PDA, PDB> extends infer Result ? Result extends number[] ?
-    Some<Result, number, 'strict'> extends true ? Fail :
-    DigitArray.ToNumber<Result>
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail
-    : Fail : Fail)
-  : Fail
-
-type SubtractDigitArray<R extends number[], A extends number[], B extends number[]> =
-  A['length'] extends 0 ? R :
-  SubtractDigitArray<[...R, SubtractDigit<A[0], B[0]>], Tail<A>, Tail<B>>
-
-
-type SubtractDigit<A extends number, B extends number> =
-  Digit.ToTuple[A] extends [...(infer U), ...Digit.ToTuple[B]] ? U['length'] : never
-
-/**
- * A - 1
- */
-export type Decrement<A extends number, Fail = never> = Subtract<A, 1, Fail>

package/src/math/index.ts

@@ -1,7 +0,0 @@
-export * from './Abs'
-export * from './Add'
-export * from './GreaterThan'
-export * from './IsPositive'
-export * from './IsWhole'
-export * from './Max'
-export * from './Subtract'

package/src/nominal-types/Brand.spec.ts

@@ -1,43 +0,0 @@
-import { assertType, brand, CanAssign, Equal, flavor } from '..'
-import { isType } from '../predicates'
-
-describe('brand()', () => {
-  test('unbranded type cannot assign to branded type', () => {
-    const a = brand('a', { a: 1 })
-    const b = { a: 1 }
-    isType.f<CanAssign<typeof b, typeof a>>()
-  })
-  test('basic use case', () => {
-    const a = brand('a', { a: 1 as const })
-    const b = brand('b', { b: 'b' })
-
-    isType.f<CanAssign<typeof a, typeof b>>()
-    assertType<1>(a.a)
-    assertType<string>(b.b)
-  })
-  test('same brand of the same type can be assigned to each other', () => {
-    const a = brand('a', { a: 1 })
-    let b = brand('a', { a: 2 })
-
-    b = a
-    expect(b.a).toBe(1)
-  })
-  test('flavor with the same name cannot be assigned to brand', () => {
-    const b = brand('x', { a: 1 })
-    const f = flavor('x', { a: 1 })
-    isType.f<CanAssign<typeof f, typeof b>>()
-  })
-  test('without subject creates a typed brand creator', () => {
-    const createPerson = brand('person')
-    let person1 = createPerson(1)
-    let person2 = createPerson(2)
-
-    const createBlogPost = brand('Blog')
-    const blogPost = createBlogPost(1)
-
-    person1 = person2
-    person2 = person1
-
-    isType.f<Equal<typeof blogPost, typeof person1>>()
-  })
-})

package/src/nominal-types/Brand.ts

@@ -1,32 +0,0 @@
-// By Drew Colthorp, <https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/#comment-604580>
-// <https://gist.github.com/dcolthorp/aa21cf87d847ae9942106435bf47565d>
-
-import { Widen } from '../utils'
-import { typeSym, valueSym } from './types'
-
-/**
- * Create a "branded" version of a type.
- * TypeScript won't allow implicit conversion to this type
- */
-export type Brand<B extends string, T> =
-  T extends undefined | null | number | bigint | boolean
-  ? { [typeSym]: B, [valueSym]: T }
-  : T & { [typeSym]: B }
-
-/**
- * Creates a brand creator with the specified type.
- */
-export function brand<B extends string>(type: B): <T>(subject: T) => Brand<B, Widen<T>>
-/**
- * Creates a branded value of specified type.
- */
-export function brand<B extends string, T>(type: B, subject: T): Brand<B, Widen<T>>
-export function brand(type: string, subject?: any) {
-  if (subject === undefined) return function (subject: any) { return brand(type, subject) }
-
-  if (typeof subject === 'object' && subject !== null) {
-    // if subject is not an object, the branding will exist only in type-level.
-    (subject as any)[typeSym] = type
-  }
-  return subject
-}

package/src/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/src/nominal-types/Flavor.ts

@@ -1,34 +0,0 @@
-// By Drew Colthorp, <https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/#comment-604580>
-// <https://gist.github.com/dcolthorp/aa21cf87d847ae9942106435bf47565d>
-
-import { Widen } from '../utils'
-import { typeSym } from './types'
-
-/**
- * Create a "flavored" version of a type.
- * TypeScript will disallow mixing flavors,
- * but will allow unflavored values of that type to be passed in where a flavored version is expected.
- * This is a less restrictive form of branding.
- */
-export type Flavor<F extends string, T> = T & {
-  [typeSym]?: F
-}
-
-/**
- * Creates a brand creator with the specified type.
- */
-export function flavor<F extends string>(type: F): <T>(subject: T) => Flavor<F, Widen<T>>
-/**
- * Creates a branded value of specified type.
- */
-export function flavor<F extends string, T>(type: F, subject: T): Flavor<F, Widen<T>>
-export function flavor(type: string, subject?: any) {
-  if (subject === undefined) {
-    return function (subject: any) { return flavor(type, subject) }
-  }
-  if (typeof subject === 'object' && subject !== null) {
-    // if subject is not an object, the branding will exist only in type-level.
-    (subject as any)[typeSym] = type
-  }
-  return subject
-}

package/src/object/ANotB.ts

@@ -1,21 +0,0 @@
-import { Equal } from '../predicates'
-import { AnyRecord } from './AnyRecord'
-import { IsDisjoint } from './IsDisjoint'
-import { KeysWithDiffType } from './KeysWithDiffType'
-
-export type ANotB<A extends AnyRecord, B extends AnyRecord> =
-  Equal<A, B> extends true
-  ? never
-  : (IsDisjoint<A, B> extends true
-    ? A
-    : { [k in Exclude<keyof A, keyof B> | KeysWithDiffType<A, B>]: A[k] })
-
-export type BNotA<A extends AnyRecord, B extends AnyRecord> = ANotB<B, A>
-
-export type LeftJoin<A extends AnyRecord, B extends AnyRecord> =
-  Equal<A, B> extends true
-  ? A
-  : (IsDisjoint<A, B> extends true
-    ? A & B
-    : { [k in Exclude<keyof A, keyof B>]: A[k] } & { [k in keyof B]: B[k] }
-  )

package/src/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 = { age: 0 } as any
-  assertType.isNumber(x.age)
-})

package/src/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/src/object/IsDisjoint.ts

@@ -1,12 +0,0 @@
-import { And, Not } from '../predicates'
-import { AnyRecord } from './AnyRecord'
-import { HasKey } from './hasKey'
-
-/**
- * Are the two records disjoint from each other.
- * Disjoint means no common property.
- */
-export type IsDisjoint<
-  A extends AnyRecord,
-  B extends AnyRecord
-  > = And<Not<HasKey<A, keyof B>>, Not<HasKey<B, keyof A>>>

package/src/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/src/object/IsRecord.ts

@@ -1,4 +0,0 @@
-export type IsRecord<T> = T extends any[]
-? false
-: T extends Record<any, any>
-? true : false

package/src/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/src/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/src/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/src/object/KnownKeys.ts

@@ -1,16 +0,0 @@
-// Original by Klaus Meinhardt @ajafff
-// known from Gerrit Birkeland @Gerrit0
-// https://github.com/Microsoft/TypeScript/issues/25987#issuecomment-408339599
-
-import { PrimitiveTypes } from '../PrimitiveTypes'
-
-// https://github.com/microsoft/TypeScript/issues/25987#issuecomment-441224690
-export type KnownKeys<T> =
-  T extends PrimitiveTypes
-  ? never
-  : {
-    [K in keyof T]: string extends K ? never : number extends K ? never : K
-  } extends { [_ in keyof T]: infer U }
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  ? ({} extends U ? never : U)
-  : never

package/src/object/Partial.spec.ts

@@ -1,50 +0,0 @@
-import { assertType, PartialExcept, PartialOmit, PartialPick } from '..'
-
-test('work on primitive type', () => {
-  type Foo = PartialPick<number, 'toFixed'>
-  const x: Foo = 1 as any
-  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 } as any
-
-  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 } as any
-
-  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 } as any
-
-  assertType.noUndefined(y.a)
-  y.b = undefined
-  y.c = undefined
-})

package/src/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<typeof x, U> {
-    return x as any
-  }
-
-  function acceptU(x: U) {
-    return x
-  }
-})

package/src/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 } as any
-
-  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 } as any
-
-  y.a = undefined
-  assertType.noUndefined(y.b)
-  assertType.noUndefined(y.c)
-})

package/src/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/src/object/SpreadRecord.ts

@@ -1,6 +0,0 @@
-import { Omit } from '../object'
-
-export type SpreadRecord<
-A extends Record<any, any>,
-B extends Record<any, any>
-> = Omit<A, Extract<keyof A, keyof B>> & B