typebox 1.1.7 → 1.1.8

package/build/type/engine/call/distribute-arguments.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TDeferred } from '../../types/deferred.mjs';
+type TExpand<Type extends TSchema> = (Type extends TUnion<infer Types extends TSchema[]> ? [...Types] : [Type]);
+type TAppend<Current extends TSchema[][], Type extends TSchema, Result extends TSchema[][] = []> = (Current extends [infer Left extends TSchema[], ...infer Right extends TSchema[][]] ? TAppend<Right, Type, [...Result, [...Left, Type]]> : Result);
+type TCross<Current extends TSchema[][], Variants extends TSchema[], Result extends TSchema[][] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCross<Current, Right, [...Result, ...TAppend<Current, Left>]> : Result);
+type TDistribute<Types extends TSchema[], Result extends TSchema[][] = [[]]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistribute<Right, TCross<Result, TExpand<Left>>> : Result);
+export type TDistributeArguments<Arguments extends TSchema[], Expression extends TSchema, Result extends TSchema[][] = Expression extends TDeferred<'Conditional', TSchema[]> ? TDistribute<Arguments> : [Arguments]> = Result;
+export declare function DistributedArguments<Arguments extends TSchema[], Expression extends TSchema>(arguments_: [...Arguments], expression: Expression): TDistributeArguments<Arguments, Expression>;
+export {};

package/build/type/engine/call/distribute-arguments.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { IsDeferred } from '../../types/deferred.mjs';
+function Expand(type) {
+    return (IsUnion(type)
+        ? [...type.anyOf]
+        : [type]);
+}
+function Append(current, type) {
+    return current.reduce((result, left) => [...result, [...left, type]], []);
+}
+function Cross(current, variants) {
+    return variants.reduce((result, left) => {
+        return [...result, ...Append(current, left)];
+    }, []);
+}
+function Distribute(types) {
+    return types.reduce((result, type) => {
+        return Cross(result, Expand(type));
+    }, [[]]);
+}
+export function DistributedArguments(arguments_, expression) {
+    return (IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
+        ? Distribute(arguments_)
+        : [arguments_]);
+}

package/build/type/engine/call/instantiate.d.mts

@@ -4,17 +4,20 @@ import { type TCallConstruct } from '../../types/call.mjs';
 import { type TRef } from '../../types/ref.mjs';
 import { type TGeneric } from '../../types/generic.mjs';
 import { type TProperties } from '../../types/properties.mjs';
+import { type TEvaluateUnion } from '../evaluate/index.mjs';
 import { type TState } from '../instantiate.mjs';
 import { type TInstantiateType } from '../instantiate.mjs';
 import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TDistributeArguments } from './distribute-arguments.mjs';
 import { type TResolveTarget } from './resolve-target.mjs';
 import { type TResolveArgumentsContext } from './resolve-arguments.mjs';
