Version 1.0.44 (#1424)

* Support RecursiveAnchor and RecursiveRef for Draft 2019-19

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.0.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.0.44](https://github.com/sinclairzx81/typebox/pull/1420)
+  - Support RecursiveAnchor and RecursiveRef for Draft 2019-19
 - [Revision 1.0.43](https://github.com/sinclairzx81/typebox/pull/1420)
   - Fix Json Pointer | Prevent Sparse Array on Delete
 - [Revision 1.0.42](https://github.com/sinclairzx81/typebox/pull/1418)

deno.jsonc

@@ -1,20 +1,20 @@
 {
   "tasks": {
-    "bench": "deno run -A tasks.ts bench",          // Benchmarks
-    "build": "deno run -A tasks.ts build",          // Build Project
-    "clean": "deno run -A tasks.ts clean",          // Clean Build Targets
-    "fast": "deno run -A tasks.ts fast",            // Interactive Tests
-    "format": "deno run -A tasks.ts format",        // Formats Code
-    "local": "deno run -A tasks.ts local",          // Build Local Project
-    "metrics": "deno run -A tasks.ts metrics",      // Compression Metrics
-    "publish": "deno run -A tasks.ts publish",      // Publish Package
-    "report": "deno run -A tasks.ts report",        // Test Converage
-    "range": "deno run -A tasks.ts range",          // TypeScript Compiler Ranges
-    "start": "deno run -A tasks.ts start",          // Run Example
-    "syntax": "deno run -A tasks.ts syntax",        // Build Parsers
-    "test": "deno run -A tasks.ts test",            // Test Project
-    "turing": "deno run -A tasks.ts turing",        // Turing Test
-    "website": "deno run -A tasks.ts website"       // Website Doc Server
+    "bench": "deno run -A tasks.ts bench",           // Benchmarks
+    "build": "deno run -A tasks.ts build",           // Build Project
+    "clean": "deno run -A tasks.ts clean",           // Clean Build Targets
+    "fast": "deno run -A tasks.ts fast",             // Interactive Tests
+    "format": "deno run -A tasks.ts format",         // Formats Code
+    "local": "deno run -A tasks.ts local",           // Build Local Project
+    "metrics": "deno run -A tasks.ts metrics",       // Compression Metrics
+    "publish": "deno run -A tasks.ts publish",       // Publish Package
+    "report": "deno run -A tasks.ts report",         // Test Converage
+    "range": "deno run -A tasks.ts range",           // TypeScript Compiler Ranges
+    "start": "deno run -A tasks.ts start",           // Run Example
+    "syntax": "deno run -A tasks.ts syntax",         // Build Parsers
+    "test": "deno run -A tasks.ts test",             // Test Project
+    "turing": "deno run -A tasks.ts turing",         // Turing Test
+    "website": "deno run -A tasks.ts website"        // Website Doc Server
   },
   "imports": {
     // --------------------------------------------------------------

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 XSchema } from './types/index.ts'
+import * as Schema from './types/index.ts'
 
 // ------------------------------------------------------------------
 // CreateCode
@@ -59,8 +59,9 @@ function CreateEvaluatedCheck(build: BuildResult, code: string): CheckFunction {
 // CreateDynamicCheck
 // ------------------------------------------------------------------
 function CreateDynamicCheck(build: BuildResult): CheckFunction {
-  const context = new Engine.CheckContext(build.Context(), build.Schema())
-  return (value: unknown) => Engine.CheckSchema(context, build.Schema(), value)
+  const stack = new Engine.Stack(build.Context(), build.Schema())
+  const context = new Engine.CheckContext()
+  return (value: unknown) => Engine.CheckSchema(stack, context, build.Schema(), value)
 }
 // ------------------------------------------------------------------
 // CreateCheck
@@ -88,19 +89,19 @@ export interface EvaluateResult {
 // ------------------------------------------------------------------
 export class BuildResult {
   constructor(
-    private readonly context: Record<PropertyKey, XSchema>,
-    private readonly schema: XSchema,
+    private readonly context: Record<PropertyKey, Schema.XSchema>,
+    private readonly schema: 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, XSchema> {
+  public Context(): Record<PropertyKey, Schema.XSchema> {
     return this.context
   }
   /** Returns the Schema used for this build */
-  public Schema(): XSchema {
+  public Schema(): Schema.XSchema {
     return this.schema
   }
   /** Returns true if this build requires a Unevaluated context */
@@ -130,19 +131,20 @@ export class BuildResult {
 // Build
 // ------------------------------------------------------------------
 /** Builds a schema into a optimized runtime validator */
-export function Build(schema: XSchema): BuildResult
+export function Build(schema: Schema.XSchema): BuildResult
 /** Builds a schema into a optimized runtime validator */
-export function Build(context: Record<PropertyKey, XSchema>, schema: XSchema): BuildResult
+export function Build(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema): BuildResult
 /** Builds a schema into a optimized runtime validator */
 export function Build(...args: unknown[]): BuildResult {
-  const [context, schema] = Arguments.Match<[Record<PropertyKey, XSchema>, XSchema]>(args, {
+  const [context, schema] = Arguments.Match<[Record<PropertyKey, Schema.XSchema>, Schema.XSchema]>(args, {
     2: (context, schema) => [context, schema],
     1: (schema) => [{}, schema]
   })
   Engine.ResetExternal()
   Engine.ResetFunctions()
-  const build = new Engine.BuildContext(context, schema, Engine.HasUnevaluated(context, schema))
-  const call = Engine.CreateFunction(build, schema, 'value')
+  const stack = new Engine.Stack(context, schema)
+  const build = new Engine.BuildContext(Engine.HasUnevaluated(context, schema))
+  const call = Engine.CreateFunction(stack, build, schema, 'value')
   const functions = Engine.GetFunctions()
   const externals = Engine.GetExternal()
   return new BuildResult(context, schema, externals, functions, call, build.UseUnevaluated())

src/schema/check.ts

@@ -30,21 +30,23 @@ THE SOFTWARE.
 // deno-lint-ignore-file
 
 import { Arguments } from '../system/arguments/index.ts'
-import { CheckSchema, CheckContext } from './engine/index.ts'
-import { XSchema } from './types/index.ts'
+import * as Engine from './engine/index.ts'
+import * as Schema from './types/index.ts'
 
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
 /** Checks a value against the provided schema */
-export function Check(schema: XSchema, value: unknown): boolean
+export function Check(schema: Schema.XSchema, value: unknown): boolean
 /** Checks a value against the provided schema */
-export function Check(context: Record<PropertyKey, XSchema>, schema: XSchema, value: unknown): boolean
+export function Check(context: Record<PropertyKey, Schema.XSchema>, schema: 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, XSchema>, XSchema, unknown]>(args, {
+  const [context, schema, value] = Arguments.Match<[Record<PropertyKey, Schema.XSchema>, Schema.XSchema, unknown]>(args, {
     3: (context, schema, value) => [context, schema, value],
     2: (schema, value) => [{}, schema, value]
   })
-  return CheckSchema(new CheckContext(context, schema), schema, value)
+  const stack = new Engine.Stack(context, schema)
+  const checkContext = new Engine.CheckContext()
+  return Engine.CheckSchema(stack, checkContext, schema, value)
 }

src/schema/engine/_context.ts

@@ -28,7 +28,7 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import * as S from '../types/index.ts'
+import * as Schema from '../types/index.ts'
 import type { TValidationError } from '../../error/index.ts'
 import { Guard as G, EmitGuard as E } from '../../guard/index.ts'
 
@@ -37,8 +37,8 @@ import { Guard as G, EmitGuard as E } from '../../guard/index.ts'
 // ------------------------------------------------------------------
 function HasUnevaluatedFromObject(value: Record<PropertyKey, unknown>): boolean {
   return (
-    S.IsUnevaluatedItems(value)
-    || S.IsUnevaluatedProperties(value)
+    Schema.IsUnevaluatedItems(value)
+    || Schema.IsUnevaluatedProperties(value)
     || G.Keys(value).some(key => HasUnevaluatedFromUnknown(value[key]))
   )
 }
@@ -55,29 +55,11 @@ function HasUnevaluatedFromUnknown(value: unknown) {
 export function HasUnevaluated(context: Record<PropertyKey, unknown>, schema: unknown): boolean {
   return HasUnevaluatedFromUnknown(schema) || G.Keys(context).some(key => HasUnevaluatedFromUnknown(context[key]))
 }
-
-// ------------------------------------------------------------------
-// BaseContext
-// ------------------------------------------------------------------
-export class BaseContext {
-  constructor(
-    protected readonly context: Record<PropertyKey, S.XSchema>,
-    protected readonly schema: S.XSchema,
-  ) { }
-  public GetContext(): Record<PropertyKey, object | boolean> {
-    return this.context
-  }
-  public GetSchema(): object | boolean {
-    return this.schema
-  }
-}
 // ------------------------------------------------------------------
 // BuildContext
 // ------------------------------------------------------------------
-export class BuildContext extends BaseContext {
-  constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema, private readonly hasUnevaluated: boolean) { 
-    super(context, schema)
-  }
+export class BuildContext {
+  constructor(private readonly hasUnevaluated: boolean) {}
   public UseUnevaluated(): boolean {
     return this.hasUnevaluated
   }
@@ -87,21 +69,17 @@ export class BuildContext extends BaseContext {
   public AddKey(key: string): string {
     return E.Call(E.Member('context', 'AddKey'), [key])
   }
-  public Clone(): string {
-    return E.Call(E.Member('context', 'Clone'), [])
-  }
   public Merge(results: string): string {
     return E.Call(E.Member('context', 'Merge'), [results])
   }
 }
 // ------------------------------------------------------------------
 // CheckContext
 // ------------------------------------------------------------------
-export class CheckContext extends BaseContext {
+export class CheckContext {
   private readonly indices: Set<number>
   private readonly keys: Set<string>
-  constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema) {
-    super(context, schema)
+  constructor() {
     this.indices = new Set()
     this.keys = new Set()
   }
@@ -119,9 +97,6 @@ export class CheckContext extends BaseContext {
   public GetKeys(): Set<string> {
     return this.keys
   }
-  public Clone() {
-    return new CheckContext(this.context, this.schema)
-  }
   public Merge(results: CheckContext[]): true {
     for (const context of results) {
       context.indices.forEach(value => this.indices.add(value))
@@ -135,8 +110,8 @@ export class CheckContext extends BaseContext {
 // ------------------------------------------------------------------
 export type ErrorContextCallback = (error: TValidationError) => unknown
 export class ErrorContext extends CheckContext {
-  constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema, private readonly callback: ErrorContextCallback) {
-    super(context, schema)
+  constructor(private readonly callback: ErrorContextCallback) {
+    super()
   }
   public AddError(error: TValidationError): false {
     this.callback(error)
@@ -148,8 +123,8 @@ export class ErrorContext extends CheckContext {
 // ------------------------------------------------------------------
 export class AccumulatedErrorContext extends ErrorContext {
   private readonly errors: TValidationError[]
-  constructor(context: Record<PropertyKey, S.XSchema>, schema: S.XSchema) {
-    super(context, schema, error => this.errors.push(error))
+  constructor() {
+    super(error => this.errors.push(error))
     this.errors = []
   }
   public override AddError(error: TValidationError): false {

src/schema/engine/_externals.ts

@@ -54,9 +54,9 @@ export function ResetExternal(): void {
   resetCount += 1
 }
 // ------------------------------------------------------------------
-// CreateExternalVariable
+// CreateVariable
 // ------------------------------------------------------------------
-export function CreateExternalVariable(value: unknown): string {
+export function CreateVariable(value: unknown): string {
   const call = `${state.identifier}[${state.variables.length}]`
   state.variables.push(value)
   return call

src/schema/engine/_functions.ts

@@ -28,27 +28,28 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import * as S from '../types/index.ts'
+import * as Schema from '../types/index.ts'
 import { Hashing } from '../../system/hashing/index.ts'
+import { Stack } from './_stack.ts'
+import { BuildContext } from './_context.ts'
 import { EmitGuard as E } from '../../guard/index.ts'
 import { BuildSchema } from './schema.ts'
-import { BuildContext } from './_context.ts'
 
 const functions: Map<string, string> = new Map()
 
 // ------------------------------------------------------------------
 // CreateCallExpression
 // ------------------------------------------------------------------
-function CreateCallExpression(context: BuildContext, schema: S.XSchema, hash: string, value: string): string {
+function CreateCallExpression(context: BuildContext, schema: Schema.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.XSchema, hash: string): string {
-  const expression = BuildSchema(context, schema, 'value')
+function CreateFunctionExpression(stack: Stack, context: BuildContext, schema: Schema.XSchema, hash: string): string {
+  const expression = BuildSchema(stack, context, schema, 'value')
   return context.UseUnevaluated()
     ? E.ConstDeclaration(`check_${hash}`, E.ArrowFunction(['context', 'value'], expression))
     : E.ConstDeclaration(`check_${hash}`, E.ArrowFunction(['value'], expression))
@@ -68,11 +69,11 @@ export function GetFunctions(): string[] {
 // ------------------------------------------------------------------
 // CreateFunction
 // ------------------------------------------------------------------
-export function CreateFunction(context: BuildContext, schema: S.XSchema, value: string): string {
-  const hash = Hashing.Hash(schema)
+export function CreateFunction(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string {
+  const hash = Schema.IsSchemaObject(schema) ? Hashing.Hash({ __baseURL: stack.BaseURL().href, ...schema }) : Hashing.Hash(schema)
   const call = CreateCallExpression(context, schema, hash, value)
   if (functions.has(hash)) return call
   functions.set(hash, '')
-  functions.set(hash, CreateFunctionExpression(context, schema, hash))
+  functions.set(hash, CreateFunctionExpression(stack, context, schema, hash))
   return call
 }

src/schema/engine/_guard.ts

@@ -28,27 +28,28 @@ THE SOFTWARE.
 
 // deno-fmt-ignore-file
 
-import * as S from '../types/index.ts'
-import * as V from './_externals.ts'
-import { EmitGuard as E } from '../../guard/index.ts'
+import * as Schema from '../types/index.ts'
+import * as Externals from './_externals.ts'
+import { Stack } from './_stack.ts'
 import { BuildContext, CheckContext, ErrorContext } from './_context.ts'
+import { EmitGuard as E } from '../../guard/index.ts'
 
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildGuard(context: BuildContext, schema: S.XGuard, value: string): string {
-  return E.Call(E.Member(E.Member(V.CreateExternalVariable(schema), '~guard'), 'check'), [value])
+export function BuildGuard(stack: Stack, context: BuildContext, schema: Schema.XGuard, value: string): string {
+  return E.Call(E.Member(E.Member(Externals.CreateVariable(schema), '~guard'), 'check'), [value])
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckGuard(context: CheckContext, schema: S.XGuard, value: unknown): boolean {
+export function CheckGuard(stack: Stack, context: CheckContext, schema: Schema.XGuard, value: unknown): boolean {
   return schema['~guard'].check(value)
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorGuard(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XGuard, value: unknown): boolean {
+export function ErrorGuard(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XGuard, value: unknown): boolean {
   return schema['~guard'].check(value) || context.AddError({
     keyword: '~guard',
     schemaPath,

src/schema/engine/_reducer.ts

@@ -29,8 +29,9 @@ THE SOFTWARE.
 // deno-fmt-ignore-file
 
 import * as S from '../types/index.ts'
-import { EmitGuard as E } from '../../guard/index.ts'
+import { Stack } from './_stack.ts'
 import { BuildContext } from './_context.ts'
+import { EmitGuard as E } from '../../guard/index.ts'
 import { BuildSchema } from './schema.ts'
 
 // ------------------------------------------------------------------
@@ -67,10 +68,10 @@ import { BuildSchema } from './schema.ts'
 // })()
 //
 // ------------------------------------------------------------------
-export function Reducer(context: BuildContext, schemas: S.XSchema[], value: string, check: string): string {
+export function Reducer(stack: Stack, 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}`])))
+  const context_n = schemas.map((_schema, index) => E.ConstDeclaration(`context_${index}`, E.New('CheckContext', [])))
+  const condition_n = schemas.map((schema, index) => E.ConstDeclaration(`condition_${index}`, E.Call(E.ArrowFunction(['context'], BuildSchema(stack, context, schema, value)), [`context_${index}`])))
   const checks = schemas.map((_schema, index) => E.If(`condition_${index}`, E.Call(E.Member('results', 'push'), [`context_${index}`])))
   const returns = E.Return(E.And(check, context.Merge('results')))
   return E.Call(E.ArrowFunction([], E.Statements([results, ...context_n, ...condition_n, ...checks, returns])), [])