type-plus 4.8.2 → 4.10.0

package/ts/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
-      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/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/ts/promise/PromiseValue.spec.ts

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

package/ts/promise/PromiseValueMerge.spec.ts

@@ -1,7 +0,0 @@
-import { assertType, PromiseValueMerge } from '..'
-
-test('merge promise value', async () => {
-  const result = {} as PromiseValueMerge<Promise<{ a: string }>, Promise<{ b: string }>>
-  const value = await result
-  assertType<{ a: string, b: string }>(value)
-})

package/ts/promise/isPromise.spec.ts

@@ -1,26 +0,0 @@
-import t from 'assert'
-import { isPromise } from '..'
-
-test('false if subject is falsy value or non-object', () => {
-  t.strictEqual(isPromise(undefined), false)
-  t.strictEqual(isPromise(null), false)
-  t.strictEqual(isPromise(0), false)
-  t.strictEqual(isPromise(true), false)
-  t.strictEqual(isPromise('a'), false)
-  t.strictEqual(isPromise([]), false)
-})
-
-test('false if subject does not have a then function', () => {
-  t.strictEqual(isPromise({}), false)
-})
-
-test('false if subject.then is not a function', () => {
-  t.strictEqual(isPromise({ then: true }), false)
-})
-
-test('type guard as promise', () => {
-  const subject = { then() { return true } }
-  if (isPromise(subject)) {
-    t.strictEqual(subject.then(), true)
-  }
-})

package/ts/promise/mapSeries.spec.ts

@@ -1,12 +0,0 @@
-import { mapSeries } from '..'
-
-test('map over values', () => {
-  const values = [3, 2, 1]
-  let actual = ''
-
-  return mapSeries(values, v => new Promise<string>(a => setTimeout(() => a(actual += v), v * 10)))
-    .then(result => {
-      expect(actual).toBe('321')
-      expect(result).toEqual(['3', '32', '321'])
-    })
-})

package/ts/testing/stub.spec.ts

@@ -1,58 +0,0 @@
-import { isType, stub } from '..'
-
-describe('stub()', () => {
-  test('stub is a partial of the actual object', () => {
-    const real = { a: 1, b: { c: 2 }, d: 3 }
-
-    const a = stub<typeof real>({ a: 2 })
-    expect(a.a).toBe(2)
-    isType.equal<true, typeof a, typeof real>()
-  })
-
-  test('stub function retains param types', () => {
-    function real(a: string, b: number): boolean { return a === String(b) }
-
-    const a = stub<typeof real>((_a, _b) => {
-      isType.equal<true, string, typeof _a>()
-      isType.equal<true, number, typeof _b>()
-      return false
-    })
-
-    expect(a('1', 1)).toBe(false)
-    isType.equal<true, typeof a, typeof real>()
-  })
-
-  test('stub function params can be omitted', () => {
-    function real(a: string, b: number): boolean { return a === String(b) }
-
-    const a = stub<typeof real>(() => false)
-
-    expect(a('1', 1)).toBe(false)
-    isType.equal<true, typeof a, typeof real>()
-  })
-
-  test('stub input can be omitted', () => {
-    const real = { a: 1, b: { c: 2 }, d: 3 }
-
-    const a = stub<typeof real>()
-    isType.equal<true, typeof a, typeof real>()
-  })
-})
-
-describe('stub.build()', () => {
-  test('build a stub function', () => {
-    const real = { a: 1, b: { c: 2 }, d: 3 }
-
-    const s = stub.build<typeof real>()
-    const a = s({ a: 2 })
-    expect(a.a).toBe(2)
-    isType.equal<true, typeof a, typeof real>()
-  })
-  test('can define init value', () => {
-    type S = { a: number, b: string }
-    const s = stub.build<S>({ b: 'b' })
-    const a = s({ a: 1 })
-    expect(a).toEqual({ a: 1, b: 'b' })
-    isType.equal<true, S, typeof a>()
-  })
-})

package/ts/type-checker/.eslintrc.json

@@ -1,5 +0,0 @@
-{
-  "rules": {
-    "@typescript-eslint/ban-types": "off"
-  }
-}

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

package/ts/type-checker/Boolean.ts

@@ -1,34 +0,0 @@
-import { Type, TypeSpec } from './types'
-
-export type Boolean<Value extends boolean = boolean> = Type<'boolean', Value>
-export namespace Boolean {
-  export type Analysis = { type: 'boolean', value?: boolean, fail?: true }
-}
-
-export type True = Boolean<true>
-export type False = Boolean<false>
-
-function create<Value extends boolean>(value: Value): Boolean<Value> {
-  return { type: 'boolean', value }
-}
-
-const any = create(undefined as unknown as boolean)
-
-// export const booleanSpec: TypeSpec<'boolean', boolean, boolean> = {
-//   type: any,
-//   toAnalysis: <Type extends Boolean>({ type, value }: Type) => ({ type, value }),
-//   toNative: <Value extends boolean>(value: Value) => value
-// }
-
-export const BooleanSpec: TypeSpec<Type<'boolean', boolean>> = {
-  type: any,
-  toAnalysis(_options, value, actual) {
-    if (value === undefined) {
-      return typeof actual === 'boolean' ? { type: 'boolean', value } : { type: 'boolean', value, fail: true }
-    }
-    else {
-      return value === actual ? { type: 'boolean', value } : { type: 'boolean', value, fail: true }
-    }
-  },
-  toNative(value: any): true { return value as any }
-}

