type-plus 3.12.2 → 3.15.0

package/ts/object/pick.ts

@@ -0,0 +1,35 @@
+import { UnionKeys } from '../UnionKeys'
+import { AnyRecord } from './AnyRecord'
+import { reduceByKey } from './reduceKey'
+
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Pick<T, P1>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2): Pick<T, P1 | P2>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
+export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>, P3 extends UnionKeys<T>, P4 extends UnionKeys<T>, P5 extends UnionKeys<T>, P6 extends UnionKeys<T>, P7 extends UnionKeys<T>, P8 extends UnionKeys<T>, P9 extends UnionKeys<T>, P10 extends UnionKeys<T>, P11 extends UnionKeys<T>, P12 extends UnionKeys<T>>(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5, prop6: P6, prop7: P7, prop8: P8, prop9: P9, prop10: P10, prop11: P11, prop12: P12): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
+export function pick<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
+  return reduceByKey(subject, (p, k) => {
+    if (props.indexOf(k) >= 0) p[k] = subject[k]
+    return p
+  }, {} as T)
+}
+
+/**
+ * Pick properties `K` from `T`.
+ * Works with union.
+ *
+ * Original type by Titian Cernicova-Dragomir
+ * @see <https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347>
+ */
+export type Pick<T, K extends UnionKeys<T>> = T extends unknown ? Pick._<T, keyof T & K> : never
+
+export namespace Pick {
+  export type _<T, K extends keyof T> = { [P in K]: T[P] }
+}

package/ts/object/typeOverrideIncompatible.spec.ts

@@ -0,0 +1,24 @@
+import { typeOverrideIncompatible } from '..'
+
+test('same type override has no property', () => {
+  type A = { a: 1 }
+  const transform = typeOverrideIncompatible<A>()
+
+  // TODO: find a way to assert `override` has no property
+  transform({ a: 1 }, {})
+})
+
+test('disjoint type override is A', () => {
+  type A = { a: 1 }
+  const transform = typeOverrideIncompatible<A>()
+
+  transform({ b: 2 }, { a: 1 })
+})
+
+test('intersect type override is ANotB', () => {
+  const a = { a: 1, b: 2 } as const
+  const b = { b: 3, c: 3 } as const
+  const transform = typeOverrideIncompatible<typeof a>()
+
+  transform(b, { a: 1, b: 2 })
+})

package/ts/object/typeOverrideIncompatible.ts

@@ -0,0 +1,10 @@
+import { ANotB, AnyRecord } from '.'
+
+export function typeOverrideIncompatible<A extends AnyRecord>() {
+  return function <B extends AnyRecord>(source: B, override: ANotB<A, B>): A {
+    return {
+      ...source,
+      ...override,
+    }
+  }
+}

package/ts/predicates/CanAssign.spec.ts

