Version 1.0.37 (#1406)

* Advanced Json Schema Inference

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.0.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.0.37](https://github.com/sinclairzx81/typebox/pull/1406)
+  - Json Schema Inference: Union TypeName and UnevaluatedProperties
 - [Revision 1.0.36](https://github.com/sinclairzx81/typebox/pull/1405)
   - Add Immutable Type for Tuple and Array
   - Documentation Updates Literal | Immutable

design/website/docs/overview/2_setup.md

@@ -1,13 +1,13 @@
 # Setup
 
-TypeBox requires no special configuration to use, but it is recommended to configure tsconfig.json with `strict: true`.
+TypeBox needs TypeScript to be configured with the following settings.
 
 ```typescript
 // file: tsconfig.json
-
 {
   "compilerOptions": {
-    "strict": true
+    "strict": true,              // Required for Type Inference
+    "target": "ES2018",          // Minimum ES Target
   }
 }
 ```

docs/docs/overview/2_setup.html

@@ -1,10 +1,10 @@
 <h1>Setup</h1>
-<p>TypeBox requires no special configuration to use, but it is recommended to configure tsconfig.json with <code>strict: true</code>.</p>
+<p>TypeBox needs TypeScript to be configured with the following settings.</p>
 <pre><code class="language-typescript">// file: tsconfig.json
-
 {
   &quot;compilerOptions&quot;: {
-    &quot;strict&quot;: true
+    &quot;strict&quot;: true,              // Required for Type Inference
+    &quot;target&quot;: &quot;ES2018&quot;,          // Minimum ES Target
   }
 }
 </code></pre>

example/index.ts

@@ -10,7 +10,6 @@ import Type from 'typebox'
 // ------------------------------------------------------------------
 System.Settings.Set({ enumerableKind: false })
 
-
 // ------------------------------------------------------------------
 // Type
 // ------------------------------------------------------------------

src/schema/build.ts

@@ -36,7 +36,7 @@ import { Guard } from '../guard/index.ts'
 import { Format } from '../format/index.ts'
 
 import * as Engine from './engine/index.ts'
-import { type XSchemaLike } from './types/index.ts'
+import { type XSchema } from './types/index.ts'
 
 // ------------------------------------------------------------------
 // CreateCode
@@ -88,19 +88,19 @@ export interface EvaluateResult {
 // ------------------------------------------------------------------
 export class BuildResult {
   constructor(
-    private readonly context: Record<PropertyKey, XSchemaLike>,
-    private readonly schema: XSchemaLike,
+    private readonly context: Record<PropertyKey, XSchema>,
+    private readonly schema: XSchema,
     private readonly external: Engine.TExternal,
     private readonly functions: string[],
     private readonly call: string,
     private readonly useUnevaluated: boolean
   ) { }
   /** Returns the Context used for this build */
-  public Context(): Record<PropertyKey, XSchemaLike> {
+  public Context(): Record<PropertyKey, XSchema> {
     return this.context
   }
   /** Returns the Schema used for this build */
-  public Schema(): XSchemaLike {
+  public Schema(): XSchema {
     return this.schema
   }
   /** Returns true if this build requires a Unevaluated context */
@@ -130,12 +130,12 @@ export class BuildResult {
 // Build
 // ------------------------------------------------------------------
 /** Builds a schema into a optimized runtime validator */
-export function Build(schema: XSchemaLike): BuildResult
+export function Build(schema: XSchema): BuildResult
 /** Builds a schema into a optimized runtime validator */
-export function Build(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike): BuildResult
+export function Build(context: Record<PropertyKey, XSchema>, schema: XSchema): BuildResult
 /** Builds a schema into a optimized runtime validator */
 export function Build(...args: unknown[]): BuildResult {
-  const [context, schema] = Arguments.Match<[Record<PropertyKey, XSchemaLike>, XSchemaLike]>(args, {
+  const [context, schema] = Arguments.Match<[Record<PropertyKey, XSchema>, XSchema]>(args, {
     2: (context, schema) => [context, schema],
     1: (schema) => [{}, schema]
   })

src/schema/check.ts

@@ -31,18 +31,18 @@ THE SOFTWARE.
 
 import { Arguments } from '../system/arguments/index.ts'
 import { CheckSchema, CheckContext } from './engine/index.ts'
-import { XSchemaLike } from './types/index.ts'
+import { XSchema } from './types/index.ts'
 
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 /** Checks a value against the provided schema */
-export function Check(schema: XSchemaLike, value: unknown): boolean
+export function Check(schema: XSchema, value: unknown): boolean
 /** Checks a value against the provided schema */
-export function Check(context: Record<PropertyKey, XSchemaLike>, schema: XSchemaLike, value: unknown): boolean
+export function Check(context: Record<PropertyKey, XSchema>, schema: XSchema, value: unknown): boolean
 /** Checks a value against the provided schema */
 export function Check(...args: unknown[]): boolean {
-  const [context, schema, value] = Arguments.Match<[Record<PropertyKey, XSchemaLike>, XSchemaLike, unknown]>(args, {
+  const [context, schema, value] = Arguments.Match<[Record<PropertyKey, XSchema>, XSchema, unknown]>(args, {
     3: (context, schema, value) => [context, schema, value],
     2: (schema, value) => [{}, schema, value]
   })

src/schema/deref/deref.ts

@@ -34,7 +34,7 @@ import * as S from '../types/index.ts'
 // ------------------------------------------------------------------
 // Rebase
 // ------------------------------------------------------------------
-export function Rebase(baseUri: string, schema: S.XSchema): string {
+export function Rebase(baseUri: string, schema: S.XSchemaObject): string {
   if (!S.IsId(schema)) return baseUri
   if (IsUri(schema.$id)) return schema.$id
   if (!IsUri(schema.$id) && IsUri(baseUri)) {
@@ -51,7 +51,7 @@ function IsHashPointer(value: string): boolean {
 function IsHash(value: string): boolean {
   return value.length > 0 && value[0] === '#'
 }
-function Select(schema: S.XSchema, baseUri: string, $ref: string): S.XSchemaLike | undefined {
+function Select(schema: S.XSchemaObject, baseUri: string, $ref: string): S.XSchema | undefined {
   if (IsUri(baseUri)) {
     const [base, ref] = [new URL(baseUri), new URL($ref, baseUri)]
     const matched = base.pathname === ref.pathname
@@ -62,14 +62,14 @@ function Select(schema: S.XSchema, baseUri: string, $ref: string): S.XSchemaLike
   }
   if (IsHashPointer($ref)) {
     const target = Pointer.Get(schema, $ref.slice(1))
-    if (S.IsSchemaLike(target)) return target
+    if (S.IsSchema(target)) return target
   }
   return undefined
 }
 // ------------------------------------------------------------------
 // Traversal
 // ------------------------------------------------------------------
-function FromObject(schema: S.XSchema, baseUrl: string, ref: S.XRef): S.XSchemaLike | undefined {
+function FromObject(schema: S.XSchemaObject, baseUrl: string, ref: S.XRef): S.XSchema | undefined {
   // ----------------------------------------------------------------
   // TypeBox: Fast TCyclic Deref
   // ----------------------------------------------------------------
@@ -81,18 +81,18 @@ function FromObject(schema: S.XSchema, baseUrl: string, ref: S.XRef): S.XSchemaL
   // ----------------------------------------------------------------
   const rebase = Rebase(baseUrl, schema)
   const target = Select(schema, rebase, ref.$ref)
-  if (S.IsSchemaLike(target)) return target
+  if (S.IsSchema(target)) return target
 
   // Keep searching ...
-  return Object.values(schema).reduce<S.XSchemaLike | undefined>(
+  return Object.values(schema).reduce<S.XSchema | undefined>(
     (result, subschema) => result || FromValue(subschema, rebase, ref),
     undefined
   )
 }
-function FromArray(schema: unknown[], baseUri: string, ref: S.XRef): S.XSchemaLike | undefined {
-  return schema.reduce((result, value) => result || FromValue(value, baseUri, ref), undefined) as S.XSchema | undefined
+function FromArray(schema: unknown[], baseUri: string, ref: S.XRef): S.XSchema | undefined {
+  return schema.reduce((result, value) => result || FromValue(value, baseUri, ref), undefined) as S.XSchemaObject | undefined
 }
-function FromValue(schema: unknown, base: string, ref: S.XRef): S.XSchemaLike | undefined {
+function FromValue(schema: unknown, base: string, ref: S.XRef): S.XSchema | undefined {
   return (
     (Guard.IsObject(schema) && FromObject(schema, base, ref)) ||
     (Guard.IsArray(schema) && FromArray(schema, base, ref)) ||

src/schema/engine/_context.ts

@@ -61,8 +61,8 @@ export function HasUnevaluated(context: Record<PropertyKey, unknown>, schema: un
 // ------------------------------------------------------------------
 export class BaseContext {
   constructor(
-    protected readonly context: Record<PropertyKey, S.XSchemaLike>,
-    protected readonly schema: S.XSchemaLike,
+    protected readonly context: Record<PropertyKey, S.XSchema>,
+    protected readonly schema: S.XSchema,
   ) { }
   public GetContext(): Record<PropertyKey, object | boolean> {
     return this.context
@@ -75,7 +75,7 @@ export class BaseContext {
 // BuildContext
 // ------------------------------------------------------------------
 export class BuildContext extends BaseContext {
-  constructor(context: Record<PropertyKey, S.XSchemaLike>, schema: S.XSchemaLike, private readonly hasUnevaluated: boolean) { 
+  constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema, private readonly hasUnevaluated: boolean) { 
     super(context, schema)
   }
   public UseUnevaluated(): boolean {
@@ -100,7 +100,7 @@ export class BuildContext extends BaseContext {
 export class CheckContext extends BaseContext {
   private readonly indices: Set<number>
   private readonly keys: Set<string>
-  constructor(context: Record<PropertyKey, S.XSchemaLike>, schema: S.XSchemaLike) {
+  constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema) {
     super(context, schema)
     this.indices = new Set()
     this.keys = new Set()
@@ -135,7 +135,7 @@ export class CheckContext extends BaseContext {
 // ------------------------------------------------------------------
 export type ErrorContextCallback = (error: TValidationError) => unknown
 export class ErrorContext extends CheckContext {
-  constructor(context: Record<PropertyKey, S.XSchemaLike>, schema: S.XSchemaLike, private readonly callback: ErrorContextCallback) {
+  constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema, private readonly callback: ErrorContextCallback) {
     super(context, schema)
   }
   public AddError(error: TValidationError): false {
@@ -148,7 +148,7 @@ export class ErrorContext extends CheckContext {
 // ------------------------------------------------------------------
 export class AccumulatedErrorContext extends ErrorContext {
   private readonly errors: TValidationError[]
-  constructor(context: Record<PropertyKey, S.XSchemaLike>, schema: S.XSchemaLike) {
+  constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema) {
     super(context, schema, error => this.errors.push(error))
     this.errors = []
   }

src/schema/engine/_functions.ts

@@ -39,15 +39,15 @@ const functions: Map<string, string> = new Map()
 // ------------------------------------------------------------------
 // CreateCallExpression
 // ------------------------------------------------------------------
-function CreateCallExpression(context: BuildContext, schema: S.XSchemaLike, hash: string, value: string): string {
+function CreateCallExpression(context: BuildContext, schema: S.XSchema, hash: string, value: string): string {
   return context.UseUnevaluated()
     ? E.Call(`check_${hash}`, ['context', value])
     : E.Call(`check_${hash}`, [value])
 }
 // ------------------------------------------------------------------
 // CreateFunctionExpression
 // ------------------------------------------------------------------
-function CreateFunctionExpression(context: BuildContext, schema: S.XSchemaLike, hash: string): string {
+function CreateFunctionExpression(context: BuildContext, schema: S.XSchema, hash: string): string {
   const expression = BuildSchema(context, schema, 'value')
   return context.UseUnevaluated()
     ? E.ConstDeclaration(`check_${hash}`, E.ArrowFunction(['context', 'value'], expression))
@@ -68,7 +68,7 @@ export function GetFunctions(): string[] {
 // ------------------------------------------------------------------
 // CreateFunction
 // ------------------------------------------------------------------
-export function CreateFunction(context: BuildContext, schema: S.XSchemaLike, value: string): string {
+export function CreateFunction(context: BuildContext, schema: S.XSchema, value: string): string {
   const hash = Hashing.Hash(schema)
   const call = CreateCallExpression(context, schema, hash, value)
   if (functions.has(hash)) return call

src/schema/engine/_reducer.ts

@@ -67,7 +67,7 @@ import { BuildSchema } from './schema.ts'
 // })()
 //
 // ------------------------------------------------------------------
-export function Reducer(context: BuildContext, schemas: S.XSchemaLike[], value: string, check: string): string {
+export function Reducer(context: BuildContext, schemas: S.XSchema[], value: string, check: string): string {
   const results = E.ConstDeclaration('results', '[]')
   const context_n = schemas.map((_schema, index) => E.ConstDeclaration(`context_${index}`, context.Clone()))
   const condition_n = schemas.map((schema, index) => E.ConstDeclaration(`condition_${index}`, E.Call(E.ArrowFunction(['context'], BuildSchema(context, schema, value)), [`context_${index}`])))