type-plus 4.9.1 → 4.10.0

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),
-  })
-})

package/ts/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/ts/types/Null.ts

@@ -1,14 +0,0 @@
-import { TypeAnalysis, Type } from './types'
-import { undef } from './Undefined'
-import { union } from './Union'
-
-export type Null = Type<'null', undefined>
-export namespace Null {
-  export type Analysis = TypeAnalysis<'null'>
-}
-
-const any: Null = { type: 'null', value: undefined }
-
-export const nil = Object.assign({}, any, {
-  optional: union.create(any, undef)
-})

package/ts/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/ts/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/ts/types/Record.ts

@@ -1,25 +0,0 @@
-import { AllType } from './AllType'
-import { TypeAnalysis, Type } from './types'
-import { undef, Undefined } from './Undefined'
-import { union, Union } from './Union'
-
-export type Record<Value extends AllType = any> = Type<'record', Value>
-
-export namespace Record {
-  export type Analysis<
-    Value extends AllType.PrimitiveValues | AllType.Analysis = any
-    > = TypeAnalysis<'record', Value>
-}
-
-function create<Value extends AllType>(value: Value): Record<Value> {
-  return { type: 'record', value }
-}
-
-export const record = {
-  create,
-  optional: {
-    create<Value extends AllType>(value: Value): Union<[Record<Value>, Undefined]> {
-      return union.create(create(value), undef) as any
-    }
-  }
-}

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

package/ts/types/Tuple.ts

@@ -1,50 +0,0 @@
-import { TypeAnalysis, Type } from './types'
-import { AllType } from './AllType'
-import { undef, Undefined } from './Undefined'
-import { union, Union } from './Union'
-import { Tail } from '../array'
-
-export type Tuple<Values extends AllType[] = any[]> = Type<'tuple', Values>
-
-export namespace Tuple {
-  export type Analysis<
-    Value extends AllType.PrimitiveValues | AllType.Analysis = any
-    > = TypeAnalysis<'tuple', Value[]>
-
-  export type FindByProp<
-    Tuple extends Array<{ [K in Key]: any }>,
-    Key extends string,
-    Value> = FindByProp._<Tuple, Key, Value>['result']
-  export namespace FindByProp {
-    export type _<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] : _<Tail<Tuple>, Key, Value>['result'] }
-  }
-}
-
-/**
- * Creates a tuple type.
- */
-function create<Value extends AllType, Values extends AllType[]>(
-  value: Value,
-  ...values: Values
-): Tuple<[Value, ...Values]> {
-  return {
-    type: 'tuple',
-    value: [value, ...values]
-  }
-}
-export const tuple = {
-  create,
-  optional: {
-    /**
-     * Creates an optional tuple type.
-     */
-    create<Value extends AllType, Values extends AllType[]>(
-      value: Value,
-      ...values: Values
-    ): Union<[Tuple<[Value, ...Values]>, Undefined]> {
-      return union.create(create(value, ...values), undef)
-    }
-  }
-}

package/ts/types/Undefined.ts

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

package/ts/types/Union.ts

@@ -1,46 +0,0 @@
-import { AllType } from './AllType'
-import { TypeAnalysis, Type } from './types'
-import { undef } from './Undefined'
-
-
-export type Union<Values extends AllType[] = any[]> = Type<'union', Values>
-
-export namespace Union {
-  export type Analysis<
-    Value extends AllType.PrimitiveValues | AllType.Analysis = any
-    > = TypeAnalysis<'union', Value[]>
-}
-
-/**
- * Create union type.
- */
-function create<
-  Value extends AllType, Values extends AllType[]
->(value: Value, ...values: Values): Values['length'] extends 0
-  ? Value : Union<[Value, ...Values]> {
-  values.unshift(value)
-  if (values.length === 1) return values[0] as any
-  const v = values.reduce<AllType[]>((p, v) => {
-    if (v.type === 'union') {
-      p.push(...(v as any).value)
-    }
-    else {
-      p.push(v)
-    }
-    return p
-  }, [])
-  return { type: 'union', value: v } as any
-}
-
-export const union = {
-  create,
-  optional: {
-    /**
-     * Creates an optional unional type.
-     */
-    create<Value extends AllType, Values extends AllType[]>(value: Value, ...values: Values) {
-      values.push(undef)
-      return create(value, ...values)
-    }
-  }
-}

package/ts/types/Unknown.ts

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