-type TPeek<CallStack extends string[], Result extends string = CallStack extends [infer Left extends string, ...infer _ extends string[]] ? Left : ''> = Result;
-type TDeferredCall<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, DeferredCall extends TSchema = TCallConstruct<Target, InstantiatedArguments>> = DeferredCall;
-type TTailCall<Context extends TProperties, State extends TState, Name extends string, Arguments extends TSchema[], DeferredCall extends TSchema = TDeferredCall<Context, State, TRef<Name>, Arguments>> = DeferredCall;
-type THeadCall<Context extends TProperties, State extends TState, Name extends string, Parameters extends TParameter[], Expression extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, ArgumentsContext extends TProperties = TResolveArgumentsContext<Context, State, Parameters, InstantiatedArguments>, ReturnType extends TSchema = TInstantiateType<ArgumentsContext, {
-    callstack: [...State['callstack'], Name];
+type TPeek<State extends TState, Result extends string = State['callstack'] extends [...infer _ extends string[], infer Top extends string] ? Top : ''> = Result;
+type TIsTailCall<State extends TState, Name extends string, Result extends boolean = TPeek<State> extends Name ? true : false> = Result;
+type TCallDispatch<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, Arguments extends TSchema[], ArgumentsContext extends TProperties = TResolveArgumentsContext<Context, State, Parameters, Arguments>, ReturnType extends TSchema = TInstantiateType<ArgumentsContext, {
+    callstack: [...State['callstack'], Target['$ref']];
 }, Expression>> = TInstantiateType<Context, State, ReturnType>;
-export type TCallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], Resolved extends [string, TSchema] = TResolveTarget<Context, Target, Arguments>, Name extends string = Resolved[0], Type extends TSchema = Resolved[1], Result extends TSchema = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TPeek<State['callstack']> extends Name ? TTailCall<Context, State, Name, Arguments> : THeadCall<Context, State, Name, Parameters, Expression, Arguments> : TDeferredCall<Context, State, Target, Arguments>)> = Result;
+type TCallDistributed<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, DistributedArguments extends TSchema[][], Result extends TSchema[] = []> = (DistributedArguments extends [infer Arguments extends TSchema[], ...infer DistributedArguments extends TSchema[][]] ? TCallDispatch<Context, State, Target, Parameters, Expression, Arguments> extends infer ReturnType extends TSchema ? TCallDistributed<Context, State, Target, Parameters, Expression, DistributedArguments, [...Result, ReturnType]> : never : Result);
+type TCallImmediate<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, InstantiatedArguments extends TSchema[], DistributedArguments extends TSchema[][] = TDistributeArguments<InstantiatedArguments, Expression>, ReturnTypes extends TSchema[] = TCallDistributed<Context, State, Target, Parameters, Expression, DistributedArguments>, Result extends TSchema = ReturnTypes['length'] extends 1 ? ReturnTypes[0] : TEvaluateUnion<ReturnTypes>> = Result;
+export type TCallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, Resolved extends [string, TSchema] = TResolveTarget<Context, Target, Arguments>, Name extends string = Resolved[0], Type extends TSchema = Resolved[1], Result extends TSchema = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TIsTailCall<State, Name> extends true ? TCallConstruct<TRef<Name>, InstantiatedArguments> : TCallImmediate<Context, State, TRef<Name>, Parameters, Expression, InstantiatedArguments> : TCallConstruct<Target, InstantiatedArguments>)> = Result;
 export declare function CallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[]>(context: Context, state: State, target: Target, arguments_: [...Arguments]): TCallInstantiate<Context, State, Target, Arguments>;
 export {};

package/build/type/engine/call/instantiate.mjs

@@ -3,36 +3,46 @@ import { Guard } from '../../../guard/index.mjs';
 import { CallConstruct } from '../../types/call.mjs';
 import { Ref } from '../../types/ref.mjs';
 import { IsGeneric } from '../../types/generic.mjs';
+import { EvaluateUnion } from '../evaluate/index.mjs';
 import { InstantiateType } from '../instantiate.mjs';
 import { InstantiateTypes } from '../instantiate.mjs';
-// ----------------------------------------------------------------------------
-// Call: Infrastructure
-// ----------------------------------------------------------------------------
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+import { DistributedArguments } from './distribute-arguments.mjs';
 import { ResolveTarget } from './resolve-target.mjs';
 import { ResolveArgumentsContext } from './resolve-arguments.mjs';
