type-plus 3.12.2 → 3.15.0

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

@@ -0,0 +1,28 @@
+// 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/types/Generate.ts

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

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

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

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

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

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

@@ -0,0 +1,115 @@
+import { tersify } from 'tersify'
+import { reduceByKey } from '../object'
+import { AllType } from './AllType'
+import { analyze } from './analyze'
+
+export function getPlainAnalysisReport(analysisResult: analyze.Result) {
+  if (!analysisResult.analysis.fail) {
+    return `The subject${analysisResult.options.strict ? ' strictly' : ''} satisfies type ${formatAnalysis(analysisResult.analysis)}`
+  }
+
+  return toViolations(analysisResult.options, [], analysisResult.actual, analysisResult.analysis).join('\n')
+}
+
+function formatAnalysis(a: AllType.Analysis) {
+  return a.type
+}
+
+function toViolations(options: analyze.Options, path: Array<string | number>, actual: any, analysis: AllType.Analysis): string[] {
+  const clause = options.strict ? `expects to be strictly` : `expects to be`
+  const violations = [`${formatPath(path)} ${clause} ${formatType(analysis)} but is actually ${tersify(actual)}`]
+
+  switch (analysis.type) {
+    case 'tuple': {
+      if (options.strict && analysis.value!.length < actual.length) {
+        const index = actual.length - analysis.value!.length === 1 ? 'index' : 'indices'
+        violations.push(`${index} ${range(analysis.value!.length, actual.length)} should not contain any value`)
+      }
+      const v2 = analysis.value!.reduce((p, a, i) => {
+        if (a.fail) p.push(...toViolations(options, [...path, i], actual[i], a))
+        return p
+      }, [] as string[])
+      if (v2.length > 0) violations.push(...v2)
+      break
+    }
+    case 'object':
+      if (analysis.value) {
+        const typeKeys = Object.keys(analysis.value)
+        const actualKeys = Object.keys(actual)
+        if (options.strict) {
+          const extraKeys = actualKeys.filter(k => typeKeys.indexOf(k) === -1)
+          const index = extraKeys.length === 1 ? 'property' : 'properties'
+          violations.push(`${index} ${extraKeys.join(',')} should not contain any value`)
+        }
+        const propViolations = typeKeys.reduce((p, k) => {
+          const a = analysis.value![k]
+          if (a.fail) p.push(...toViolations(options, [...path, k], actual[k], a))
+          return p
+        }, [] as string[])
+        if (propViolations.length > 0) violations.push(...propViolations)
+      }
+      break
+  }
+  return violations
+}
+
+function formatPath(path: Array<string | number>) {
+  return path.length === 0 ? 'subject' : `subject${path.map(p => toAccessor(p)).join('')}`
+}
+
+function toAccessor(p: string | number) {
+  if (typeof p === 'number') return `[${p}]`
+  if (p.indexOf('-') >= 0) return `['${p}']`
+  return `.${p}`
+}
+
+function toProp(p: string) {
+  return p.indexOf('-') >= 0 ? `'${p}'` : p
+}
+
+function formatType(e: AllType.Analysis): string {
+  switch (e.type) {
+    case 'undefined':
+    case 'null':
+    case 'symbol':
+      // case 'never':
+      return e.type
+    case 'boolean':
+    case 'number':
+      // case 'bigint':
+      return e.value === undefined ? e.type : String(e.value)
+    case 'string':
+      return e.value === undefined ? e.type : `'${e.value}'`
+    case 'array':
+      return e.value === undefined ? 'Array<any>' : `Array<${formatType(e.value as any)}>`
+    case 'tuple':
+      return `[${formatExpectations(e.value as AllType.Analysis[])}]`
+    case 'object':
+      return e.value === undefined ? e.type
+        : `{ ${reduceByKey(
+          e.value as Record<string, any>,
+          (p, k) => {
+            p.push(`${toProp(k)}: ${formatType((e.value as any)[k] as any)}`)
+            return p
+          },
+          [] as string[]
+        ).join(', ')} }`
+    case 'record':
+      return `Record<string, ${formatType(e.value as any)}>`
+    case 'union':
+      return `(${formatExpectations(e.value as AllType.Analysis[], ' | ')})`
+    // istanbul ignore next
+    default:
+      return `report not expected: ${e.value}`
+  }
+}
+
+function formatExpectations(es: AllType.Analysis[], sep = ',') {
+  return es.map(formatType).join(sep)
+}
+
+function range(start: number, end: number) {
+  const r: number[] = []
+  while (start < end) r.push(start++)
+  return r
+}

package/ts/types/index.ts

