type-plus 4.9.1 → 4.10.2

package/ts/functional/compose.spec.ts

@@ -1,32 +0,0 @@
-import { compose, isType } from '..'
-
-test('works with endofunctors: +2 *3', () => {
-  const plus2 = (x: number) => x + 2
-  const multiply3 = (x: number) => x * 3
-
-  const a = compose(plus2, multiply3)
-
-  isType.equal<true, (a: number) => number, typeof a>()
-  expect(a(2)).toBe(12)
-})
-
-test('cross types', () => {
-  const n2s = (n: number) => String(n)
-  const len1 = (s: string) => s.length === 1
-
-  const isSingleDigit = compose(n2s, len1)
-
-  isType.equal<true, (n: number) => boolean, typeof isSingleDigit>()
-  expect(isSingleDigit(1)).toBe(true)
-  expect(isSingleDigit(10)).toBe(false)
-})
-
-test('multiple params first function', () => {
-  const add = (a: number, b: number) => a + b
-  const multiply3 = (x: number) => x * 3
-
-  const a = compose(add, multiply3)
-
-  isType.equal<true, (a: number, b: number) => number, typeof a>()
-  expect(a(2, 2)).toBe(12)
-})

package/ts/index.spec.ts

@@ -1,7 +0,0 @@
-// import { T, types } from '.'
-
-// test('export types also as T', () => {
-//   expect(T).toBe(types)
-// })
-
-test.todo('no test')

package/ts/math/Abs.spec.ts

@@ -1,14 +0,0 @@
-import { Abs, isType } from '..'
-
-test('positive returns itself', () => {
-  isType.equal<true, 1, Abs<1>>()
-})
-
-test('negative returns positive', () => {
-  isType.equal<true, 1234, Abs<-1234>>()
-})
-
-test('number returns Fail', () => {
-  isType.equal<true, never, Abs<number>>()
-  isType.equal<true, 0, Abs<number, 0>>()
-})

package/ts/math/Add.spec.ts

@@ -1,82 +0,0 @@
-import { Add, Increment, isType } from '..'
-
-describe('Add<A, B>', () => {
-  test('fractional A gets never', () => {
-    isType.equal<true, never, Add<1.1, 1>>()
-  })
-
-  test('negative A gets never', () => {
-    isType.equal<true, never, Add<-1, 1>>()
-  })
-
-  test('fractional B gets never', () => {
-    isType.equal<true, never, Add<1, 1.2>>()
-  })
-
-  test('negative B gets never', () => {
-    isType.equal<true, never, Add<1, -1>>()
-  })
-
-  test('number gets Fail', () => {
-    isType.equal<true, never, Add<number, 1>>()
-    isType.equal<true, never, Add<1, number>>()
-
-    isType.equal<true, number, Add<number, 1, number>>()
-    isType.equal<true, number, Add<1, number, number>>()
-  })
-
-  describe('single digit', () => {
-    test('0 + n = n', () => {
-      isType.equal<true, 0, Add<0, 0>>()
-      isType.equal<true, 1, Add<0, 1>>()
-      isType.equal<true, 2, Add<0, 2>>()
-      isType.equal<true, 3, Add<0, 3>>()
-      isType.equal<true, 4, Add<0, 4>>()
-      isType.equal<true, 5, Add<0, 5>>()
-      isType.equal<true, 6, Add<0, 6>>()
-      isType.equal<true, 7, Add<0, 7>>()
-      isType.equal<true, 8, Add<0, 8>>()
-      isType.equal<true, 9, Add<0, 9>>()
-    })
-    test('9 + n', () => {
-      isType.equal<true, 9, Add<9, 0>>()
-      isType.equal<true, 10, Add<9, 1>>()
-      isType.equal<true, 11, Add<9, 2>>()
-      isType.equal<true, 12, Add<9, 3>>()
-      isType.equal<true, 13, Add<9, 4>>()
-      isType.equal<true, 14, Add<9, 5>>()
-      isType.equal<true, 15, Add<9, 6>>()
-      isType.equal<true, 16, Add<9, 7>>()
-      isType.equal<true, 17, Add<9, 8>>()
-      isType.equal<true, 18, Add<9, 9>>()
-    })
-  })
-
-  test('1 + 2 digits', () => {
-    isType.equal<true, 16, Add<3, 13>>()
-    isType.equal<true, 108, Add<9, 99>>()
-  })
-
-  test('2 + 1 digits', () => {
-    isType.equal<true, 16, Add<13, 3>>()
-    isType.equal<true, 108, Add<99, 9>>()
-  })
-
-  test('2 + 2 digits', () => {
-    isType.equal<true, 20, Add<10, 10>>()
-    isType.equal<true, 38, Add<19, 19>>()
-  })
-
-  test('n + n digits', () => {
-    isType.equal<true, 7777, Add<1234, 6543>>()
-  })
-})
-
-describe('Increment<A>', () => {
-  test('add 1', () => {
-    isType.equal<true, 1, Increment<0>>()
-  })
-  test('work with large number', () => {
-    isType.equal<true, 7777, Increment<7776>>()
-  })
-})

