typebox 1.0.43 → 1.0.44

package/build/schema/engine/propertyNames.d.mts

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildPropertyNames(context: BuildContext, schema: S.XPropertyNames, value: string): string;
-export declare function CheckPropertyNames(context: CheckContext, schema: S.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorPropertyNames(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildPropertyNames(stack: Stack, context: BuildContext, schema: Schema.XPropertyNames, value: string): string;
+export declare function CheckPropertyNames(stack: Stack, context: CheckContext, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorPropertyNames(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/propertyNames.mjs

@@ -1,29 +1,31 @@
 // deno-fmt-ignore-file
-import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import { Unique } from './_unique.mjs';
 import { AccumulatedErrorContext } from './_context.mjs';
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildPropertyNames(context, schema, value) {
-    return E.Call(E.Member(E.Keys(value), 'every'), [E.ArrowFunction(['key'], BuildSchema(context, schema.propertyNames, 'key'))]);
+export function BuildPropertyNames(stack, context, schema, value) {
+    const [key, _index] = [Unique(), Unique()];
+    return E.Every(E.Keys(value), E.Constant(0), [key, _index], BuildSchema(stack, context, schema.propertyNames, key));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckPropertyNames(context, schema, value) {
-    return G.Every(G.Keys(value), 0, (key) => CheckSchema(context, schema.propertyNames, key));
+export function CheckPropertyNames(stack, context, schema, value) {
+    return G.Every(G.Keys(value), 0, (key, _index) => CheckSchema(stack, context, schema.propertyNames, key));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorPropertyNames(context, schemaPath, instancePath, schema, value) {
+export function ErrorPropertyNames(stack, context, schemaPath, instancePath, schema, value) {
     const propertyNames = [];
-    const isPropertyNames = G.EveryAll(G.Keys(value), 0, (key) => {
+    const isPropertyNames = G.EveryAll(G.Keys(value), 0, (key, _index) => {
         const nextInstancePath = `${instancePath}/${key}`;
         const nextSchemaPath = `${schemaPath}/propertyNames`;
-        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
-        const isPropertyName = ErrorSchema(nextContext, nextSchemaPath, nextInstancePath, schema.propertyNames, key);
+        const nextContext = new AccumulatedErrorContext();
+        const isPropertyName = ErrorSchema(stack, nextContext, nextSchemaPath, nextInstancePath, schema.propertyNames, key);
         if (!isPropertyName)
             propertyNames.push(key);
         return isPropertyName;

package/build/schema/engine/recursiveRef.d.mts

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRecursiveRef(context: BuildContext, schema: S.XRecursiveRef, value: string): string;
-export declare function CheckRecursiveRef(context: CheckContext, schema: S.XRecursiveRef, value: unknown): boolean;
-export declare function ErrorRecursiveRef(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRecursiveRef, value: unknown): boolean;
+export declare function BuildRecursiveRef(stack: Stack, context: BuildContext, schema: Schema.XRecursiveRef, value: string): string;
+export declare function CheckRecursiveRef(stack: Stack, context: CheckContext, schema: Schema.XRecursiveRef, value: unknown): boolean;
+export declare function ErrorRecursiveRef(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRecursiveRef, value: unknown): boolean;

package/build/schema/engine/recursiveRef.mjs

@@ -1,36 +1,25 @@
 // deno-fmt-ignore-file
-import * as F from './_functions.mjs';
-import * as S from '../types/index.mjs';
+import * as Functions from './_functions.mjs';
+import * as Schema from '../types/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
-import { Resolver } from '../resolver/index.mjs';
-// ------------------------------------------------------------------
-// Resolve
-// ------------------------------------------------------------------
-function Resolve(context, schema) {
-    // note: it is safe to coerce to XSchema here as it wouldn't be possible
-    // to enter a ref resolution if the root schema was boolean.
-    const schemaRoot = context.GetSchema();
-    const dereferenced = Resolver.RecursiveRef(schemaRoot, schema);
-    return S.IsSchema(dereferenced) ? dereferenced : false;
-}
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildRecursiveRef(context, schema, value) {
-    const target = Resolve(context, schema);
-    return F.CreateFunction(context, target, value);
+export function BuildRecursiveRef(stack, context, schema, value) {
+    const target = stack.RecursiveRef(schema.$recursiveRef) ?? false;
+    return Functions.CreateFunction(stack, context, target, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckRecursiveRef(context, schema, value) {
-    const target = Resolve(context, schema);
-    return (S.IsSchema(target) && CheckSchema(context, target, value));
+export function CheckRecursiveRef(stack, context, schema, value) {
+    const target = stack.RecursiveRef(schema.$recursiveRef) ?? false;
+    return (Schema.IsSchema(target) && CheckSchema(stack, context, target, value));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRecursiveRef(context, schemaPath, instancePath, schema, value) {
-    const target = Resolve(context, schema);
-    return (S.IsSchema(target) && ErrorSchema(context, '#', instancePath, target, value));
+export function ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema, value) {
+    const target = stack.RecursiveRef(schema.$recursiveRef) ?? false;
+    return (Schema.IsSchema(target) && ErrorSchema(stack, context, '#', instancePath, target, value));
 }

package/build/schema/engine/ref.d.mts

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRef(context: BuildContext, schema: S.XRef, value: string): string;
-export declare function CheckRef(context: CheckContext, schema: S.XRef, value: unknown): boolean;
-export declare function ErrorRef(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRef, value: unknown): boolean;
+export declare function BuildRef(stack: Stack, context: BuildContext, schema: Schema.XRef, value: string): string;
+export declare function CheckRef(stack: Stack, context: CheckContext, schema: Schema.XRef, value: unknown): boolean;
+export declare function ErrorRef(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRef, value: unknown): boolean;

package/build/schema/engine/ref.mjs

@@ -1,43 +1,58 @@
 // deno-fmt-ignore-file
-import * as F from './_functions.mjs';
-import * as S from '../types/index.mjs';
-import { Guard as G } from '../../guard/index.mjs';
+import * as Functions from './_functions.mjs';
+import * as Schema from '../types/index.mjs';
+import { CheckContext, AccumulatedErrorContext } from './_context.mjs';
+import { EmitGuard as E } from '../../guard/index.mjs';
 import { CheckSchema, ErrorSchema } from './schema.mjs';
-import { Resolver } from '../resolver/index.mjs';
-// ------------------------------------------------------------------
-// Resolve
-// ------------------------------------------------------------------
-function Resolve(context, schema) {
-    // note: it is safe to coerce to XSchema here as it wouldn't be possible
-    // to enter a ref resolution if the root schema was boolean.
-    const schemaRoot = context.GetSchema();
-    // contextual schema
-    const schemaContext = context.GetContext();
-    if (G.HasPropertyKey(schemaContext, schema.$ref)) {
-        return schemaContext[schema.$ref];
-    }
-    // referential schema
-    const dereferenced = Resolver.Ref(schemaRoot, schema.$ref);
-    return S.IsSchema(dereferenced) ? dereferenced : false;
+// ------------------------------------------------------------------
+// BuildRefStandard
+// ------------------------------------------------------------------
+function BuildRefStandard(stack, context, target, value) {
+    const interior = E.ArrowFunction(['context', 'value'], Functions.CreateFunction(stack, context, target, 'value'));
+    const exterior = E.ArrowFunction(['context', 'value'], E.Statements([
+        E.ConstDeclaration('nextContext', E.New('CheckContext', [])),
+        E.ConstDeclaration('result', E.Call(interior, ['nextContext', 'value'])),
+        E.If('result', context.Merge('[nextContext]')),
+        E.Return('result')
+    ]));
+    return E.Call(exterior, ['context', value]);
+}
+// ------------------------------------------------------------------
+// BuildRefStandard
+// ------------------------------------------------------------------
+function BuildRefFast(stack, context, target, value) {
+    return Functions.CreateFunction(stack, context, target, value);
 }
 // ------------------------------------------------------------------
-// Build
+// BuildRef
 // ------------------------------------------------------------------
-export function BuildRef(context, schema, value) {
-    const target = Resolve(context, schema);
-    return F.CreateFunction(context, target, value);
+export function BuildRef(stack, context, schema, value) {
+    const target = stack.Ref(schema.$ref) ?? false;
+    return context.UseUnevaluated()
+        ? BuildRefStandard(stack, context, target, value)
+        : BuildRefFast(stack, context, target, value);
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckRef(context, schema, value) {
-    const target = Resolve(context, schema);
-    return (S.IsSchema(target) && CheckSchema(context, target, value));
+export function CheckRef(stack, context, schema, value) {
+    const target = stack.Ref(schema.$ref) ?? false;
+    const nextContext = new CheckContext();
+    const result = (Schema.IsSchema(target) && CheckSchema(stack, nextContext, target, value));
+    if (result)
+        context.Merge([nextContext]);
+    return result;
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRef(context, schemaPath, instancePath, schema, value) {
-    const target = Resolve(context, schema);
-    return (S.IsSchema(target) && ErrorSchema(context, '#', instancePath, target, value));
+export function ErrorRef(stack, context, schemaPath, instancePath, schema, value) {
+    const target = stack.Ref(schema.$ref) ?? false;
+    const nextContext = new AccumulatedErrorContext();
+    const result = (Schema.IsSchema(target) && ErrorSchema(stack, nextContext, '#', instancePath, target, value));
+    if (result)
+        context.Merge([nextContext]);
+    if (!result)
+        nextContext.GetErrors().forEach(error => context.AddError(error));
+    return result;
 }

package/build/schema/engine/required.d.mts

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildRequired(context: BuildContext, schema: S.XRequired, value: string): string;
-export declare function CheckRequired(context: CheckContext, schema: S.XRequired, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorRequired(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildRequired(stack: Stack, context: BuildContext, schema: Schema.XRequired, value: string): string;
+export declare function CheckRequired(stack: Stack, context: CheckContext, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorRequired(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XRequired, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/required.mjs

@@ -3,19 +3,19 @@ import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildRequired(context, schema, value) {
+export function BuildRequired(stack, context, schema, value) {
     return E.ReduceAnd(schema.required.map((key) => E.HasPropertyKey(value, E.Constant(key))));
 }
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckRequired(context, schema, value) {
+export function CheckRequired(stack, context, schema, value) {
     return G.Every(schema.required, 0, (key) => G.HasPropertyKey(value, key));
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorRequired(context, schemaPath, instancePath, schema, value) {
+export function ErrorRequired(stack, context, schemaPath, instancePath, schema, value) {
     const requiredProperties = [];
     const isRequired = G.EveryAll(schema.required, 0, (key) => {
         const hasKey = G.HasPropertyKey(value, key);

package/build/schema/engine/schema.d.mts

@@ -1,5 +1,6 @@
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
+import { Stack } from './_stack.mjs';
 import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
-export declare function BuildSchema(context: BuildContext, schema: S.XSchema, value: string): string;
-export declare function CheckSchema(context: CheckContext, schema: S.XSchema, value: unknown): boolean;
-export declare function ErrorSchema(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XSchema, value: unknown): boolean;
+export declare function BuildSchema(stack: Stack, context: BuildContext, schema: Schema.XSchema, value: string): string;
+export declare function CheckSchema(stack: Stack, context: CheckContext, schema: Schema.XSchema, value: unknown): boolean;
+export declare function ErrorSchema(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XSchema, value: unknown): boolean;