@@ -0,0 +1,28 @@
+/**
+ * A turing complete solution inspired by many.
+ * The types is in Pascal Cases
+ * because lower case type names (e.g. true) is a reserved keyword.
+ * https://github.com/microsoft/TypeScript/issues/14833
+ * https://github.com/tycho01/typical
+ */
+
+// export * from './BigInt'
+export * from './AllType'
+export * from './Any'
+export * from './Array'
+export * from './Boolean'
+export * from './check'
+export * from './conform'
+export * from './Generate'
+export { nil as null, Null } from './Null'
+export * from './Number'
+export { keys, object, ObjectType as Object } from './Object'
+export * from './Record'
+export * from './satisfy'
+export * from './String'
+export * from './Symbol'
+export * from './Tuple'
+export * from './types'
+export { undef as undefined, Undefined } from './Undefined'
+export * from './Union'
+export * from './Unknown'

package/ts/types/optional.ts

@@ -0,0 +1,30 @@
+import { object } from './Object'
+import { any } from './Any'
+import { array } from './Array'
+import { boolean } from './Boolean'
+import { nil } from './Null'
+import { number } from './Number'
+import { string } from './String'
+import { symbol } from './Symbol'
+import { tuple } from './Tuple'
+import { undef } from './Undefined'
+import { unknown } from './Unknown'
+import { record } from './Record'
+// import { bigint } from './types/BigInt'
+
+export const optional = {
+  any,
+  array: array.optional,
+  // bigint: bigint.optional,
+  boolean: boolean.optional,
+  null: nil.optional,
+  number: number.optional,
+  object: object.optional,
+  record: record.optional,
+  string: string.optional,
+  symbol: symbol.optional,
+  tuple: tuple.optional,
+  undefined: undef,
+  unknown
+}
+export const O = optional

package/ts/types/required.ts

@@ -0,0 +1,30 @@
+import { object } from './Object'
+import { any } from './Any'
+import { array } from './Array'
+import { boolean } from './Boolean'
+import { nil } from './Null'
+import { number } from './Number'
+import { string } from './String'
+import { symbol } from './Symbol'
+import { tuple } from './Tuple'
+import { undef } from './Undefined'
+import { unknown } from './Unknown'
+import { record } from './Record'
+// import { bigint } from './types/BigInt'
+
+export const required = {
+  any,
+  array: array,
+  // bigint: bigint,
+  boolean: boolean,
+  null: nil,
+  number: number,
+  object: object,
+  record: record,
+  string: string,
+  symbol: symbol,
+  tuple: tuple,
+  undefined: undef,
+  unknown
+}
+export const R = required

package/ts/types/satisfy.accept.ts

@@ -0,0 +1,38 @@
+import { baseline } from '@unional/fixture'
+import fs from 'fs'
+import path from 'path'
+import { T, O } from '..'
+
+const eslint = T.object.create({
+  env: O.object.create({
+    es6: O.boolean
+  }),
+  parseOptions: O.object.create({
+    ecmaVersion: O.number.list(3, 5, 6, 7, 8, 9, 10, 11, 12),
+    sourceType: O.string.list('script', 'module'),
+    ecmaFeatures: O.object.create({
+      globalReturn: O.boolean,
+      impliedStrict: O.boolean,
+      jsx: O.boolean
+    })
+  }),
+  plugins: O.array.create(O.string),
+  overrides: O.array.create(
+    T.object.create({
+      files: O.array.create(O.string),
+      processor: O.string,
+      rules: O.record.create(O.string.create('error'))
+    })
+  ),
+  rules: O.record.create(O.string.create('error'))
+})
+
+baseline('fixtures/eslint', ({ caseName, caseFolder }) => {
+  test(`eslint ${caseName}`, () => {
+    const config: unknown = JSON.parse(
+      fs.readFileSync(`${path.join(caseFolder, caseName)}`, 'utf-8')
+    )
+
+    if (!T.satisfy(eslint, config)) fail('should satisfy')
+  })
+})

package/ts/utils/as.spec.ts

@@ -0,0 +1,24 @@
+import { as, asAny, isType } from '..'
+
+describe('as<T>()', () => {
+  test('defaults subject type to unknown', () => {
+    const s: any = {}
+    if (as(s)) isType.equal<true, unknown, typeof s>()
+  })
+
+  test('cast type to T', () => {
+    const s: any = {}
+    if (as<number>(s)) isType.equal<true, number, typeof s>()
+    if (as<string>(s)) isType.equal<true, string, typeof s>()
+    if (as<{ a: number }>(s)) isType.equal<true, { a: number }, typeof s>()
+    if (as<any>(s)) isType.equal<true, any, typeof s>()
+  })
+})
+
+describe('asAny()', () => {
+  test('cast type to any', () => {
+    const s: unknown = {}
+    if (asAny(s)) isType.equal<true, any, typeof s>()
+  })
+})
+

package/ts/utils/as.ts

@@ -0,0 +1,7 @@
+export function as<T>(subject: unknown): subject is T {
+  return true
+}
+
+export function asAny(subject: unknown): subject is any {
+  return true
+}

package/ts/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './as'
+export * from './Widen'