package/ts/math/Digit.spec.ts

@@ -1,184 +0,0 @@
-import { Equal, isType } from '..'
-import { Digit, DigitArray } from './Digit'
-
-describe('DigitArray.ToNumber<DA>', () => {
-  test('no digit gets 0', () => {
-    type A = DigitArray.ToNumber<[]>
-    isType.t<Equal<A, 0>>()
-  })
-
-  test('single digit', () => {
-    isType.t<Equal<DigitArray.ToNumber<[0]>, 0>>()
-    isType.t<Equal<DigitArray.ToNumber<[1]>, 1>>()
-    isType.t<Equal<DigitArray.ToNumber<[2]>, 2>>()
-    isType.t<Equal<DigitArray.ToNumber<[3]>, 3>>()
-    isType.t<Equal<DigitArray.ToNumber<[4]>, 4>>()
-    isType.t<Equal<DigitArray.ToNumber<[5]>, 5>>()
-    isType.t<Equal<DigitArray.ToNumber<[6]>, 6>>()
-    isType.t<Equal<DigitArray.ToNumber<[7]>, 7>>()
-    isType.t<Equal<DigitArray.ToNumber<[8]>, 8>>()
-    isType.t<Equal<DigitArray.ToNumber<[9]>, 9>>()
-
-  })
-
-  test('two digits', () => {
-    isType.t<Equal<DigitArray.ToNumber<[1, 0]>, 10>>()
-    isType.t<Equal<DigitArray.ToNumber<[1, 0]>, 10>>()
-    isType.t<Equal<DigitArray.ToNumber<[3, 1]>, 31>>()
-    isType.t<Equal<DigitArray.ToNumber<[13, 1]>, 131>>()
-    isType.t<Equal<DigitArray.ToNumber<[1, 2, 3, 4]>, 1234>>()
-  })
-
-  test('multi digits', () => {
-    isType.t<Equal<DigitArray.ToNumber<[1, 2, 3, 4]>, 1234>>()
-    isType.t<Equal<DigitArray.ToNumber<[1, 2, 3, 5]>, 1235>>()
-  })
-})
-
-describe('DigitArray.Shift10<DA>', () => {
-  test('zero digit gets the same', () => {
-    isType.equal<true, [], DigitArray.Shift10<[]>>()
-  })
-
-  test('single digit gets the same', () => {
-    isType.equal<true, [5], DigitArray.Shift10<[5]>>()
-  })
-
-  test('two digits with leading 0 get trimmed', () => {
-    isType.equal<true, [5], DigitArray.Shift10<[0, 5]>>()
-  })
-  test('two digits gets value shifted', () => {
-    isType.equal<true, [15], DigitArray.Shift10<[1, 5]>>()
-    isType.equal<true, [8, 10], DigitArray.Shift10<[9, 0]>>()
-    isType.equal<true, [8, 19], DigitArray.Shift10<[9, 9]>>()
-  })
-  test('multiple digits', () => {
-    isType.equal<true, [11, 12, 14], DigitArray.Shift10<[0, 1, 2, 3, 4]>>()
-  })
-})
-
-describe('Digit.GreaterThan<A, B>', () => {
-  test('n > n is false', () => {
-    isType.equal<true, false, Digit.GreaterThan<0, 0>>()
-    isType.equal<true, false, Digit.GreaterThan<1, 1>>()
-    isType.equal<true, false, Digit.GreaterThan<2, 2>>()
-    isType.equal<true, false, Digit.GreaterThan<3, 3>>()
-    isType.equal<true, false, Digit.GreaterThan<4, 4>>()
-    isType.equal<true, false, Digit.GreaterThan<5, 5>>()
-    isType.equal<true, false, Digit.GreaterThan<6, 6>>()
-    isType.equal<true, false, Digit.GreaterThan<7, 7>>()
-    isType.equal<true, false, Digit.GreaterThan<8, 8>>()
-    isType.equal<true, false, Digit.GreaterThan<9, 9>>()
-  })
-  test('N > m is true', () => {
-    isType.equal<true, true, Digit.GreaterThan<1, 0>>()
-    isType.equal<true, true, Digit.GreaterThan<2, 0>>()
-    isType.equal<true, true, Digit.GreaterThan<3, 0>>()
-    isType.equal<true, true, Digit.GreaterThan<4, 0>>()
-    isType.equal<true, true, Digit.GreaterThan<5, 0>>()
-    isType.equal<true, true, Digit.GreaterThan<6, 0>>()
-    isType.equal<true, true, Digit.GreaterThan<7, 0>>()
-    isType.equal<true, true, Digit.GreaterThan<8, 0>>()
-    isType.equal<true, true, Digit.GreaterThan<9, 0>>()
-
-    isType.equal<true, true, Digit.GreaterThan<2, 1>>()
-    isType.equal<true, true, Digit.GreaterThan<3, 1>>()
-    isType.equal<true, true, Digit.GreaterThan<4, 1>>()
-    isType.equal<true, true, Digit.GreaterThan<5, 1>>()
-    isType.equal<true, true, Digit.GreaterThan<6, 1>>()
-    isType.equal<true, true, Digit.GreaterThan<7, 1>>()
-    isType.equal<true, true, Digit.GreaterThan<8, 1>>()
-    isType.equal<true, true, Digit.GreaterThan<9, 1>>()
-
-    isType.equal<true, true, Digit.GreaterThan<3, 2>>()
-    isType.equal<true, true, Digit.GreaterThan<4, 2>>()
-    isType.equal<true, true, Digit.GreaterThan<5, 2>>()
-    isType.equal<true, true, Digit.GreaterThan<6, 2>>()
-    isType.equal<true, true, Digit.GreaterThan<7, 2>>()
-    isType.equal<true, true, Digit.GreaterThan<8, 2>>()
-    isType.equal<true, true, Digit.GreaterThan<9, 2>>()
-
-    isType.equal<true, true, Digit.GreaterThan<4, 3>>()
-    isType.equal<true, true, Digit.GreaterThan<5, 3>>()
-    isType.equal<true, true, Digit.GreaterThan<6, 3>>()
-    isType.equal<true, true, Digit.GreaterThan<7, 3>>()
-    isType.equal<true, true, Digit.GreaterThan<8, 3>>()
-    isType.equal<true, true, Digit.GreaterThan<9, 3>>()
-
-    isType.equal<true, true, Digit.GreaterThan<5, 4>>()
-    isType.equal<true, true, Digit.GreaterThan<6, 4>>()
-    isType.equal<true, true, Digit.GreaterThan<7, 4>>()
-    isType.equal<true, true, Digit.GreaterThan<8, 4>>()
-    isType.equal<true, true, Digit.GreaterThan<9, 4>>()
-
-    isType.equal<true, true, Digit.GreaterThan<6, 5>>()
-    isType.equal<true, true, Digit.GreaterThan<7, 5>>()
-    isType.equal<true, true, Digit.GreaterThan<8, 5>>()
-    isType.equal<true, true, Digit.GreaterThan<9, 5>>()
-
-    isType.equal<true, true, Digit.GreaterThan<7, 6>>()
-    isType.equal<true, true, Digit.GreaterThan<8, 6>>()
-    isType.equal<true, true, Digit.GreaterThan<9, 6>>()
-
-    isType.equal<true, true, Digit.GreaterThan<8, 7>>()
-    isType.equal<true, true, Digit.GreaterThan<9, 7>>()
-
-    isType.equal<true, true, Digit.GreaterThan<9, 8>>()
-  })
-
-  test('n > M is false', () => {
-    isType.equal<true, false, Digit.GreaterThan<0, 1>>()
-    isType.equal<true, false, Digit.GreaterThan<0, 2>>()
-    isType.equal<true, false, Digit.GreaterThan<0, 3>>()
-    isType.equal<true, false, Digit.GreaterThan<0, 4>>()
-    isType.equal<true, false, Digit.GreaterThan<0, 5>>()
-    isType.equal<true, false, Digit.GreaterThan<0, 6>>()
-    isType.equal<true, false, Digit.GreaterThan<0, 7>>()
-    isType.equal<true, false, Digit.GreaterThan<0, 8>>()
-    isType.equal<true, false, Digit.GreaterThan<0, 9>>()
-
-    isType.equal<true, false, Digit.GreaterThan<1, 2>>()
-    isType.equal<true, false, Digit.GreaterThan<1, 3>>()
-    isType.equal<true, false, Digit.GreaterThan<1, 4>>()
-    isType.equal<true, false, Digit.GreaterThan<1, 5>>()
-    isType.equal<true, false, Digit.GreaterThan<1, 6>>()
-    isType.equal<true, false, Digit.GreaterThan<1, 7>>()
-    isType.equal<true, false, Digit.GreaterThan<1, 8>>()
-    isType.equal<true, false, Digit.GreaterThan<1, 9>>()
-
-    isType.equal<true, false, Digit.GreaterThan<2, 3>>()
-    isType.equal<true, false, Digit.GreaterThan<2, 4>>()
-    isType.equal<true, false, Digit.GreaterThan<2, 5>>()
-    isType.equal<true, false, Digit.GreaterThan<2, 6>>()
-    isType.equal<true, false, Digit.GreaterThan<2, 7>>()
-    isType.equal<true, false, Digit.GreaterThan<2, 8>>()
-    isType.equal<true, false, Digit.GreaterThan<2, 9>>()
-
-    isType.equal<true, false, Digit.GreaterThan<3, 4>>()
-    isType.equal<true, false, Digit.GreaterThan<3, 5>>()
-    isType.equal<true, false, Digit.GreaterThan<3, 6>>()
-    isType.equal<true, false, Digit.GreaterThan<3, 7>>()
-    isType.equal<true, false, Digit.GreaterThan<3, 8>>()
-    isType.equal<true, false, Digit.GreaterThan<3, 9>>()
-
-    isType.equal<true, false, Digit.GreaterThan<4, 5>>()
-    isType.equal<true, false, Digit.GreaterThan<4, 6>>()
-    isType.equal<true, false, Digit.GreaterThan<4, 7>>()
-    isType.equal<true, false, Digit.GreaterThan<4, 8>>()
-    isType.equal<true, false, Digit.GreaterThan<4, 9>>()
-
-    isType.equal<true, false, Digit.GreaterThan<5, 6>>()
-    isType.equal<true, false, Digit.GreaterThan<5, 7>>()
-    isType.equal<true, false, Digit.GreaterThan<5, 8>>()
-    isType.equal<true, false, Digit.GreaterThan<5, 9>>()
-
-    isType.equal<true, false, Digit.GreaterThan<6, 7>>()
-    isType.equal<true, false, Digit.GreaterThan<6, 8>>()
-    isType.equal<true, false, Digit.GreaterThan<6, 9>>()
-
-    isType.equal<true, false, Digit.GreaterThan<7, 8>>()
-    isType.equal<true, false, Digit.GreaterThan<7, 9>>()
-
-    isType.equal<true, false, Digit.GreaterThan<8, 9>>()
-  })
-})