@@ -0,0 +1,57 @@
+import { assertType, CanAssign, canAssign } from '..'
+
+describe('CanAssign<A, B>', () => {
+  test('literal type to widen', () => {
+    assertType.isTrue(true as CanAssign<1, number>)
+    assertType.isTrue(true as CanAssign<1, 1>)
+    assertType.isTrue(true as CanAssign<number, number>)
+    assertType.isTrue(true as CanAssign<'a', string>)
+    assertType.isTrue(true as CanAssign<'a', 'a'>)
+    assertType.isTrue(true as CanAssign<string, string>)
+    assertType.isTrue(true as CanAssign<false, boolean>)
+    assertType.isTrue(true as CanAssign<true, boolean>)
+    assertType.isTrue(true as CanAssign<boolean, boolean>)
+  })
+  test('base type to literal type fails', () => {
+    assertType.isFalse(false as CanAssign<number, 1>)
+    assertType.isFalse(false as CanAssign<string, 'a'>)
+    assertType.isFalse(false as CanAssign<true, false>)
+    assertType.isFalse(false as CanAssign<false, true>)
+    assertType.isFalse(false as CanAssign<boolean, false>)
+    assertType.isFalse(false as CanAssign<boolean, true>)
+  })
+  test('super set to sub set', () => {
+    assertType.isTrue(true as CanAssign<{ a: string, b: number }, { a: string }>)
+  })
+  test('sub set to super set fail', () => {
+    assertType.isFalse(false as CanAssign<{ a: string }, { a: string, b: number }>)
+  })
+})
+
+describe('canAssign()', () => {
+  describe('without subject', () => {
+    test('returns a function that check type at compile time', () => {
+      assertType.isTrue(canAssign<{ a: string }>()({ a: 'a' }))
+      assertType.isTrue(canAssign<{ a: string }>()({ a: 'a', b: 'b' }))
+
+      // fails at compile time
+      // canAssign<{ a: string }>()({ a: 1 })
+    })
+    test('work with falsy value such as empty string', () => {
+      const s = ''
+      assertType.isTrue(canAssign<''>()(s))
+    })
+    test('work with undefined', () => {
+      assertType.isTrue(canAssign<number | undefined>()(undefined))
+    })
+    test('canAssign false', () => {
+      const t = canAssign<{ a: string }>(false)
+      assertType.isTrue(t(undefined))
+      assertType.isTrue(t({ a: 1 }))
+
+      // these fails
+      // t({ a: '' })
+      // t({ a: '', b: '' })
+    })
+  })
+})

package/ts/predicates/CanAssign.ts

@@ -0,0 +1,21 @@
+import { NotExtendable } from './Extends'
+import { IsEmptyObject } from './isEmptyObject'
+
+/**
+ * Can `A` assign to `B`
+ */
+export type CanAssign<A, B, Then = true, Else = false> =
+  IsEmptyObject<A> extends true
+  ? Record<string, unknown> extends B ? Then : Else
+  : boolean extends A
+  ? (boolean extends B ? Then : Else)
+  : A extends B ? Then : Else
+
+
+export type IsAssign<A, B, Then = true, Else = false> = CanAssign<A, B, Then, Else>
+
+export function canAssign<T>(canAssign: false): <S>(subject: NotExtendable<S, T>) => true
+export function canAssign<T>(): <S extends T>(subject: S) => CanAssign<S, T>
+export function canAssign<T>(): <S extends T>(subject: S) => any {
+  return () => true
+}

package/ts/predicates/Equal.spec.ts

@@ -0,0 +1,71 @@
+import { assertType, Equal, NotEqual } from '..'
+
+describe('TypeEquals', () => {
+  test('match', () => {
+    assertType.isTrue(true as Equal<false, false>)
+  })
+
+  test('not match', () => {
+    assertType.isFalse(false as Equal<string, number>)
+  })
+
+  test('literal is not equal to widen type', () => {
+    assertType.isFalse(false as Equal<1, number>)
+    assertType.isFalse(false as Equal<number, 1>)
+  })
+
+  test('super set and sub set are not equal', () => {
+    assertType.isFalse(false as Equal<{ a: 1 }, { a: 1, b: 2 }>)
+    assertType.isFalse(false as Equal<{ a: 1, b: 2 }, { a: 1 }>)
+  })
+
+  test('boolean', () => {
+    assertType.isTrue(true as Equal<boolean, boolean>)
+    assertType.isTrue(true as Equal<true, true>)
+    assertType.isTrue(true as Equal<false, false>)
+    assertType.isFalse(false as Equal<boolean, true>)
+    assertType.isFalse(false as Equal<true, boolean>)
+    assertType.isFalse(false as Equal<boolean, false>)
+    assertType.isFalse(false as Equal<false, boolean>)
+    assertType.isFalse(false as Equal<false, true>)
+    assertType.isFalse(false as Equal<true, false>)
+  })
+
+  test('same type is true', () => {
+    assertType.isTrue(true as Equal<{ a: 1 }, { a: 1 }>)
+  })
+
+  test('different type is false', () => {
+    assertType.isFalse(false as Equal<{ a: 1 }, { b: 1 }>)
+  })
+
+  test('A subset of B is false', () => {
+    assertType.isFalse(false as Equal<{ a: 1 }, { a: 1, b: 1 }>)
+  })
+
+  test('B subset of A is false', () => {
+    assertType.isFalse(false as Equal<{ a: 1, b: 1 }, { a: 1 }>)
+  })
+
+  test('disjoin is false', () => {
+    assertType.isFalse(false as Equal<{ b: 1 }, { a: 1 }>)
+  })
+
+  test('overlap is false', () => {
+    assertType.isFalse(false as Equal<{ a: 1, b: 1 }, { a: 1, c: 2 }>)
+  })
+})
+
+describe('TypeNotEquals', () => {
+  test('boolean', () => {
+    assertType.isFalse(false as NotEqual<boolean, boolean>)
+    assertType.isFalse(false as NotEqual<true, true>)
+    assertType.isFalse(false as NotEqual<false, false>)
+    assertType.isTrue(true as NotEqual<boolean, true>)
+    assertType.isTrue(true as NotEqual<true, boolean>)
+    assertType.isTrue(true as NotEqual<boolean, false>)
+    assertType.isTrue(true as NotEqual<false, boolean>)
+    assertType.isTrue(true as NotEqual<false, true>)
+    assertType.isTrue(true as NotEqual<true, false>)
+  })
+})

