type-plus 4.9.0 → 4.10.1

package/ts/types/analyze.ts

@@ -1,170 +0,0 @@
-import { reduceByKey } from '../object'
-import { AllType } from './AllType'
-import { Array as ArrayType } from './Array'
-import { Boolean } from './Boolean'
-import { number, Number } from './Number'
-import { object, ObjectType } from './Object'
-import { Record as RecordType } from './Record'
-import { string, String } from './String'
-import { Tuple } from './Tuple'
-import { Type } from './types'
-import { Union } from './Union'
-
-export namespace analyze {
-  export type Options = { strict: boolean }
-  export type Result = {
-    options: Options,
-    analysis: AllType.Analysis,
-    actual: any
-  }
-}
-export function analyze(options: analyze.Options, type: AllType, actual: unknown): analyze.Result {
-  return {
-    options,
-    analysis: analyzeInternal(options, type, actual),
-    actual
-  }
-}
-export function analyzeInternal(options: analyze.Options, type: AllType, actual: unknown): AllType.Analysis {
-  const t = type['type']
-  switch (t) {
-    case 'unknown':
-    case 'any':
-      return ok(type)
-    case 'undefined':
-    case 'symbol':
-      return typeof actual === t ? ok(type) : fail(t)
-    case 'null':
-      return actual === null ? ok(type) : fail(t)
-    case 'boolean': return analyzeBoolean(type as Boolean, actual)
-    case 'number': return analyzeType(number, type as Number, actual)
-    case 'string': return analyzeType(string, type as String, actual)
-    // case 'bigint': return analyzeType(bigint, type as BigInt, actual)
-    case 'object': return analyzeObject(options, type as ObjectType, actual)
-    case 'record': return analyzeRecord(options, type as RecordType, actual)
-    case 'array': return analyzeArray(options, type as ArrayType, actual)
-    case 'tuple': return analyzeTuple(options, type as Tuple, actual)
-    case 'union': return analyzeUnion(options, type as Union, actual)
-  }
-}
-
-function analyzeBoolean(type: Boolean, actual: unknown) {
-  const value = type['value']
-  if (value === undefined) {
-    return typeof actual === 'boolean' ? ok(type) : fail('boolean', value)
-  }
-  else {
-    return value === actual ? ok(type) : fail('boolean', value)
-  }
-}
-
-function analyzeType(
-  baseType: Number | String, // | BigInt,
-  type: Type<any, any>,
-  actual: unknown
-) {
-  const value = type['value']
-  return typeof actual === baseType['type'] && (type === baseType || actual === value)
-    ? ok(type)
-    : fail(type['type'], type['value'])
-}
-
-function analyzeUnion(options: analyze.Options, type: Union, actual: unknown) {
-  const subTypes = type['value']
-  const r = subTypes.map(t => analyzeInternal(options, t, actual))
-  return r.some(r => !r.fail) ? ok(type) : fail('union', r)
-}
-
-function analyzeArray(options: analyze.Options, type: ArrayType<AllType>, actual: unknown) {
-  const subType = type['value']
-  if (!Array.isArray(actual)) return fail('array', subType ? ok(subType) : undefined)
-  if (subType === undefined) return ok(type)
-
-  const r = actual.reduce((p, a, i) => {
-    const r = analyzeInternal(options, subType, a)
-    if (r.fail) {
-      p.value = r.value
-      p.keys.push(i)
-      p.actual.push(a)
-    }
-    return p
-  }, { keys: [], actual: [] })
-  return r.keys.length === 0 ?
-    ok(type) :
-    fail('array', { ...fail(subType['type'], r.value) })
-}
-
-function analyzeTuple(options: analyze.Options, type: Tuple, actual: unknown) {
-  const value = type['value']
-  if (!Array.isArray(actual)) return fail('tuple', value.map(ok))
-  const results = value.map((v, i) => analyzeInternal(options, v, actual[i]))
-  if (options.strict && results.length < actual.length) {
-    return fail('tuple', results)
-  }
-  return results.every(r => !r.fail) ? ok(type) : fail('tuple', results)
-}
-
-function analyzeObject(options: analyze.Options, type: ObjectType, actual: any) {
-  const typeMap = type['value']
-  if (!isOnlyObject(actual)) return fail('object', typeMap ? object.map(v => ok(v), typeMap) : undefined)
-  if (type === object as ObjectType) return ok(type)
-
-  const typeKeys = Object.keys(typeMap)
-  const s = { ...actual }
-  const results = typeKeys.reduce(
-    (p, k) => {
-      const r = p.value[k] = analyzeInternal(options, typeMap[k], actual[k])
-      p.fail ||= !!r.fail
-      s[k] = undefined
-      return p
-    },
-    { fail: false, value: {} } as { fail: boolean, value: Record<string, AllType.Analysis> }
-  )
-  const skeys = Object.keys(s)
-  if (options.strict && skeys.length > typeKeys.length) {
-    return fail('object', results.value)
-  }
-
-  return !results.fail ? ok(type) : fail('object', results.value)
-}
-
-function analyzeRecord(options: analyze.Options, type: RecordType, actual: unknown) {
-  const subType = type['value']
-  if (!isOnlyObject(actual)) return fail('record', ok(subType))
-
-  const r = reduceByKey(actual, (p, k) => {
-    const r = analyzeInternal(options, subType, actual[k])
-    if (r.fail) {
-      p.value = r.value
-      p.keys.push(k)
-      p.actual.push(actual[k])
-    }
-    return p
-  }, { keys: [] as string[], actual: [] as any[], value: undefined as any })
-  return r.keys.length === 0 ?
-    ok(type) :
-    fail('record', { ...fail(subType['type'], r.value) })
-}
-
-function ok(t: { type: AllType.Analysis['type'], ['value']?: AllType.Analysis['value'] }): AllType.Analysis {
-  const type = t['type']
-  const value = t['value']
-  if (value === undefined) return { type, value }
-  if (typeof value !== 'object' || value === null) return { type, value }
-  if (Array.isArray(value)) return { type, value: value.map(ok) } as any
-  if (value['type']) return { type, value: ok(value) } as any
-  return {
-    type, value: reduceByKey(
-      value as Record<string, any>,
-      (p, k) => (p[k] = ok(value[k]), p),
-      {} as Record<string, any>)
-  } as any
-}
-
-function fail(type: AllType.Analysis['type'], value?: AllType.Analysis['value']): AllType.Analysis {
-  return value === undefined ? { type, fail: true } : { type, value, fail: true }
-}
-
-function isOnlyObject(actual: unknown): actual is Object {
-  return typeof actual === 'object' && actual !== null && !Array.isArray(actual)
-}