package/ts/math/GreaterThan.spec.ts

@@ -1,75 +0,0 @@
-import { GreaterThan, isType } from '..'
-
-test('only support whole number', () => {
-  isType.equal<true, never, GreaterThan<0.1, 1>>()
-  isType.equal<true, never, GreaterThan<1, 0.1>>()
-})
-
-test('number gets never', () => {
-  isType.equal<true, never, GreaterThan<number, 1>>()
-  isType.equal<true, never, GreaterThan<1, number>>()
-})
-
-test('override Fail case', () => {
-  isType.equal<true, number, GreaterThan<number, 2, number>>()
-})
-
-test('n > n is false', () => {
-  isType.equal<true, false, GreaterThan<0, 0>>()
-  isType.equal<true, false, GreaterThan<1, 1>>()
-  isType.equal<true, false, GreaterThan<12, 12>>()
-})
-
-test('with same number of digits', () => {
-  isType.equal<true, true, GreaterThan<1, 0>>()
-  isType.equal<true, true, GreaterThan<22, 11>>()
-  isType.equal<true, true, GreaterThan<20, 19>>()
-  isType.equal<true, true, GreaterThan<19, 10>>()
-
-  isType.equal<true, false, GreaterThan<0, 1>>()
-  isType.equal<true, false, GreaterThan<11, 22>>()
-  isType.equal<true, false, GreaterThan<19, 20>>()
-  isType.equal<true, false, GreaterThan<10, 19>>()
-})
-
-test('with different number of digits', () => {
-  isType.equal<true, false, GreaterThan<0, 1>>()
-  isType.equal<true, false, GreaterThan<9, 100>>()
-  isType.equal<true, true, GreaterThan<10, 1>>()
-  isType.equal<true, true, GreaterThan<123, 32>>()
-  isType.equal<true, true, GreaterThan<123, 13>>()
-})
-
-test('-0 > 0 and 0 > -0 are false', () => {
-  isType.equal<true, false, GreaterThan<-0, 0>>()
-  isType.equal<true, false, GreaterThan<0, -0>>()
-})
-
-test('works with negative numbers', () => {
-  isType.equal<true, true, GreaterThan<0, -1>>()
-  isType.equal<true, true, GreaterThan<1, -1>>()
-  isType.equal<true, true, GreaterThan<2, -1>>()
-
-  isType.equal<true, false, GreaterThan<-1, 0>>()
-  isType.equal<true, false, GreaterThan<-1, 1>>()
-  isType.equal<true, false, GreaterThan<-1, 2>>()
-
-  isType.equal<true, false, GreaterThan<-0, -0>>()
-  isType.equal<true, false, GreaterThan<-1, -1>>()
-
-  isType.equal<true, true, GreaterThan<-0, -1>>()
-  isType.equal<true, false, GreaterThan<-1, -1>>()
-  isType.equal<true, false, GreaterThan<-2, -1>>()
-
-  isType.equal<true, false, GreaterThan<-1, -0>>()
-  isType.equal<true, false, GreaterThan<-1, -1>>()
-  isType.equal<true, true, GreaterThan<-1, -2>>()
-})
-
-test('work with large numbers', () => {
-  isType.equal<true, true, GreaterThan<1000000, 0>>()
-  isType.equal<true, false, GreaterThan<0, 1000000>>()
-
-  isType.equal<true, false, GreaterThan<-1000000, 0>>()
-  isType.equal<true, true, GreaterThan<0, -1000000>>()
-})