-function Peek(callstack) {
-    return (Guard.IsGreaterThan(callstack.length, 0) ? callstack[0] : '');
+function Peek(state) {
+    const result = Guard.IsGreaterThan(state.callstack.length, 0) ? state.callstack[state.callstack.length - 1] : '';
+    return result;
 }
-function DeferredCall(context, state, target, arguments_) {
-    const instantiatedArguments = InstantiateTypes(context, state, arguments_);
-    const deferredCall = CallConstruct(target, instantiatedArguments);
-    return deferredCall;
-}
-function TailCall(context, state, name, arguments_) {
-    const deferredCall = DeferredCall(context, state, Ref(name), arguments_);
-    return deferredCall;
+function IsTailCall(state, name) {
+    const result = Guard.IsEqual(Peek(state), name);
+    return result;
 }
-function HeadCall(context, state, name, parameters, expression, arguments_) {
-    const instantiatedArguments = InstantiateTypes(context, state, arguments_);
-    const argumentsContext = ResolveArgumentsContext(context, state, parameters, instantiatedArguments);
-    const returnType = InstantiateType(argumentsContext, { callstack: [...state.callstack, name] }, expression);
+function CallDispatch(context, state, target, parameters, expression, arguments_) {
+    const argumentsContext = ResolveArgumentsContext(context, state, parameters, arguments_);
+    const returnType = InstantiateType(argumentsContext, { callstack: [...state.callstack, target.$ref] }, expression);
     return InstantiateType(context, state, returnType);
 }
+function CallDistributed(context, state, target, parameters, expression, distributedArguments) {
+    return distributedArguments.reduce((result, arguments_) => [...result, CallDispatch(context, state, target, parameters, expression, arguments_)], []);
+}
+function CallImmediate(context, state, target, parameters, expression, arguments_) {
+    const distributedArguments = DistributedArguments(arguments_, expression);
+    const returnTypes = CallDistributed(context, state, target, parameters, expression, distributedArguments);
+    const result = returnTypes.length === 1 ? returnTypes[0] : EvaluateUnion(returnTypes);
+    return result;
+}
 export function CallInstantiate(context, state, target, arguments_) {
-    const [name, type] = ResolveTarget(context, target, arguments_);
-    return (IsGeneric(type)
-        ? Guard.IsEqual(Peek(state.callstack), name)
-            ? TailCall(context, state, name, arguments_)
-            : HeadCall(context, state, name, type.parameters, type.expression, arguments_)
-        : DeferredCall(context, state, target, arguments_));
+    const instantiatedArguments = InstantiateTypes(context, state, arguments_);
+    const resolved = ResolveTarget(context, target, arguments_);
+    const name = resolved[0];
+    const type = resolved[1];
+    const result = (IsGeneric(type)
+        ? IsTailCall(state, name)
+            ? CallConstruct(Ref(name), instantiatedArguments)
+            : CallImmediate(context, state, Ref(name), type.parameters, type.expression, instantiatedArguments)
+        : CallConstruct(target, instantiatedArguments));
+    return result;
 }

package/build/type/engine/evaluate/broaden.d.mts

@@ -9,7 +9,7 @@ import { type TEvaluateType } from './evaluate.mjs';
 type TBroadFilter<Type extends TSchema, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultRightInside ? TBroadFilter<Type, Right, [...Result]> : TBroadFilter<Type, Right, [...Result, Left]> : Result);
 type TIsBroadestType<Type extends TSchema, Types extends TSchema[]> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCompare<Type, Left> extends typeof ResultLeftInside | typeof ResultEqual ? false : TIsBroadestType<Type, Right> : true);
 type TBroadenType<Type extends TSchema, Types extends TSchema[], Evaluated extends TSchema = TEvaluateType<Type>, Result extends TSchema[] = (Evaluated extends TAny ? [Evaluated] : TIsBroadestType<Evaluated, Types> extends true ? [...TBroadFilter<Evaluated, Types>, Evaluated] : Types)> = Result;
-type TBroadenTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TObject ? TBroadenTypes<Right, [...Result, Left]> : TBroadenTypes<Right, TBroadenType<Left, Result>> : Result);
+type TBroadenTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? (Left extends TObject ? TBroadenTypes<Right, [...Result, Left]> : Left extends TNever ? TBroadenTypes<Right, Result> : TBroadenTypes<Right, TBroadenType<Left, Result>>) : Result);
 export type TBroaden<Types extends TSchema[], Broadened extends TSchema[] = TBroadenTypes<Types>, Flattened extends TSchema[] = TFlatten<Broadened>, Result extends TSchema = (Flattened extends [] ? TNever : Flattened extends [infer Type extends TSchema] ? Type : TUnion<Flattened>)> = Result;
 /** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
 export declare function Broaden<Types extends TSchema[]>(types: [...Types]): TBroaden<Types>;

package/build/type/engine/evaluate/broaden.mjs

@@ -1,8 +1,7 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-import { IsSchema } from '../../types/schema.mjs';
 import { IsAny } from '../../types/any.mjs';
-import { Never } from '../../types/never.mjs';
+import { Never, IsNever } from '../../types/never.mjs';
 import { IsObject } from '../../types/object.mjs';
 import { Union } from '../../types/union.mjs';
 import { Compare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare.mjs';
@@ -30,12 +29,12 @@ function BroadenType(type, types) {
             : types);
 }
 function BroadenTypes(types, result = []) {
-    const [left, ...right] = types;
-    return (IsSchema(left)
-        ? IsObject(left)
-            ? BroadenTypes(right, [...result, left]) // special: push object type
-            : BroadenTypes(right, BroadenType(left, result))
-        : result);
+    return types.reduce((result, left) => {
+        return (IsObject(left) ? [...result, left] : // push
+            IsNever(left) ? result : // ignore
+                BroadenType(left, result) // broaden
+        );
+    }, []);
 }
 /** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
 export function Broaden(types) {

package/package.json

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

package/readme.md

@@ -57,12 +57,11 @@ License: MIT
 
 ## Contents
 
-
 - [Type](#Type)
 - [Value](#Value)
 - [Script](#Script)
 - [Schema](#Schema)
-- [Legacy](#Legacy)
+- [Versions](#Versions)
 - [Contribute](#Contribute)
 
 
@@ -223,60 +222,31 @@ const R = C.Parse({  x: 0, y: 0, z: 0 })            // const R: {
                                                     // } = ...
 ```
 
-## Legacy
-
-If upgrading from `@sinclair/typebox` 0.34.x refer to the 1.0 migration guide at the following URL.
+<a name="Versions"></a>
 
-[Migration Guide](https://github.com/sinclairzx81/typebox/blob/main/changelog/1.0.0-migration.md)
+## Versions
 
-Most types created with 0.34.x are compatible with V1, and it is possible to run both `typebox` and `@sinclair/typebox` packages side by side. 
+TypeBox provides two distinct versions that span two generations of the TypeScript compiler.
 
-```typescript
-import { Type } from '@sinclair/typebox'            // TB: 0.34.x
-import { Static } from 'typebox'                    // TB: 1.0.0
+### Version 0.x
 
-// ----------------------------------------------------------
-// Legacy Types
-// ----------------------------------------------------------
-const A = Type.Object({
-  x: Type.Number(),
-  y: Type.Number(),
-  z: Type.Number()
-})
-
-const B = Type.Object({
-  a: Type.Number(),
-  b: Type.Number(),
-  c: Type.Number()
-})
-
-const C = Type.Composite([A, B])
+```bash
+$ npm install @sinclair/typebox                     # 0.x - LTS    | TS 4-6
+```
 
-// ----------------------------------------------------------
-// Modern Inference
-// ----------------------------------------------------------
-type C = Static<typeof C>                           // type C = {
-                                                    //   x: number;
-                                                    //   y: number;
-                                                    //   z: number;
-                                                    //   a: number;
-                                                    //   b: number;
-                                                    //   c: number;
-                                                    // }
+Developed against TypeScript 4-6 and maintained under Long Term Support (LTS) for existing infrastructure on the 0.x revision line. ESM and CJS compatible.
 
-// ----------------------------------------------------------
-// Modern Compile
-// ----------------------------------------------------------
-import Schema from 'typebox/schema'
+### Version 1.x
 
-const R = Schema.Compile(C).Check({ ... })
+```bash
+$ npm install typebox                               # 1.x - Latest | TS 7 Native
 ```
 
-Revision 0.34.x is actively maintained at the following URL.
+Developed against the TypeScript 7 native compiler with advanced type inference and JSON Schema 2020-12 compliant validation, with backwards compatibility for `0.x` types. ESM only.
 
-[TypeBox 0.34.x](https://github.com/sinclairzx81/typebox-legacy)
+### Additional
 
-Please submit non-1.0 issues to this repository.
+The `1.x` version is recommended for most new projects and is the active development line that targets optimizations enabled by the TypeScript 7 native compiler. The `0.x` version is maintained under LTS for environments requiring CJS and ESM compatibility as well as support for older TypeScript compiler versions. For issues relating to `0.x` please submit them to the [TypeBox 0.x](https://github.com/sinclairzx81/sinclair-typebox) repository.
 
 ## Contribute