package/ts/types/check.spec.ts

@@ -1,12 +0,0 @@
-import * as T from '.'
-import { check } from './check'
-
-test('check without strict', () => {
-  const t = T.tuple.create(T.string)
-  expect(check({ strict: false }, t, ['a', 'b', 'c', 'd'])).toBe(true)
-})
-
-test('check with strict', () => {
-  const t = T.tuple.create(T.string)
-  expect(check({ strict: true }, t, ['a', 'b', 'c', 'd'])).toBe(false)
-})

package/ts/types/check.ts

@@ -1,26 +0,0 @@
-import { AllType } from './AllType'
-import { analyze } from './analyze'
-import { Generate } from './Generate'
-import { getPlainAnalysisReport } from './getPlainAnalysisReport'
-
-/**
- * Checks if the specified `subject` against the `type`.
- * @return type guard (boolean). If the subject does not check to the type,
- * the detail report is available in `check.result`,
- * and you can get a string report using `check.getReport()`
- */
-export function check<T extends AllType>(options: analyze.Options, type: T, subject: unknown): subject is Generate<T> {
-  const result = check.result = analyze(options, type, subject)
-  return !result.analysis.fail
-}
-
-/**
- * Analysis report.
- */
-check.result = { analysis: {}, actual: undefined } as analyze.Result
-
-/**
- * Gets a simple report of the analysis.
- */
-check.getReport = () => getPlainAnalysisReport(check.result)
-

package/ts/types/conform.spec.ts

@@ -1,7 +0,0 @@
-import * as T from '.'
-import { conform } from './conform'
-
-test('conform is strict', () => {
-  const t = T.tuple.create(T.string)
-  expect(conform(t, ['a', 'b', 'c', 'd'])).toBe(false)
-})

package/ts/types/conform.ts