package/ts/predicates/Equal.ts

@@ -0,0 +1,14 @@
+/**
+ * Checks if two types are equal.
+ * Borrow from `typepark`.
+ * The simple `A extends B ? B extends A ? true : false : false`
+ * does not work with boolean type.
+ */
+export type Equal<A, B, Then = true, Else = false> =
+  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
+  ? Then : Else
+export type IsEqual<A, B> = Equal<A, B>
+
+export type NotEqual<A, B, Then = true, Else = false> =
+  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? Else : Then
+export type IsNotEqual<A, B> = NotEqual<A, B>

package/ts/predicates/Extends.ts

@@ -0,0 +1,4 @@
+export type Extendable<A, B> = A extends B ? A : never
+export type NotExtendable<A, B> = A extends B ? never : A
+export type IsExtend<A, B, Then = true, Else = false> = A extends B ? Then : Else
+export type IsNotExtend<A, B, Then = true, Else = false> = A extends B ? Else : Then

package/ts/predicates/If.spec.ts

@@ -0,0 +1,14 @@
+import { assertType, If, isType } from '..'
+
+test('true gets Then', () => {
+  assertType<If<true, 2, 3>>(2)
+})
+
+test('false gets Else', () => {
+  assertType<If<false, 2, 3>>(3)
+})
+
+test('Then defaults to true and Else defaults to false', () => {
+  isType.t<If<true>>()
+  isType.f<If<false>>()
+})

package/ts/predicates/If.ts

@@ -0,0 +1,5 @@
+export type If<
+  Condition extends boolean,
+  Then = true,
+  Else = false
+  > = Condition extends true ? Then : Else

package/ts/predicates/index.spec.ts

