type-plus 3.12.2 → 3.15.0

package/src/predicates/Extends.ts

@@ -1,4 +0,0 @@
-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/src/predicates/If.spec.ts

@@ -1,14 +0,0 @@
-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/src/predicates/If.ts

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

package/src/predicates/index.spec.ts

@@ -1,73 +0,0 @@
-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/src/predicates/index.ts

@@ -1,16 +0,0 @@
-export * from './CanAssign'
-export * from './Equal'
-export * from './Extends'
-export * from './If'
-export * from './isType'
-export * from './logical'
-
-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/src/predicates/isType.spec.ts

@@ -1,106 +0,0 @@
-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 as any
-      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 as any
-      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/src/predicates/isType.ts

@@ -1,32 +0,0 @@
-import { 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 new (...args: any) => any>(subject: unknown, constructor: T): subject is InstanceType<T>
-export function isType(subject: any, validator?: any) {
-  if (validator) {
-    if (isConstructor(validator))
-      return subject instanceof validator
-    else
-      return validator(subject)
-  }
-  return true
-}
-
-const sym = Symbol()
-
-isType.t = function <T extends true>(subject: T = sym as any) {
-  return (subject as any) === sym || subject === true
-}
-isType.f = function <T extends false>(subject: T = sym as any) {
-  return (subject as any) === sym || 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/src/predicates/logical.spec.ts

@@ -1,59 +0,0 @@
-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/src/predicates/logical.ts

@@ -1,4 +0,0 @@
-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/src/promise/PromiseValue.spec.ts

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

package/src/promise/isPromise.ts

@@ -1,3 +0,0 @@
-export function isPromise<R = any>(subject: any): subject is Promise<R> {
-  return !!subject && typeof subject.then === 'function'
-}

package/src/promise/mapSeries.ts

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

package/src/type-checker/AnyType.ts

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

package/src/type-checker/buildTypes.spec.ts

@@ -1,28 +0,0 @@
-// import { MapToProp } from '../array'
-// import { assertType } from '../assertion'
-// import * as T from '../types'
-// import { Checker } from './types'
-
-// export function buildTypes<Checkers extends Checker[]>(...checkers: Checkers) {
-//   const types = checkers.map(c => c.type).reduce((p, t) => ({ ...p, ...t }), {})
-//   types.satisfy = (type: any, subject: unknown) => true
-//   return types as unknown as MapToProp<Checkers, 'type'> & {
-//     satisfy<T extends MapToProp<Checkers, 'type'>>(type: T, subject: unknown): subject is T
-//   }
-// }
-
-// const any = { type: { any: { type: 'any', value: undefined } } }
-// const unknown = { type: { unknown: { type: 'unknown', value: undefined } } }
-
-// describe('checker: any', () => {
-//   test('cast to any', () => {
-//     const t = buildTypes(any, unknown)
-
-//     const s: unknown = 1
-//     if (t.satisfy(T.number, s)) {
-//       assertType.isNumber(s)
-//     }
-//   })
-// })
-
-test.todo('not ready')

package/src/types/Generate.ts

@@ -1,48 +0,0 @@
-import { Tail } from '../array'
-import { AllType } from './AllType'
-// import { KeyTypes } from '../object-key'
-import { Any } from './Any'
-import { Array } from './Array'
-// import { BigInt } from './BigInt'
-import { Boolean, False, True } from './Boolean'
-import { Null } from './Null'
-import { Number } from './Number'
-import { ObjectType } from './Object'
-import { Record } from './Record'
-import { String } from './String'
-import { Symbol } from './Symbol'
-import { Tuple } from './Tuple'
-import { Undefined } from './Undefined'
-import { Union } from './Union'
-import { Unknown } from './Unknown'
-
-export type Generate<T extends AllType> =
-  T extends Undefined ? undefined :
-  T extends Null ? null :
-  T extends True ? true :
-  T extends False ? false :
-  T extends Boolean ? boolean :
-  T extends Symbol ? symbol :
-  T extends Any ? any :
-  T extends Unknown ? unknown :
-  T extends Number ? T['value'] :
-  T extends String ? T['value'] :
-  T extends ObjectType ? { [K in keyof T['value']]: Generate<T['value'][K]> } :
-  T extends Record ? { [K: string]: Generate<T['value']> } :
-  T extends Array ? Generate<T['value']>[] :
-  T extends Tuple ? Generate._TupleDevice<T['value']>['result'] :
-  T extends Union ? Generate._UnionDevice<T['value']>['result'] :
-  // T extends BigInt ? T['value'] :
-  unknown
-
-export namespace Generate {
-  export type _UnionDevice<T extends AllType[]> = T['length'] extends 0
-    ? { result: never }
-    // @ts-ignore sometimes language service mark this as referencing itself
-    : { result: Generate<T[0]> | _UnionDevice<Tail<T>>['result'] }
-
-  export type _TupleDevice<T extends AllType[]> = T['length'] extends 0
-    ? { result: [] }
-    // @ts-ignore sometimes language service mark this as referencing itself
-    : { result: [Generate<T[0]>, ..._TupleDevice<Tail<T>>['result']] }
-}

package/src/types/Number.ts

@@ -1,56 +0,0 @@
-import { Tail } from '../array'
-import { Type } from './types'
-import { undef, Undefined } from './Undefined'
-import { Union, union } from './Union'
-
-export type Number<Value extends number = number> = Type<'number', Value>
-
-export namespace Number {
-  export type Analysis = {
-    type: 'number',
-    value?: number,
-    fail?: true
-  }
-}
-
-type NumberListDevice<Values extends number[] = number[]> = Values['length'] extends 0
-  ? { result: [] } : Values['length'] extends 1
-  ? { result: [Number<Values[0]>] }
-  : { result: [Number<Values[0]>, Number<Values[1]>, ...NumberListDevice<Tail<Tail<Values>>>['result']] }
-
-/**
- * Creates a single number type.
- */
-function create<Value extends number>(value: Value): Number<Value> {
-  return { type: 'number', value }
-}
-
-const any = create(undefined as unknown as number)
-
-export const number = Object.assign(any, {
-  any,
-  create,
-  // @ts-ignore we know that this can be infinite
-  list<Value extends number, Values extends number[]>(value: Value, ...values: Values): Union<
-    // @ts-ignore this seems to be a bug in TypeScript.
-    // It can recognize `NumberListDevice<[1,2,3]>['result']`
-    NumberListDevice<[Value, ...Values]>['result']
-  > {
-    return union.create(create(value), ...values.map(create)) as any
-  },
-  optional: Object.assign(union.create(any, undef), {
-    /**
-     * Creates an optional number constant type.
-     */
-    create<Value extends number>(value: Value): Union<[Number<Value>, Undefined]> {
-      return union.create(create(value), undef)
-    },
-    // @ts-ignore we know that this can be infinite
-    list<Value extends number, Values extends number[]>(value: Value, ...values: Values): Union<
-      // @ts-ignore this seems to be a bug in TypeScript.
-      [...NumberListDevice<[Value, ...Values]>['result'], Undefined]
-    > {
-      return union.create(create(value), ...values.map(create), undef) as any
-    }
-  })
-})

package/src/types/Object.ts

@@ -1,53 +0,0 @@
-import { KeyTypes, reduceByKey } from '../object'
-import { AllType } from './AllType'
-import { number } from './Number'
-import { string as str } from './String'
-import { symbol as sym } from './Symbol'
-import { Type } from './types'
-import { undef, Undefined } from './Undefined'
-import { union, Union } from './Union'
-
-export type ObjectType<
-  Props extends Record<string, AllType> = Record<string, any>
-  > = Type<'object', Props>
-
-export namespace ObjectType {
-  export type Analysis<
-    Value extends AllType.PrimitiveValues | AllType.Analysis = any
-    > = {
-      type: 'object',
-      value?: Record<string, Value>,
-      fail?: true
-    }
-}
-
-/**
- * create specific object type.
- */
-function create<Props extends Record<string, AllType>>(props: Props): ObjectType<Props> {
-  return { type: 'object', value: props }
-}
-
-const any = create(undefined as any)
-
-export function map<
-  T extends Record<KeyTypes, any>
->(callback: (value: any, key: keyof T, obj: Record<KeyTypes, any>) => any, subject: T) {
-  return reduceByKey(subject, (p, k) => (p[k] = callback(subject[k], k, p), p), {} as Record<any, any>)
-}
-
-export const object = Object.assign(any, {
-  any,
-  create,
-  map,
-  optional: Object.assign(union.create(any, undef), {
-    /**
-     * Creates an optional object type.
-     */
-    create<Props extends Record<string, AllType>>(props: Props): Union<[ObjectType<Props>, Undefined]> {
-      return union.create(create(props), undef)
-    }
-  })
-})
-
-export const keys = union.create(str, number, sym)

package/src/types/String.ts

@@ -1,56 +0,0 @@
-import { Tail } from '../array'
-import { Type } from './types'
-import { undef, Undefined } from './Undefined'
-import { Union, union } from './Union'
-
-export type String<Value extends string = string> = Type<'string', Value>
-
-export namespace String {
-  export type Analysis = {
-    type: 'string',
-    value?: string,
-    fail?: true
-  }
-}
-
-type StringListDevice<Values extends string[]> = Values['length'] extends 0
-  ? { result: [] } : Values['length'] extends 1
-  ? { result: [String<Values[0]>] }
-  : { result: [String<Values[0]>, String<Values[1]>, ...StringListDevice<Tail<Tail<Values>>>['result']] }
-
-/**
-* Creates a constant string type.
-*/
-function create<Value extends string>(value: Value): String<Value> {
-  // Cannot name this function as `const` because it is a reserved keyword.
-  return { type: 'string', value: value }
-}
-const any = create(undefined as unknown as string)
-
-export const string = Object.assign(any, {
-  any,
-  create,
-  // @ts-ignore we know that this can be infinite
-  list<Value extends string, Values extends string[]>(value: Value, ...values: Values): Union<
-    // @ts-ignore this seems to be a bug in TypeScript.
-    // It can recognize `StringListDevice<['a','b','c']>['result']`
-    StringListDevice<[Value, ...Values]>['result']
-  > {
-    return union.create(create(value), ...values.map(create)) as any
-  },
-  optional: Object.assign(union.create(any, undef), {
-    /**
-     * Creates an optional constant string type.
-     */
-    create<Value extends string>(value: Value): Union<[String<Value>, Undefined]> {
-      return union.create(create(value), undef)
-    },
-    // @ts-ignore we know that this can be infinite
-    list<Value extends string, Values extends string[]>(value: Value, ...values: Values): Union<
-      // @ts-ignore this seems to be a bug in TypeScript.
-      [...StringListDevice<[Value, ...Values]>['result'], Undefined]
-    > {
-      return union.create(create(value), ...values.map(create), undef) as any
-    }
-  })
-})

package/src/types/Symbol.ts

@@ -1,19 +0,0 @@
-import { TypeAnalysis, Type } from './types'
-import { undef } from './Undefined'
-import { union } from './Union'
-
-export type Symbol<Value extends string = string> = Type<'symbol', Value>
-
-export namespace Symbol {
-  export type Analysis = TypeAnalysis<'symbol'>
-}
-
-function create<Value extends string>(value: Value): Symbol<Value> {
-  return { type: 'symbol', value }
-}
-
-const any = create(undefined as unknown as string)
-
-export const symbol = Object.assign(any, {
-  optional: union.create(any, undef)
-})