package/ts/math/IsPositive.spec.ts

@@ -1,15 +0,0 @@
-import { IsPositive, isType } from '..'
-
-test('positive is true', () => {
-  isType.t<IsPositive<0>>()
-  isType.t<IsPositive<1>>()
-  isType.t(true)
-})
-
-test('negative is false', () => {
-  isType.f<IsPositive<-1>>()
-})
-
-test('number type is false because we cannot determine', () => {
-  isType.f<IsPositive<number>>()
-})

package/ts/math/IsWhole.spec.ts

@@ -1,19 +0,0 @@
-import { isType, IsWhole } from '..'
-
-test('whole number is true', () => {
-  isType.t<IsWhole<1>>()
-  isType.t<IsWhole<1.>>()
-  isType.t<IsWhole<0>>()
-  isType.t<IsWhole<0.>>()
-  isType.t<IsWhole<-0>>()
-  isType.t<IsWhole<-1>>()
-})
-
-test('fraction is false', () => {
-  isType.f<IsWhole<0.1>>()
-  isType.f<IsWhole<-0.1>>()
-})
-
-test('number type is false because we cannot determine', () => {
-  isType.f<IsWhole<number>>()
-})

package/ts/math/Max.spec.ts

@@ -1,59 +0,0 @@
-import { isType, Max } from '..'
-
-test('only support whole number', () => {
-  isType.equal<true, never, Max<0.1, 1>>()
-  isType.equal<true, never, Max<1, 0.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>>()
-})
-
-test('work with negative numbers', () => {
-  isType.equal<true, 0, Max<0, -0>>()
-  isType.equal<true, 0, Max<-0, 0>>()
-  isType.equal<true, 0, Max<-0, -0>>()
-
-  isType.equal<true, 0, Max<0, -1>>()
-  isType.equal<true, 1, Max<1, -1>>()
-  isType.equal<true, 2, Max<2, -1>>()
-
-  isType.equal<true, 0, Max<-1, 0>>()
-  isType.equal<true, 1, Max<-1, 1>>()
-  isType.equal<true, 2, Max<-1, 2>>()
-
-  isType.equal<true, -1, Max<-1, -2>>()
-  isType.equal<true, -2, Max<-2, -2>>()
-  isType.equal<true, -2, Max<-3, -2>>()
-})
-
-test('work with large numbers', () => {
-  isType.equal<true, 1000000, Max<1000000, 0>>()
-  isType.equal<true, 1000000, Max<0, 1000000>>()
-
-  isType.equal<true, 0, Max<-1000000, 0>>()
-  isType.equal<true, 0, Max<0, -1000000>>()
-})

package/ts/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<1233, 1234>>()
-})

package/ts/nodejs/isNodeError.spec.ts

@@ -1,11 +0,0 @@
-import { assertType, isSystemError } from '..'
-
-describe('isSystemError()', () => {
-  test('ENOENT', () => {
-    const s: unknown = {}
-    if (isSystemError('ENOENT', s)) {
-      assertType<'ENOENT'>(s.code)
-      assertType<string>(s.path)
-    }
-  })
-})

package/ts/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/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>>()
-  })
-})