type-plus 4.8.2 → 4.10.0

package/ts/types/getPlainAnalysisReport.ts

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

@@ -1,28 +0,0 @@
-/**
- * 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 type { AllType } from './AllType'
-export * from './Any'
-export * from './Array'
-export * from './Boolean'
-export * from './check'
-export * from './conform'
-export type { Generate } 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

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

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

@@ -1,39 +0,0 @@
-import { baseline } from '@unional/fixture'
-import fs from 'fs'
-import path from 'path'
-import * as T from '.'
-import { O } from './optional'
-
-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')
-  })
-})