package/ts/type-checker/Tuple.spec.ts

@@ -1,15 +0,0 @@
-import { assertType } from '../assertion'
-import { Tuple } from './Tuple'
-
-describe('Find<T,S>', () => {
-  test('[] returns never', () => {
-    assertType<Tuple.FindByProp<[], 'key', string>>(0 as never)
-  })
-  test('[num], num returns num', () => {
-    assertType<Tuple.FindByProp<[{ key: number }], 'key', number>>({ key: 1 })
-  })
-  test('[num,str] str returns str', () => {
-    type Values = [{ type: 'a' }, { type: 'b' }, { type: 'c' }]
-    assertType<Tuple.FindByProp<Values, 'type', 'c'>>({ type: 'c' })
-  })
-})

package/ts/type-checker/Tuple.ts

@@ -1,14 +0,0 @@
-
-export namespace Tuple {
-  export type Head<T extends any[]> = T['length'] extends 0 ? never : T[0]
-  export type Tail<T extends any[]> = T['length'] extends 0 ? never :
-    T extends [any, ...infer Tail] ? Tail : T
-
-  export type FindByProp<Tuple extends Array<{ [K in Key]: any }>, Key extends string, Value> = FindByProp._FindByProp<Tuple, Key, Value>['result']
-
-  export namespace FindByProp {
-    export type _FindByProp<Tuple extends Array<{ [K in Key]: any }>, Key extends string, Value> = Tuple['length'] extends 0
-      ? { result: never }
-      : { result: Value extends Tuple[0][Key] ? Tuple[0] : _FindByProp<Tail<Tuple>, Key, Value>['result'] }
-  }
-}

package/ts/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/ts/type-checker/typeChecker.spec.ts

@@ -1,14 +0,0 @@
-import { assertType } from '..'
-import * as T from '../types'
-import { createTypeChecker } from './typeChecker'
-
-describe('check()', () => {
-  test('bool', () => {
-    const checker = createTypeChecker()
-
-    const s: unknown = false
-    if (checker.check({ strict: false, debug: false }, T.boolean.true, s)) {
-      assertType<true>(s)
-    }
-  })
-})

package/ts/type-checker/typeChecker.ts

@@ -1,52 +0,0 @@
-import { AllType } from '../types'
-import { analyze } from '../types/analyze'
-import { satisfy } from '../types/satisfy'
-import { BooleanSpec } from './Boolean'
-import { Tuple } from './Tuple'
-import { Type, TypeSpec } from './types'
-
-// export type TypeChecker<Types extends Type<string, any>[]> = {
-
-// }
-
-export namespace TypeChecker {
-  export type CheckOptions = {
-    /**
-     * Check in strict mode.
-     * true = `conform()`.
-     * false = `satisfy()`.
-     */
-    strict: boolean,
-    /**
-     * Turn on debug logging.
-     */
-    debug: boolean
-  }
-
-  export type Generate<Specs extends Array<any>, T> = Specs extends Array<TypeSpec<AllType>>
-    ? Generate._<Specs, T>['result'] : never
-
-  export namespace Generate {
-    export type _<Specs extends Array<TypeSpec<AllType>>, T> = T extends AllType
-    ? {
-      result: Generate<Specs, _ToNative<Tuple.FindByProp<Specs, 'type', T>, T>>
-    }
-    : { result: T }
-
-    export type _ToNative<R, T> = R extends TypeSpec<any> ? ReturnType<R['toNative']> : T
-  }
-}
-
-export function createTypeChecker<
-  Specs extends Type<string, any>[]
->(..._typeSpec: Specs) {
-  return {
-    check<T extends AllType>(
-      _options: TypeChecker.CheckOptions,
-      type: T,
-      subject: unknown): subject is TypeChecker.Generate<[typeof BooleanSpec], T> {
-      const result = satisfy.result = analyze({ strict: false }, type, subject)
-      return !result.analysis.fail
-    }
-  }
-}

package/ts/type-checker/types.ts

@@ -1,19 +0,0 @@
-export type Checker = {
-  type: Record<string, any>
-}
-
-export type TypeSpec<T extends Type<string, any> = Type<string, any>, R = any> = {
-  type: T,
-  toAnalysis(options: AnalysisOptions, value: T['value'], subject: unknown): TypeAnalysis<T['type'], T['value']>,
-  toNative(value: T['value']): R
-}
-
-export type AnalysisOptions = { strict: boolean, debug: boolean }
-
-export type Type<T extends string, V> = {
-  type: T,
-  value: V
-}
-
-export type TypeAnalysis<T extends string, V = never> = { type: T, value?: V, fail?: true }
-