@@ -1,27 +0,0 @@
-import { AllType } from './AllType'
-import { analyze } from './analyze'
-import { Generate } from './Generate'
-import { getPlainAnalysisReport } from './getPlainAnalysisReport'
-
-/**
- * Checks if the specified `subject` conforms to the `type`.
- * `conform()` is the shortcut of `check({ strict: true }, ...)`.
- * @return type guard (boolean). If the subject does not conform to the type,
- * the detail report is available in `conform.result`,
- * and you can get a string report using `conform.getReport()`
- */
-export function conform<T extends AllType>(type: T, subject: unknown): subject is Generate<T> {
-  const result = conform.result = analyze({ strict: true }, type, subject)
-  return !result.analysis.fail
-}
-
-/**
- * Analysis report.
- */
-conform.result = { analysis: {}, actual: undefined } as analyze.Result
-
-/**
- * Gets a simple report of the analysis.
- */
-conform.getReport = () => getPlainAnalysisReport(conform.result)
-

package/ts/types/getPlainAnalysisReport.spec.ts

@@ -1,354 +0,0 @@
-import * as T from '.'
-import { AllType } from './AllType'
-import { analyze } from './analyze'
-import { getPlainAnalysisReport } from './getPlainAnalysisReport'
-
-const nonStrict = { strict: false, debug: false }
-const strict = { strict: true, debug: false }
-
-describe('any', () => {
-  test('pass', () => {
-    assertReportEquals(nonStrict, T.any, false,
-      `The subject satisfies type any`)
-  })
-  test('strict pass', () => {
-    assertReportEquals(strict, T.any, false,
-      `The subject strictly satisfies type any`)
-  })
-})
-
-describe('unknown', () => {
-  test('pass', () => {
-    assertReportEquals(nonStrict, T.unknown, false,
-      `The subject satisfies type unknown`)
-  })
-  test('strict pass', () => {
-    assertReportEquals(strict, T.unknown, false,
-      `The subject strictly satisfies type unknown`)
-  })
-})
-
-describe('undefined', () => {
-  test('pass', () => {
-    assertReportEquals(nonStrict, T.undefined, undefined,
-      `The subject satisfies type undefined`)
-  })
-  test('strict pass', () => {
-    assertReportEquals(strict, T.undefined, undefined,
-      `The subject strictly satisfies type undefined`)
-  })
-  test('fail with explicit undefined', () => {
-    assertReportEquals(nonStrict, T.undefined, false,
-      `subject expects to be undefined but is actually false`)
-  })
-})
-
-describe('null', () => {
-  test('pass', () => {
-    assertReportEquals(nonStrict, T.null, null,
-      `The subject satisfies type null`)
-  })
-  test('strict pass', () => {
-    assertReportEquals(strict, T.null, null,
-      `The subject strictly satisfies type null`)
-  })
-  test('fail with explicit null', () => {
-    assertReportEquals(nonStrict, T.null, false,
-      `subject expects to be null but is actually false`)
-  })
-})
-describe('boolean', () => {
-  test('pass', () => {
-    assertReportEquals(nonStrict, T.boolean, false,
-      `The subject satisfies type boolean`)
-  })
-  test('strict pass', () => {
-    assertReportEquals(strict, T.boolean, true,
-      `The subject strictly satisfies type boolean`)
-  })
-
-  test('not boolean', () => {
-    assertReportEquals(nonStrict, T.boolean, undefined,
-      `subject expects to be boolean but is actually undefined`)
-  })
-
-  test('specific boolean violation', () => {
-    assertReportEquals(nonStrict, T.boolean.true, false,
-      `subject expects to be true but is actually false`)
-  })
-
-  test('optional boolean violation', () => {
-    assertReportEquals(nonStrict, T.boolean.optional, null,
-      `subject expects to be (boolean | undefined) but is actually null`)
-  })
-
-  test('optional specific boolean violation', () => {
-    assertReportEquals(nonStrict, T.boolean.optional.false, true,
-      `subject expects to be (false | undefined) but is actually true`)
-  })
-})
-describe('number', () => {
-  test('not number', () => {
-    assertReportEquals(nonStrict, T.number, undefined,
-      `subject expects to be number but is actually undefined`)
-  })
-
-  test('specific number violation', () => {
-    assertReportEquals(nonStrict, T.number.create(1), false,
-      `subject expects to be 1 but is actually false`)
-  })
-
-  test('optional number violation', () => {
-    assertReportEquals(nonStrict, T.number.optional, false,
-      `subject expects to be (number | undefined) but is actually false`)
-  })
-
-  test('optional specific number violation', () => {
-    assertReportEquals(nonStrict, T.number.optional.create(2), false,
-      `subject expects to be (2 | undefined) but is actually false`)
-  })
-
-  test('number list violation', () => {
-    assertReportEquals(nonStrict, T.number.list(1, 2, 3), false,
-      `subject expects to be (1 | 2 | 3) but is actually false`)
-  })
-
-  test('optional number list violation', () => {
-    assertReportEquals(nonStrict, T.number.optional.list(1, 2, 3), false,
-      `subject expects to be (1 | 2 | 3 | undefined) but is actually false`)
-  })
-})
-describe('string', () => {
-  test('not string', () => {
-    assertReportEquals(nonStrict, T.string, undefined,
-      `subject expects to be string but is actually undefined`)
-  })
-
-  test('specific string violation', () => {
-    assertReportEquals(nonStrict, T.string.create('a'), false,
-      `subject expects to be 'a' but is actually false`)
-  })
-
-  test('optional string violation', () => {
-    assertReportEquals(nonStrict, T.string.optional, false,
-      `subject expects to be (string | undefined) but is actually false`)
-  })
-
-  test('optional specific string violation', () => {
-    assertReportEquals(nonStrict, T.string.optional.create('b'), false,
-      `subject expects to be ('b' | undefined) but is actually false`)
-  })
-
-  test('string list violation', () => {
-    assertReportEquals(nonStrict, T.string.list('a', 'b', 'c'), false,
-      `subject expects to be ('a' | 'b' | 'c') but is actually false`)
-  })
-
-  test('optional string list violation', () => {
-    assertReportEquals(nonStrict, T.string.optional.list('a', 'b', 'c'), false,
-      `subject expects to be ('a' | 'b' | 'c' | undefined) but is actually false`)
-  })
-})
-describe('symbol', () => {
-  test('not symbol', () => {
-    assertReportEquals(nonStrict, T.symbol, undefined,
-      `subject expects to be symbol but is actually undefined`)
-  })
-})
-describe('bigint', () => {
-  // test('not bigint', () => {
-  //   assertReportEquals(nonStrict, T.bigint, undefined,
-  //     `subject expects to be bigint but is actually undefined`)
-  // })
-})
-describe('array', () => {
-  test('base violation', () => {
-    assertReportEquals(nonStrict, T.array, undefined,
-      `subject expects to be Array<any> but is actually undefined`)
-  })
-  test('specific array violation', () => {
-    assertReportEquals(nonStrict, T.array.create(T.number), false,
-      `subject expects to be Array<number> but is actually false`)
-  })
-  test('optional array violation', () => {
-    assertReportEquals(nonStrict, T.array.optional, false,
-      `subject expects to be (Array<any> | undefined) but is actually false`)
-  })
-  test('optional specific array violation', () => {
-    assertReportEquals(nonStrict, T.array.optional.create(T.number), false,
-      `subject expects to be (Array<number> | undefined) but is actually false`)
-  })
-})
-describe('tuple', () => {
-  test('specific tuple violation', () => {
-    assertReportEquals(
-      nonStrict,
-      T.tuple.create(T.number.create(1), T.string.create('a')),
-      false,
-      `subject expects to be [1,'a'] but is actually false`)
-  })
-  test('optional specific tuple violation', () => {
-    assertReportEquals(
-      nonStrict,
-      T.tuple.optional.create(T.number),
-      false,
-      `subject expects to be ([number] | undefined) but is actually false`)
-  })
-  test('missing entry', () => {
-    assertReportEquals(
-      nonStrict,
-      T.tuple.create(T.null),
-      [],
-      [
-        `subject expects to be [null] but is actually []`,
-        `subject[0] expects to be null but is actually undefined`
-      ].join('\n')
-    )
-  })
-  test('actual is object', () => {
-    assertReportEquals(
-      nonStrict,
-      T.tuple.create(T.null, T.number),
-      { a: 1 },
-      [
-        `subject expects to be [null,number] but is actually { a: 1 }`
-      ].join('\n')
-    )
-  })
-  test('strict with extra entry', () => {
-    assertReportEquals(
-      strict,
-      T.tuple.create(T.null),
-      [null, 1],
-      [
-        `subject expects to be strictly [null] but is actually [null, 1]`,
-        `index 1 should not contain any value`
-      ].join('\n')
-    )
-  })
-  test('strict with extra entries', () => {
-    assertReportEquals(
-      strict,
-      T.tuple.create(T.null, T.number),
-      [null, 1, 'a', false],
-      [
-        `subject expects to be strictly [null,number] but is actually [null, 1, 'a', false]`,
-        `indices 2,3 should not contain any value`
-      ].join('\n')
-    )
-  })
-})
-describe('object', () => {
-  test('not object', () => {
-    assertReportEquals(nonStrict, T.object, undefined,
-      `subject expects to be object but is actually undefined`)
-  })
-  test('specific object violation', () => {
-    assertReportEquals(
-      nonStrict,
-      T.object.create({ a: T.null }),
-      false,
-      `subject expects to be { a: null } but is actually false`)
-  })
-  test('optional specific object violation', () => {
-    assertReportEquals(
-      nonStrict,
-      T.object.optional.create({ a: T.object.create({ b: T.string }) }),
-      false,
-      `subject expects to be ({ a: { b: string } } | undefined) but is actually false`)
-  })
-  test('in object violation', () => {
-    assertReportEquals(
-      nonStrict,
-      T.object.create({ a: T.string }),
-      { a: 1 },
-      [
-        `subject expects to be { a: string } but is actually { a: 1 }`,
-        `subject.a expects to be string but is actually 1`
-      ].join('\n')
-    )
-  })
-  test('nested object violation', () => {
-    assertReportEquals(
-      nonStrict,
-      T.object.create({ a: T.object.create({ b: T.string }) }),
-      { a: { b: 1 } },
-      [
-        `subject expects to be { a: { b: string } } but is actually { a: { b: 1 } }`,
-        `subject.a expects to be { b: string } but is actually { b: 1 }`,
-        `subject.a.b expects to be string but is actually 1`
-      ].join('\n')
-    )
-  })
-  test('- prop violation', () => {
-    assertReportEquals(
-      nonStrict,
-      T.object.create({ 'a-b': T.string }),
-      { 'a-b': 1 },
-      [
-        `subject expects to be { 'a-b': string } but is actually { 'a-b': 1 }`,
-        `subject['a-b'] expects to be string but is actually 1`
-      ].join('\n')
-    )
-  })
-  test('strict with extra property', () => {
-    assertReportEquals(
-      strict,
-      T.object.create({ a: T.number }),
-      { a: 1, b: 2 },
-      [
-        `subject expects to be strictly { a: number } but is actually { a: 1, b: 2 }`,
-        `property b should not contain any value`
-      ].join('\n')
-    )
-  })
-  test('strict with extra properties', () => {
-    assertReportEquals(
-      strict,
-      T.object.create({ a: T.number }),
-      { a: 1, b: 2, c: 'c' },
-      [
-        `subject expects to be strictly { a: number } but is actually { a: 1, b: 2, c: 'c' }`,
-        `properties b,c should not contain any value`
-      ].join('\n')
-    )
-  })
-  test('object with array', () => {
-    assertReportEquals(
-      nonStrict,
-      T.object.create({ a: T.array, b: T.string }),
-      { a: [], b: 1 },
-      [
-        `subject expects to be { a: Array<any>, b: string } but is actually { a: [], b: 1 }`,
-        `subject.b expects to be string but is actually 1`
-      ].join('\n')
-    )
-  })
-})
-describe('record', () => {
-  test('specific record violation', () => {
-    assertReportEquals(
-      nonStrict,
-      T.record.create(T.null),
-      false,
-      `subject expects to be Record<string, null> but is actually false`)
-  })
-  test('optional specific record violation', () => {
-    assertReportEquals(
-      nonStrict,
-      T.record.optional.create(T.record.create(T.string)),
-      false,
-      `subject expects to be (Record<string, Record<string, string>> | undefined) but is actually false`)
-  })
-  test(`nested violation`, () => {
-    assertReportEquals(
-      nonStrict,
-      T.record.optional.create(T.record.create(T.string)),
-      { a: { b: 1 } },
-      `subject expects to be (Record<string, Record<string, string>> | undefined) but is actually { a: { b: 1 } }`)
-  })
-})
-
-function assertReportEquals(options: analyze.Options, type: AllType, subject: unknown, report: string) {
-  expect(getPlainAnalysisReport(analyze(options, type, subject))).toEqual(report)
-}