type-plus 3.13.0 → 4.0.0

package/ts/math/IsPositive.ts

@@ -0,0 +1,9 @@
+/**
+ * Check if type of positive number literal
+ * `number` type is false as it can be negative.
+ * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
+ */
+export type IsPositive<N extends number, Then = true, Else = false> =
+  number extends N
+  ? Else
+  : `${N}` extends `-${number}` ? Else : Then

package/ts/math/IsWhole.spec.ts

@@ -0,0 +1,19 @@
+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/IsWhole.ts

@@ -0,0 +1,9 @@
+/**
+ * Check if type is whole number literal.
+ * `number` type is false as it can be fractional.
+ * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
+ */
+export type IsWhole<N extends number, Then = true, Else = false> =
+  number extends N
+  ? Else
+  : `${N}` extends `${number}.${number}` ? Else : Then

package/ts/math/Max.spec.ts

@@ -0,0 +1,35 @@
+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/ts/math/Max.ts

@@ -0,0 +1,31 @@
+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/ts/math/README.md

@@ -0,0 +1,7 @@
+# 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/ts/math/Subtract.spec.ts

@@ -0,0 +1,40 @@
+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/math/Subtract.ts

@@ -0,0 +1,40 @@
+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, never, '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/ts/math/index.ts

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

package/ts/nodejs/index.ts

@@ -0,0 +1 @@
+export * from './isNodeError'

package/ts/nodejs/isNodeError.spec.ts

@@ -0,0 +1,11 @@
+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/nodejs/isNodeError.ts

@@ -0,0 +1,28 @@
+
+type SystemErrors = {
+  'EACCES': Error & { code: 'EACCES' },
+  'EADDRINUSE': Error & { code: 'EADDRINUSE' },
+  'ECONNREFUSED': Error,
+  'ECONNRESET': Error,
+  'EEXIST': Error,
+  'EISDIR': Error,
+  'EMFILE': Error,
+  'ENOENT': Error & { code: 'ENOENT', path: string },
+  'ENOTDIR': Error,
+  'ENOTEMPTY': Error,
+  'ENOTFOUND': Error,
+  'EPERM': Error,
+  'EPIPE': Error,
+  'ETIMEDOUT': Error,
+}
+
+export type SystemErrorCodes = keyof SystemErrors
+
+/**
+ * Type guard NodeJS SystemErrors.
+ * The list is not complete. Will add as needed.
+ * Feel free to contribute.
+ */
+export function isSystemError<C extends SystemErrorCodes>(code: C, err: unknown): err is SystemErrors[C] {
+  return !!err && (err as any).code === code
+}

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

@@ -0,0 +1,43 @@
+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/Brand.ts

@@ -0,0 +1,32 @@
+// 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?: unknown) {
+  if (subject === undefined) return function <T>(subject: T) { 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 { [typeSym]: string })[typeSym] = type
+  }
+  return subject
+}

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

@@ -0,0 +1,51 @@
+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/Flavor.ts

@@ -0,0 +1,32 @@
+// 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?: unknown) {
+  if (subject === undefined) return function <T>(subject: T) { 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 { [typeSym]: string })[typeSym] = type
+  }
+  return subject
+}

package/ts/object/ANotB.ts

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

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

@@ -0,0 +1,25 @@
+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/IsDisjoint.ts

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

@@ -0,0 +1,22 @@
+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/IsRecord.ts

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

package/ts/object/KeyofOptional.spec.ts

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

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

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

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