@@ -0,0 +1,73 @@
+import { IsAny, IsBoolean, IsLiteral, isType, PrimitiveTypes } from '..'
+
+describe('IsLiteral<T>', () => {
+  test('`number` is not literal', () => {
+    isType.equal<true, false, IsLiteral<number>>()
+  })
+
+  test('numeric literals are literals', () => {
+    isType.equal<true, true, IsLiteral<1>>()
+    isType.equal<true, true, IsLiteral<12345>>()
+  })
+
+  test('`string` is not literal', () => {
+    isType.equal<true, false, IsLiteral<string>>()
+  })
+
+  test('string literals are literals', () => {
+    isType.equal<true, true, IsLiteral<'1'>>()
+    isType.equal<true, true, IsLiteral<'abc'>>()
+  })
+
+  test('override Then/Else', () => {
+    isType.equal<true, 'yes', IsLiteral<'1', 'yes'>>()
+    isType.equal<true, 'no', IsLiteral<string, 'yes', 'no'>>()
+  })
+})
+
+describe('IsBoolean<T>', () => {
+  test('boolean/true/false', () => {
+    isType.equal<true, true, IsBoolean<boolean>>()
+    isType.equal<true, false, IsBoolean<false>>()
+    isType.equal<true, false, IsBoolean<true>>()
+  })
+  test('override Then/Else', () => {
+    isType.equal<true, 'yes', IsBoolean<boolean, 'yes'>>()
+    isType.equal<true, 'no', IsBoolean<1, 'yes', 'no'>>()
+  })
+})
+
+describe('IsAny<T>', () => {
+  test('any is true', () => {
+    isType.equal<true, true, IsAny<any>>()
+  })
+
+  test('string is false', () => {
+    isType.equal<true, false, IsAny<string>>()
+  })
+
+  test('other singular types are false', () => {
+    isType.equal<true, false, IsAny<undefined>>()
+    isType.equal<true, false, IsAny<null>>()
+    isType.equal<true, false, IsAny<number>>()
+    isType.equal<true, false, IsAny<boolean>>()
+    isType.equal<true, false, IsAny<string>>()
+    isType.equal<true, false, IsAny<symbol>>()
+    isType.equal<true, false, IsAny<unknown>>()
+    isType.equal<true, false, IsAny<never>>()
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    isType.equal<true, false, IsAny<{}>>()
+    isType.equal<true, false, IsAny<void>>()
+  })
+
+  test('union types are false', () => {
+    isType.equal<true, false, IsAny<
+      undefined | null | number | boolean | string |
+      // eslint-disable-next-line @typescript-eslint/ban-types
+      symbol | unknown | never | void | object>>()
+  })
+
+  test('union of all types is true', () => {
+    isType.equal<true, true, IsAny<PrimitiveTypes>>()
+  })
+})

package/ts/predicates/index.ts

@@ -0,0 +1,17 @@
+export * from './CanAssign'
+export * from './Equal'
+export * from './Extends'
+export * from './If'
+export * from './isType'
+export * from './logical'
+export * from './isEmptyObject'
+
+import { IsExtend } from './Extends'
+
+export type IsLiteral<T extends number | string, Then = true, Else = false> = number extends T ?
+  Else :
+  string extends T ? Else : Then
+
+export type IsBoolean<T, Then = true, Else = false> = boolean extends T ? Then : Else
+
+export type IsAny<T, Then = true, Else = false> = boolean extends IsExtend<T, string> ? Then : Else

package/ts/predicates/isEmptyObject.spec.ts

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { IsEmptyObject } from '..'
+import { isType } from './isType'
+
+test('true for {}', () => {
+  isType.t<IsEmptyObject<{}>>()
+})
+test('false for everything else', () => {
+  isType.f<IsEmptyObject<undefined>>()
+  isType.f<IsEmptyObject<false>>()
+  isType.f<IsEmptyObject<0>>()
+  isType.f<IsEmptyObject<''>>()
+  isType.f<IsEmptyObject<{ a: 1 }>>()
+})
+

package/ts/predicates/isEmptyObject.ts

@@ -0,0 +1,2 @@
+/* eslint-disable @typescript-eslint/ban-types */
+export type IsEmptyObject<T> = T extends {} ? {} extends T ? true : false : false

package/ts/predicates/isType.spec.ts

