typebox 1.0.42 → 1.0.44

package/build/schema/engine/unevaluatedItems.mjs

@@ -1,16 +1,18 @@
 // deno-fmt-ignore-file
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { Unique } from './_unique.mjs';
 import { AccumulatedErrorContext } from './_context.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildUnevaluatedItems(context, schema, value) {
+export function BuildUnevaluatedItems(stack, context, schema, value) {
+    const [index, item] = [Unique(), Unique()];
     const indices = E.Call(E.Member('context', 'GetIndices'), []);
-    const hasIndex = E.Call(E.Member('indices', 'has'), ['index']);
-    const isSchema = BuildSchema(context, schema.unevaluatedItems, 'value');
-    const addIndex = E.Call(E.Member('context', 'AddIndex'), ['index']);
-    const isEvery = E.Every(value, E.Constant(0), ['value', 'index'], E.And(E.Or(hasIndex, isSchema), addIndex));
+    const hasIndex = E.Call(E.Member('indices', 'has'), [index]);
+    const isSchema = BuildSchema(stack, context, schema.unevaluatedItems, item);
+    const addIndex = E.Call(E.Member('context', 'AddIndex'), [index]);
+    const isEvery = E.Every(value, E.Constant(0), [item, index], E.And(E.Or(hasIndex, isSchema), addIndex));
     return E.Call(E.ArrowFunction(['context'], E.Statements([
         E.ConstDeclaration('indices', indices),
         E.Return(isEvery)
@@ -19,22 +21,22 @@ export function BuildUnevaluatedItems(context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckUnevaluatedItems(context, schema, value) {
+export function CheckUnevaluatedItems(stack, context, schema, value) {
     const indices = context.GetIndices();
-    return G.Every(value, 0, (value, index) => {
-        return (indices.has(index) || CheckSchema(context, schema.unevaluatedItems, value))
+    return G.Every(value, 0, (item, index) => {
+        return (indices.has(index) || CheckSchema(stack, context, schema.unevaluatedItems, item))
             && context.AddIndex(index);
     });
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorUnevaluatedItems(context, schemaPath, instancePath, schema, value) {
+export function ErrorUnevaluatedItems(stack, context, schemaPath, instancePath, schema, value) {
     const indices = context.GetIndices();
     const unevaluatedItems = [];
-    const isUnevaluatedItems = G.EveryAll(value, 0, (value, index) => {
-        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
-        const isEvaluatedItem = (indices.has(index) || ErrorSchema(nextContext, schemaPath, instancePath, schema.unevaluatedItems, value))
+    const isUnevaluatedItems = G.EveryAll(value, 0, (item, index) => {
+        const nextContext = new AccumulatedErrorContext();
+        const isEvaluatedItem = (indices.has(index) || ErrorSchema(stack, nextContext, schemaPath, instancePath, schema.unevaluatedItems, item))
             && context.AddIndex(index);
         if (!isEvaluatedItem)
             unevaluatedItems.push(index);

package/build/schema/engine/unevaluatedProperties.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 BuildUnevaluatedProperties(context: BuildContext, schema: S.XUnevaluatedProperties, value: string): string;
-export declare function CheckUnevaluatedProperties(context: CheckContext, schema: S.XUnevaluatedProperties, value: Record<PropertyKey, unknown>): boolean;
-export declare function ErrorUnevaluatedProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XUnevaluatedProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function BuildUnevaluatedProperties(stack: Stack, context: BuildContext, schema: Schema.XUnevaluatedProperties, value: string): string;
+export declare function CheckUnevaluatedProperties(stack: Stack, context: CheckContext, schema: Schema.XUnevaluatedProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorUnevaluatedProperties(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XUnevaluatedProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/unevaluatedProperties.mjs

@@ -1,16 +1,18 @@
 // deno-fmt-ignore-file
-import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { Unique } from './_unique.mjs';
 import { AccumulatedErrorContext } from './_context.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildUnevaluatedProperties(context, schema, value) {
+export function BuildUnevaluatedProperties(stack, context, schema, value) {
+    const [key, prop] = [Unique(), Unique()];
     const keys = E.Call(E.Member('context', 'GetKeys'), []);
-    const hasKey = E.Call(E.Member('keys', 'has'), ['key']);
-    const addKey = E.Call(E.Member('context', 'AddKey'), ['key']);
-    const isSchema = BuildSchema(context, schema.unevaluatedProperties, `value`);
-    const isEvery = E.Every(E.Entries(value), E.Constant(0), ['[key, value]', '_'], E.Or(hasKey, E.And(isSchema, addKey)));
+    const hasKey = E.Call(E.Member('keys', 'has'), [key]);
+    const addKey = E.Call(E.Member('context', 'AddKey'), [key]);
+    const isSchema = BuildSchema(stack, context, schema.unevaluatedProperties, prop);
+    const isEvery = E.Every(E.Entries(value), E.Constant(0), [`[${key}, ${prop}]`, '_'], E.Or(hasKey, E.And(isSchema, addKey)));
     return E.Call(E.ArrowFunction(['context'], E.Statements([
         E.ConstDeclaration('keys', keys),
         E.Return(isEvery)
@@ -19,23 +21,23 @@ export function BuildUnevaluatedProperties(context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckUnevaluatedProperties(context, schema, value) {
+export function CheckUnevaluatedProperties(stack, context, schema, value) {
     const keys = context.GetKeys();
-    return G.Every(G.Entries(value), 0, ([key, value]) => {
+    return G.Every(G.Entries(value), 0, ([key, prop]) => {
         return keys.has(key)
-            || (CheckSchema(context, schema.unevaluatedProperties, value) && context.AddKey(key));
+            || (CheckSchema(stack, context, schema.unevaluatedProperties, prop) && context.AddKey(key));
     });
 }
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorUnevaluatedProperties(context, schemaPath, instancePath, schema, value) {
+export function ErrorUnevaluatedProperties(stack, context, schemaPath, instancePath, schema, value) {
     const keys = context.GetKeys();
     const unevaluatedProperties = [];
-    const isUnevaluatedProperties = G.EveryAll(G.Entries(value), 0, ([key, value]) => {
-        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+    const isUnevaluatedProperties = G.EveryAll(G.Entries(value), 0, ([key, prop]) => {
+        const nextContext = new AccumulatedErrorContext();
         const isEvaluatedProperty = keys.has(key)
-            || (ErrorSchema(nextContext, schemaPath, instancePath, schema.unevaluatedProperties, value) && context.AddKey(key));
+            || (ErrorSchema(stack, nextContext, schemaPath, instancePath, schema.unevaluatedProperties, prop) && context.AddKey(key));
         if (!isEvaluatedProperty)
             unevaluatedProperties.push(key);
         return isEvaluatedProperty;

package/build/schema/engine/uniqueItems.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 BuildUniqueItems(context: BuildContext, schema: S.XUniqueItems, value: string): string;
-export declare function CheckUniqueItems(context: CheckContext, schema: S.XUniqueItems, value: unknown[]): boolean;
-export declare function ErrorUniqueItems(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XUniqueItems, value: unknown[]): boolean;
+export declare function BuildUniqueItems(stack: Stack, context: BuildContext, schema: Schema.XUniqueItems, value: string): string;
+export declare function CheckUniqueItems(stack: Stack, context: CheckContext, schema: Schema.XUniqueItems, value: unknown[]): boolean;
+export declare function ErrorUniqueItems(stack: Stack, context: ErrorContext, schemaPath: string, instancePath: string, schema: Schema.XUniqueItems, value: unknown[]): boolean;

package/build/schema/engine/uniqueItems.mjs

@@ -10,7 +10,7 @@ function IsValid(schema) {
 // ------------------------------------------------------------------
 // Build
 // ------------------------------------------------------------------
-export function BuildUniqueItems(context, schema, value) {
+export function BuildUniqueItems(stack, context, schema, value) {
     if (!IsValid(schema))
         return E.Constant(true);
     const set = E.Member(E.New('Set', [E.Call(E.Member(value, 'map'), [E.Member('Hashing', 'Hash')])]), 'size');
@@ -20,7 +20,7 @@ export function BuildUniqueItems(context, schema, value) {
 // ------------------------------------------------------------------
 // Check
 // ------------------------------------------------------------------
-export function CheckUniqueItems(context, schema, value) {
+export function CheckUniqueItems(stack, context, schema, value) {
     if (!IsValid(schema))
         return true;
     const set = new Set(value.map(Hashing.Hash)).size;
@@ -30,7 +30,7 @@ export function CheckUniqueItems(context, schema, value) {
 // ------------------------------------------------------------------
 // Error
 // ------------------------------------------------------------------
-export function ErrorUniqueItems(context, schemaPath, instancePath, schema, value) {
+export function ErrorUniqueItems(stack, context, schemaPath, instancePath, schema, value) {
     if (!IsValid(schema))
         return true;
     const set = new Set();

package/build/schema/errors.d.mts

@@ -1,6 +1,6 @@
 import { type TLocalizedValidationError } from '../error/index.mjs';
-import { type XSchema } from './types/index.mjs';
+import * as Schema from './types/index.mjs';
 /** Checks a value and returns validation errors */
-export declare function Errors(schema: XSchema, value: unknown): [boolean, TLocalizedValidationError[]];
+export declare function Errors(schema: Schema.XSchema, value: unknown): [boolean, TLocalizedValidationError[]];
 /** Checks a value and returns validation errors */
-export declare function Errors(context: Record<PropertyKey, XSchema>, schema: XSchema, value: unknown): [boolean, TLocalizedValidationError[]];
+export declare function Errors(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, value: unknown): [boolean, TLocalizedValidationError[]];

package/build/schema/errors.mjs

@@ -1,10 +1,9 @@
 // deno-fmt-ignore-file
-// deno-lint-ignore-file
 import { Arguments } from '../system/arguments/index.mjs';
 import { Settings } from '../system/settings/index.mjs';
 import { Get as LocaleGet } from '../system/locale/_config.mjs';
 import { Guard } from '../guard/index.mjs';
-import { ErrorSchema, ErrorContext } from './engine/index.mjs';
+import * as Engine from './engine/index.mjs';
 /** Checks a value and returns validation errors */
 export function Errors(...args) {
     const [context, schema, value] = Arguments.Match(args, {
@@ -14,11 +13,12 @@ export function Errors(...args) {
     const settings = Settings.Get();
     const locale = LocaleGet();
     const errors = [];
-    const errorContext = new ErrorContext(context, schema, error => {
+    const stack = new Engine.Stack(context, schema);
+    const errorContext = new Engine.ErrorContext(error => {
         if (Guard.IsGreaterEqualThan(errors.length, settings.maxErrors))
             return;
         return errors.push({ ...error, message: locale(error) });
     });
-    const result = ErrorSchema(errorContext, '#', '', schema, value);
+    const result = Engine.ErrorSchema(stack, errorContext, '#', '', schema, value);
     return [result, errors];
 }

package/build/schema/pointer/pointer.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
-// Indices
+// Asserts
 // ------------------------------------------------------------------
 function AssertNotRoot(indices) {
     if (indices.length === 0)
@@ -14,6 +14,9 @@ function AssertCanSet(value) {
 // ------------------------------------------------------------------
 // Indices
 // ------------------------------------------------------------------
+function IsNumericIndex(index) {
+    return /^(0|[1-9]\d*)$/.test(index);
+}
 function TakeIndexRight(indices) {
     return [
         indices.slice(0, indices.length - 1),
@@ -83,6 +86,11 @@ export function Delete(value, pointer) {
     const [head, index] = TakeIndexRight(indices);
     const parent = GetIndices(head, value);
     AssertCanSet(parent);
-    delete parent[index];
+    if (Guard.IsArray(parent) && IsNumericIndex(index)) {
+        parent.splice(+index, 1);
+    }
+    else {
+        delete parent[index];
+    }
     return value;
 }

package/build/schema/resolve/index.d.mts

@@ -0,0 +1 @@
+export * as Resolve from './resolve.mjs';

package/build/schema/resolve/index.mjs

@@ -0,0 +1 @@
+export * as Resolve from './resolve.mjs';

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

@@ -0,0 +1,2 @@
+import * as Schema from '../types/index.mjs';
+export declare function Ref(schema: Schema.XSchemaObject, ref: string): Schema.XSchema | undefined;

package/build/schema/{resolver → resolve}/ref.mjs

@@ -1,98 +1,96 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../guard/index.mjs';
 import { Pointer } from '../pointer/index.mjs';
-import * as S from '../types/index.mjs';
+import * as Schema from '../types/index.mjs';
 // ------------------------------------------------------------------
-// MatchId
+// Match: Id
 // ------------------------------------------------------------------
-function MatchId(value, base, ref) {
-    if (value.$id === ref.hash)
-        return value;
-    const absoluteId = new URL(value.$id, base.href);
+function MatchId(schema, base, ref) {
+    if (schema.$id === ref.hash)
+        return schema;
+    const absoluteId = new URL(schema.$id, base.href);
     const absoluteRef = new URL(ref.href, base.href);
     if (Guard.IsEqual(absoluteId.pathname, absoluteRef.pathname)) {
-        return ref.hash.startsWith('#') ? MatchHash(value, base, ref) : value;
+        return ref.hash.startsWith('#') ? MatchHash(schema, base, ref) : schema;
     }
     return undefined;
 }
 // ------------------------------------------------------------------
-// MatchAnchor
+// Match: Anchor
 // ------------------------------------------------------------------
-function MatchAnchor(value, base, ref) {
-    const absoluteAnchor = new URL(`#${value.$anchor}`, base.href);
+function MatchAnchor(schema, base, ref) {
+    const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
     const absoluteRef = new URL(ref.href, base.href);
     if (Guard.IsEqual(absoluteAnchor.href, absoluteRef.href))
-        return value;
+        return schema;
     return undefined;
 }
 // ------------------------------------------------------------------
-// MatchHash
+// Match: Hash
 // ------------------------------------------------------------------
-function MatchHash(value, base, ref) {
+function MatchHash(schema, base, ref) {
     if (ref.href.endsWith('#'))
-        return value;
+        return schema;
     return ref.hash.startsWith('#')
-        ? Pointer.Get(value, decodeURIComponent(ref.hash.slice(1)))
+        ? Pointer.Get(schema, decodeURIComponent(ref.hash.slice(1)))
         : undefined;
 }
 // ------------------------------------------------------------------
 // Match
 // ------------------------------------------------------------------
-function Match(value, base, ref) {
-    if (S.IsId(value)) {
-        const result = MatchId(value, base, ref);
+function Match(schema, base, ref) {
+    if (Schema.IsId(schema)) {
+        const result = MatchId(schema, base, ref);
         if (!Guard.IsUndefined(result))
             return result;
     }
-    if (S.IsAnchor(value)) {
-        const result = MatchAnchor(value, base, ref);
+    if (Schema.IsAnchor(schema)) {
+        const result = MatchAnchor(schema, base, ref);
         if (!Guard.IsUndefined(result))
             return result;
     }
-    return MatchHash(value, base, ref);
+    return MatchHash(schema, base, ref);
 }
 // ------------------------------------------------------------------
 // FromArray
 // ------------------------------------------------------------------
-function FromArray(value, base, ref) {
-    for (const item of value) {
-        const result = FromValue(item, base, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    return undefined;
+function FromArray(schema, base, ref) {
+    return schema.reduce((result, item) => {
+        const match = FromValue(item, base, ref);
+        return !Guard.IsUndefined(match) ? match : result;
+    }, undefined);
 }
 // ------------------------------------------------------------------
 // FromObject
 // ------------------------------------------------------------------
-function FromObject(value, base, ref) {
-    for (const key of Guard.Keys(value)) {
-        const result = FromValue(value[key], base, ref);
-        if (!Guard.IsUndefined(result))
-            return result;
-    }
-    return undefined;
+function FromObject(schema, base, ref) {
+    return Guard.Keys(schema).reduce((result, key) => {
+        const match = FromValue(schema[key], base, ref);
+        return !Guard.IsUndefined(match) ? match : result;
+    }, undefined);
 }
 // ------------------------------------------------------------------
 // FromValue
 // ------------------------------------------------------------------
-function FromValue(value, base, ref) {
-    const newbase = S.IsSchemaObject(value) && S.IsId(value) ? new URL(value.$id, ref.href) : base;
-    if (S.IsSchemaObject(value)) {
-        const result = Match(value, newbase, ref);
+function FromValue(schema, base, ref) {
+    base = Schema.IsSchemaObject(schema) && Schema.IsId(schema) ? new URL(schema.$id, base.href) : base;
+    if (Schema.IsSchemaObject(schema)) {
+        const result = Match(schema, base, ref);
         if (!Guard.IsUndefined(result))
             return result;
     }
-    if (Guard.IsArray(value))
-        return FromArray(value, newbase, ref);
-    if (Guard.IsObject(value))
-        return FromObject(value, newbase, ref);
+    if (Guard.IsArray(schema))
+        return FromArray(schema, base, ref);
+    if (Guard.IsObject(schema))
+        return FromObject(schema, base, ref);
     return undefined;
 }
 // ------------------------------------------------------------------
 // Ref
 // ------------------------------------------------------------------
 export function Ref(schema, ref) {
-    const base = new URL('', 'http://domain.com');
-    return FromValue(schema, base, new URL(ref, 'http://domain.com'));
+    const defaultBase = new URL('memory://root');
+    const initialBase = Schema.IsId(schema) ? new URL(schema.$id, defaultBase.href) : defaultBase;
+    const initialRef = new URL(ref, initialBase.href);
+    return FromValue(schema, initialBase, initialRef);
 }

package/build/schema/resolve/resolve.d.mts

@@ -0,0 +1 @@
+export * from './ref.mjs';

package/build/schema/resolve/resolve.mjs

@@ -0,0 +1 @@
+export * from './ref.mjs';

package/build/schema/schema.d.mts

@@ -1,6 +1,6 @@
 export * from './engine/index.mjs';
 export * from './pointer/index.mjs';
-export * from './resolver/index.mjs';
+export * from './resolve/index.mjs';
 export * from './static/index.mjs';
 export * from './types/index.mjs';
 export * from './build.mjs';

package/build/schema/schema.mjs

@@ -1,6 +1,6 @@
 export * from './engine/index.mjs';
 export * from './pointer/index.mjs';
-export * from './resolver/index.mjs';
+export * from './resolve/index.mjs';
 export * from './static/index.mjs';
 export * from './types/index.mjs';
 export * from './build.mjs';

package/build/schema/types/recursiveAnchor.d.mts

@@ -6,3 +6,7 @@ export interface XRecursiveAnchor<Anchor extends string = string> {
  * Returns true if the schema contains a valid $recursiveAnchor property
  */
 export declare function IsRecursiveAnchor(schema: XSchemaObject): schema is XRecursiveAnchor;
+/**
+ * Returns true if the schema contains a valid $recursiveAnchor property that is true
+ */
+export declare function IsRecursiveAnchorTrue(schema: XSchemaObject): schema is XRecursiveAnchor;

package/build/schema/types/recursiveAnchor.mjs

@@ -10,3 +10,10 @@ export function IsRecursiveAnchor(schema) {
     return Guard.HasPropertyKey(schema, '$recursiveAnchor')
         && Guard.IsBoolean(schema.$recursiveAnchor);
 }
+/**
+ * Returns true if the schema contains a valid $recursiveAnchor property that is true
+ */
+export function IsRecursiveAnchorTrue(schema) {
+    return IsRecursiveAnchor(schema)
+        && Guard.IsEqual(schema.$recursiveAnchor, true);
+}

package/build/type/types/static.d.mts

@@ -39,10 +39,10 @@ export type StaticEvaluate<T> = {
 export type StaticDirection = 'Encode' | 'Decode';
 export type StaticType<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema> = (Type extends TCodec<infer Type extends TSchema, infer Decoded extends unknown> ? StaticCodec<Stack, Direction, Context, This, Type, Decoded> : Type extends TAny ? StaticAny : Type extends TArray<infer Items extends TSchema> ? StaticArray<Stack, Direction, Context, This, Type, Items> : Type extends TAsyncIterator<infer Type extends TSchema> ? StaticAsyncIterator<Stack, Direction, Context, This, Type> : Type extends Base<infer Value extends unknown> ? StaticBase<Value> : Type extends TBigInt ? StaticBigInt : Type extends TBoolean ? StaticBoolean : Type extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticConstructor<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TEnum<infer Values extends TEnumValue[]> ? StaticEnum<Values> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticFunction<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TInteger ? StaticInteger : Type extends TIntersect<infer Types extends TSchema[]> ? StaticIntersect<Stack, Direction, Context, This, Types> : Type extends TIterator<infer Types extends TSchema> ? StaticIterator<Stack, Direction, Context, This, Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? StaticLiteral<Value> : Type extends TNever ? StaticNever : Type extends TNull ? StaticNull : Type extends TNumber ? StaticNumber : Type extends TObject<infer Properties extends TProperties> ? StaticObject<Stack, Direction, Context, This, Properties> : Type extends TPromise<infer Type extends TSchema> ? StaticPromise<Stack, Direction, Context, This, Type> : Type extends TRecord<infer Key extends string, infer Value extends TSchema> ? StaticRecord<Stack, Direction, Context, This, Key, Value> : Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? StaticCyclic<Stack, Direction, Context, This, Defs, Ref> : Type extends TRef<infer Ref extends string> ? StaticRef<Stack, Direction, Context, This, Ref> : Type extends TString ? StaticString : Type extends TSymbol ? StaticSymbol : Type extends TTemplateLiteral<infer Pattern extends string> ? StaticTemplateLiteral<Pattern> : Type extends TThis ? StaticThis<Stack, Direction, Context, This> : Type extends TTuple<infer Items extends TSchema[]> ? StaticTuple<Stack, Direction, Context, This, Type, Items> : Type extends TUndefined ? StaticUndefined : Type extends TUnion<infer Types extends TSchema[]> ? StaticUnion<Stack, Direction, Context, This, Types> : Type extends TUnknown ? StaticUnknown : Type extends TUnsafe<infer Type extends unknown> ? StaticUnsafe<Type> : Type extends TVoid ? StaticVoid : XStatic<Type>);
 /** Infers a static type from a TypeBox type using Parse logic. */
-export type StaticParse<Type extends TSchema, Context extends TProperties = {}> = StaticType<[], 'Decode', Context, {}, Type>;
+export type StaticParse<Type extends TSchema, Context extends TProperties = {}, Result extends unknown = StaticType<[], 'Decode', Context, {}, Type>> = Result;
 /** Infers a static type from a TypeBox type using Decode logic. */
-export type StaticDecode<Type extends TSchema, Context extends TProperties = {}> = StaticType<[], 'Decode', Context, {}, Type>;
+export type StaticDecode<Type extends TSchema, Context extends TProperties = {}, Result extends unknown = StaticType<[], 'Decode', Context, {}, Type>> = Result;
 /** Infers a static type from a TypeBox type using Encode logic. */
-export type StaticEncode<Type extends TSchema, Context extends TProperties = {}> = StaticType<[], 'Encode', Context, {}, Type>;
+export type StaticEncode<Type extends TSchema, Context extends TProperties = {}, Result extends unknown = StaticType<[], 'Encode', Context, {}, Type>> = Result;
 /** Infers a static type from a TypeBox type. */
-export type Static<Type extends TSchema, Context extends TProperties = {}> = StaticType<[], 'Encode', Context, {}, Type>;
+export type Static<Type extends TSchema, Context extends TProperties = {}, Result extends unknown = StaticType<[], 'Encode', Context, {}, Type>> = Result;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.0.42",
+  "version": "1.0.44",
   "keywords": [
     "typescript",
     "jsonschema"

package/build/schema/resolver/index.d.mts

@@ -1 +0,0 @@
-export * as Resolver from './resolver.mjs';

package/build/schema/resolver/index.mjs

@@ -1 +0,0 @@
-export * as Resolver from './resolver.mjs';

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

@@ -1,2 +0,0 @@
-import * as S from '../types/index.mjs';
-export declare function RecursiveRef(schema: unknown, ref: S.XRecursiveRef): unknown;

package/build/schema/resolver/recursiveRef.mjs

@@ -1,47 +0,0 @@
-import { Guard } from '../../guard/index.mjs';
-import * as S from '../types/index.mjs';
-import { Ref } from './ref.mjs';
-// ------------------------------------------------------------------
-// FromArray
-// ------------------------------------------------------------------
-function FromArray(value, anchor, ref) {
-    for (const item of value) {
-        const resolved = FromValue(item, anchor, ref);
-        if (!Guard.IsUndefined(resolved))
-            return resolved;
-    }
-    return undefined;
-}
-// ------------------------------------------------------------------
-// FromObject
-// ------------------------------------------------------------------
-function FromObject(value, anchor, ref) {
-    for (const key of Guard.Keys(value)) {
-        const resolved = FromValue(value[key], anchor, ref);
-        if (!Guard.IsUndefined(resolved))
-            return resolved;
-    }
-    return undefined;
-}
-// ------------------------------------------------------------------
-// FromValue
-// ------------------------------------------------------------------
-function FromValue(value, anchor, ref) {
-    if (Guard.IsObjectNotArray(value) && S.IsRecursiveAnchor(value)) {
-        anchor = value;
-    }
-    if (value === ref)
-        return Ref(anchor, ref.$recursiveRef);
-    if (Guard.IsArray(value))
-        return FromArray(value, anchor, ref);
-    if (Guard.IsObject(value))
-        return FromObject(value, anchor, ref);
-    return undefined;
-}
-// ------------------------------------------------------------------
-// RecursiveRef
-// ------------------------------------------------------------------
-export function RecursiveRef(schema, ref) {
-    const anchor = schema;
-    return FromValue(schema, anchor, ref);
-}

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

@@ -1 +0,0 @@
-export declare function Ref(schema: unknown, ref: string): unknown;

package/build/schema/resolver/resolver.d.mts

@@ -1,2 +0,0 @@
-export * from './recursiveRef.mjs';
-export * from './ref.mjs';

package/build/schema/resolver/resolver.mjs

@@ -1,2 +0,0 @@
-export * from './recursiveRef.mjs';
-export * from './ref.mjs';