package/ts/types/.eslintrc.json

@@ -1,5 +0,0 @@
-{
-  "rules": {
-    "@typescript-eslint/ban-types": "off"
-  }
-}

package/ts/types/AllType.ts

@@ -1,31 +0,0 @@
-import { Any } from './Any'
-import { Array } from './Array'
-// import { BigInt } from './BigInt'
-import { Boolean } 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 AllType = Undefined | Null | Boolean | Number | String
-  | ObjectType | Record
-  | Array | Tuple
-  // <https://www.rapidtables.com/math/symbols/Set_Symbols.html>
-  | Union // | Intersection | SubSet | SuperSet | Complement | Diff
-  | Unknown | Any
-  | Symbol // | BigInt
-
-export namespace AllType {
-  export type PrimitiveValues = boolean | number | string // | bigint
-  export type Analysis = Any.Analysis | Unknown.Analysis |
-    Undefined.Analysis | Null.Analysis | Boolean.Analysis | Number.Analysis | String.Analysis |
-    Symbol.Analysis |
-    ObjectType.Analysis | Record.Analysis | Array.Analysis | Tuple.Analysis |
-    Union.Analysis
-}

package/ts/types/Any.ts

@@ -1,7 +0,0 @@
-import { Type, TypeAnalysis } from './types'
-
-export type Any = Type<'any', undefined>
-export namespace Any {
-  export type Analysis = TypeAnalysis<'any'>
-}
-export const any: Any = { type: 'any', value: undefined }

package/ts/types/Array.ts

@@ -1,43 +0,0 @@
-// import { BigInt } from './BigInt'
-import { AllType } from './AllType'
-import { Type } from './types'
-import { undef, Undefined } from './Undefined'
-import { union, Union } from './Union'
-import { unknown } from './Unknown'
-
-export type Array<Value extends AllType = any> = Type<'array', Value>
-export namespace Array {
-  export type Analysis<
-    Value extends AllType.PrimitiveValues | AllType.Analysis = any
-    > = {
-      type: 'array',
-      value?: Value,
-      fail?: true
-    }
-}
-
-/**
- * Creates an array type.
- */
-function create<Value extends AllType>(value: Value): Array<Value> {
-  return {
-    type: 'array',
-    value
-  }
-}
-
-const any = create(undefined as unknown as any)
-
-export const array = Object.assign({}, any, {
-  any,
-  create,
-  optional: Object.assign(union.create(any, undef), {
-    /**
-     * Creates an optional array type.
-     */
-    create<Value extends AllType>(value: Value): Union<[Array<Value>, Undefined]> {
-      return union.create(create(value), undef)
-    }
-  }),
-  unknown: create(unknown)
-})

package/ts/types/BigInt.ts

@@ -1,36 +0,0 @@
-// istanbul ignore file
-// import { undef, Undefined } from './Undefined'
-// import { Union, union } from './Union'
-
-import { TypeAnalysis, Type } from './types'
-
-export type BigInt<Value extends bigint = bigint> = Type<'bigint', Value>
-
-export namespace BigInt {
-  export type Analysis = TypeAnalysis<'bigint', bigint>
-}
-
-/**
- * Creates a single value type.
- */
-function create<Value extends bigint>(value: Value): BigInt<Value> {
-  // Cannot name this function as `const` because it is a reserved keyword.
-  return { type: 'bigint', value }
-}
-
-const any = create(undefined as unknown as bigint)
-
-export const bigint = Object.assign(any, {
-  any,
-  create,
-  // Note: adding this requires Union type to include BigInt
-  // optional: {
-  //   ...union.create(any, undef),
-  //   /**
-  //    * Creates an optional bigint constant type.
-  //    */
-  //   create<Value extends bigint>(value: Value): Union<[BigInt<Value>, Undefined]> {
-  //     return union.create(create(value), undef)
-  //   }
-  // }
-})

package/ts/types/Boolean.ts

@@ -1,36 +0,0 @@
-import { Type } from './types'
-import { undef, Undefined } from './Undefined'
-import { Union, union } from './Union'
-
-export type Boolean<Value extends boolean = boolean> = Type<'boolean', Value>
-export namespace Boolean {
-  export type Analysis = { type: 'boolean', value?: boolean, fail?: true }
-}
-
-export type True = Boolean<true>
-export type False = Boolean<false>
-
-function create<Value extends boolean>(value: Value): Boolean<Value> {
-  return { type: 'boolean', value }
-}
-
-const any = create(undefined as unknown as boolean)
-const t = create(true)
-const f = create(false)
-
-export const boolean = Object.assign(any, {
-  any,
-  true: t,
-  false: f,
-  create,
-  optional: Object.assign(union.create(any, undef), {
-    /**
-     * Creates an optional boolean type.
-     */
-    create<Value extends boolean>(value: Value): Union<[Boolean<Value>, Undefined]> {
-      return union.create(create(value), undef)
-    },
-    true: union.create(t, undef),
-    false: union.create(f, undef),
-  })
-})