@@ -0,0 +1,106 @@
+import { assertType, Equal, isType } from '..'
+
+describe('isType()', () => {
+  describe('without validator', () => {
+    test('subject type is checked at compile time', () => {
+      const subject = { a: 1, b: 2 } as const
+      if (isType<{ a: 1 }>(subject)) {
+        assertType<{ a: 1 }>(subject)
+      }
+    })
+    test('work with falsy value such as empty string', () => {
+      const s = ''
+      if (isType<''>(s)) {
+        assertType<''>(s)
+      }
+    })
+  })
+  describe('with validator function', () => {
+    test('Specify T in the validate function', () => {
+      const s: unknown = false
+      if (isType(s, (s: boolean) => typeof s === 'boolean'))
+        assertType<boolean>(s)
+    })
+    test('Specify T at type declaration', () => {
+      const s: unknown = false
+      if (isType<boolean>(s, s => typeof s === 'boolean'))
+        assertType<boolean>(s)
+    })
+    test('exclude type if type guard fails', () => {
+      const s: string | number = 1
+      if (isType<string>(s, s => typeof s === 'string')) {
+        assertType<string>(s)
+      }
+      else {
+        assertType<number>(s)
+      }
+    })
+  })
+  describe('with class', () => {
+    test('Class as validator', () => {
+      const s: unknown = new Error()
+      if (isType(s, Error))
+        assertType<Error>(s)
+    })
+    test('Class as validator fails', () => {
+      class Foo { a() { } }
+      const s: Foo | number = 1
+      if (isType(s, Foo)) {
+        assertType<Foo>(s)
+      }
+      else {
+        assertType<number>(s)
+      }
+    })
+    test('subject can be type any', () => {
+      const s: any = false
+      if (isType<boolean>(s, s => typeof s === 'boolean'))
+        assertType<boolean>(s)
+    })
+  })
+})
+
+describe('isType.t()', () => {
+  test('accept true type but not false or boolean', () => {
+    expect(isType.t<true>()).toBe(true)
+    expect(isType.t<Equal<1, 1>>()).toBe(true)
+
+    // these fails
+    // isType.t<false>()
+    // isType.t<boolean>()
+  })
+  test('accept value with type true but not false or boolean', () => {
+    expect(isType.t(true)).toBe(true)
+
+    // these fails
+    // isType.t(false)
+    // isType.t(1 === 1)
+  })
+})
+
+describe('isType.f()', () => {
+  test('accept false type but not true or boolean', () => {
+    expect(isType.f<false>()).toBe(true)
+    expect(isType.f<Equal<1, 2>>()).toBe(true)
+
+    // these fails
+    // isType.f<true>()
+    // isType.f<boolean>()
+  })
+  test('accept value with type true but not false or boolean', () => {
+    expect(isType.f(false)).toBe(true)
+
+    // these fails
+    // isType.f(true)
+    // isType.f(1 !== 1)
+  })
+})
+
+describe('isType.equal()', () => {
+  test('true case', () => {
+    isType.equal<true, 1, 1>()
+  })
+  test('false case', () => {
+    isType.equal<false, '1', 1>()
+  })
+})

package/ts/predicates/isType.ts

@@ -0,0 +1,30 @@
+import { AnyConstructor, isConstructor } from '../class'
+import { Equal } from './Equal'
+
+export function isType<T>(subject: T): subject is T
+export function isType<T>(subject: unknown, validator: (s: T) => boolean): subject is T
+export function isType<T extends AnyConstructor>(subject: unknown, constructor: T): subject is InstanceType<T>
+export function isType(subject: unknown, validator?: AnyConstructor | ((s: unknown) => boolean)) {
+  if (validator) {
+    if (isConstructor(validator))
+      return subject instanceof validator
+    else
+      return validator(subject)
+  }
+  return true
+}
+
+isType.t = function <T extends true>(subject?: T) {
+  return subject === undefined || subject === true
+}
+isType.f = function <T extends false>(subject?: T) {
+  return subject === undefined || subject === false
+}
+
+/**
+ * are types A and B equals/not equals.
+ * Slightly easier to use then `isType.t<>()` and `isType.f<>()`,
+ * when doing type level only equality comparison as you don't have to import `Equal<>`.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+isType.equal = function <C extends Equal<A, B>, A, B>() { }

package/ts/predicates/logical.spec.ts

@@ -0,0 +1,59 @@
+import { And, assertType, Equal, Not, Or, Xor } from '..'
+
+describe('And<A,B>', () => {
+  test('basic', () => {
+    assertType.isTrue(true as And<true, true>)
+    assertType.isFalse(false as And<true, false>)
+    assertType.isFalse(false as And<false, true>)
+    assertType.isFalse(false as And<false, false>)
+  })
+  test('boolean special handling', () => {
+    assertType.isTrue(true as Equal<And<boolean, true>, boolean>)
+    assertType.isFalse(false as And<boolean, false>)
+    assertType.isTrue(true as Equal<And<true, boolean>, boolean>)
+    assertType.isFalse(false as And<false, boolean>)
+    assertType.isTrue(true as Equal<And<boolean, boolean>, boolean>)
+  })
+})
+
+describe('Or<A,B>', () => {
+  test('basic', () => {
+    assertType.isTrue(true as Or<true, true>)
+    assertType.isTrue(true as Or<true, false>)
+    assertType.isTrue(true as Or<false, true>)
+    assertType.isFalse(false as Or<false, false>)
+  })
+  test('boolean special handling', () => {
+    assertType.isTrue(true as Or<boolean, true>)
+    assertType.isTrue(true as Equal<Or<boolean, false>, boolean>)
+    assertType.isTrue(true as Or<true, boolean>)
+    assertType.isTrue(true as Equal<Or<false, boolean>, boolean>)
+    assertType.isTrue(true as Equal<Or<boolean, boolean>, boolean>)
+  })
+})
+
+describe('Xor<A,B>', () => {
+  test('basic', () => {
+    assertType.isFalse(false as Xor<true, true>)
+    assertType.isTrue(true as Xor<true, false>)
+    assertType.isTrue(true as Xor<false, true>)
+    assertType.isFalse(false as Xor<false, false>)
+  })
+  test('boolean special handling', () => {
+    assertType.isTrue(true as Equal<Xor<boolean, true>, boolean>)
+    assertType.isTrue(true as Equal<Xor<boolean, false>, boolean>)
+    assertType.isTrue(true as Equal<Xor<true, boolean>, boolean>)
+    assertType.isTrue(true as Equal<Xor<false, boolean>, boolean>)
+    assertType.isTrue(true as Equal<Xor<boolean, boolean>, boolean>)
+  })
+})
+
+describe('Not<X>', () => {
+  test('basic', () => {
+    assertType.isTrue(true as Not<false>)
+    assertType.isFalse(false as Not<true>)
+  })
+  test('boolean special handling', () => {
+    assertType.isTrue(true as Equal<Not<boolean>, boolean>)
+  })
+})

package/ts/predicates/logical.ts

@@ -0,0 +1,4 @@
+export type And<A extends boolean, B extends boolean> = A extends true ? B extends true ? true : false : false
+export type Or<A extends boolean, B extends boolean> = A extends true ? true : B extends true ? true : false
+export type Not<X extends boolean> = X extends true ? false : true
+export type Xor<A extends boolean, B extends boolean> = A extends true ? Not<B> : B extends true ? true : false

package/ts/promise/PromiseValue.spec.ts

@@ -0,0 +1,6 @@
+import { assertType, PromiseValue } from '..'
+
+test('extract value from Promise', () => {
+  const y: PromiseValue<Promise<string>> = ''
+  assertType.isString(y)
+})

package/ts/promise/isPromise.ts

@@ -0,0 +1,4 @@
+export function isPromise<R = any>(subject: unknown): subject is Promise<R> {
+  // @ts-ignore
+  return !!subject && typeof subject['then'] === 'function'
+}

package/ts/promise/mapSeries.ts

@@ -0,0 +1,5 @@
+export function mapSeries<R, T = any>(values: T[], fn: (value: T) => Promise<R>): Promise<R[]> {
+  return values.reduce(
+    (p, v) => p.then(r => fn(v).then(v => (r.push(v), r))),
+    Promise.resolve<R[]>([]))
+}

package/ts/type-checker/AnyType.ts

@@ -0,0 +1,13 @@
+import { TypeAnalysis, Type, TypeSpec } from './types'
+
+export type Any = Type<'any', undefined>
+export namespace Any {
+  export type Analysis = TypeAnalysis<'any'>
+}
+export const any: Any = { type: 'any', value: undefined }
+
+export const anySpec: TypeSpec<Any> = {
+  type: any,
+  toAnalysis: (options, value, _subject) => ({ type: 'any', value }),
+  toNative: (value) => value
+}