typebox 1.1.7 → 1.1.9

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

@@ -0,0 +1,15 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TDeferred } from '../../types/deferred.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+type TCollectDistributionNames<Expression extends TSchema, Result extends string[] = []> = (Expression extends TDeferred<'Conditional', [infer Left extends TSchema, infer _Right extends TSchema, infer True extends TSchema, infer False extends TSchema]> ? Left extends TRef<infer Name extends string> ? TCollectDistributionNames<True, TCollectDistributionNames<False, [...Result, Name]>> : TCollectDistributionNames<True, TCollectDistributionNames<False, Result>> : Result);
+type TBuildDistributionArray<Parameters extends TParameter[], Names extends string[], Result extends boolean[] = []> = (Parameters extends [infer Left extends TParameter, ...infer Right extends TParameter[]] ? Left['name'] extends Names[number] ? TBuildDistributionArray<Right, Names, [...Result, true]> : TBuildDistributionArray<Right, Names, [...Result, false]> : Result);
+type TZipDistributionArray<Arguments extends TSchema[], DistributionArray extends boolean[], Result extends [boolean, TSchema][] = []> = (Arguments extends [infer ArgumentLeft extends TSchema, ...infer ArgumentRight extends TSchema[]] ? DistributionArray extends [infer BooleanLeft extends boolean, ...infer BooleanRight extends boolean[]] ? TZipDistributionArray<ArgumentRight, BooleanRight, [...Result, [BooleanLeft, ArgumentLeft]]> : Result : Result);
+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<ZippedArguments extends [boolean, TSchema][], Result extends TSchema[][] = [[]]> = (ZippedArguments extends [infer Left extends [boolean, TSchema], ...infer Right extends [boolean, TSchema][]] ? Left[0] extends true ? TDistribute<Right, TCross<Result, TExpand<Left[1]>>> : TDistribute<Right, TCross<Result, [Left[1]]>> : Result);
+export type TDistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema, DistributionNames extends string[] = TCollectDistributionNames<Expression>, DistributionArray extends boolean[] = TBuildDistributionArray<Parameters, DistributionNames>, ZippedArguments extends [boolean, TSchema][] = TZipDistributionArray<Arguments, DistributionArray>, Result extends TSchema[][] = Expression extends TDeferred<'Conditional', TSchema[]> ? TDistribute<ZippedArguments> : [Arguments]> = Result;
+export declare function DistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema>(parameters: [...Parameters], arguments_: [...Arguments], expression: Expression): TDistributeArguments<Parameters, Arguments, Expression>;
+export {};

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

@@ -0,0 +1,52 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { IsDeferred } from '../../types/deferred.mjs';
+import { IsRef } from '../../types/ref.mjs';
+function CollectDistributionNames(expression, result = []) {
+    return (IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
+        ? IsRef(expression.parameters[0])
+            ? CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], [...result, expression.parameters[0].$ref]))
+            : CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], result))
+        : result);
+}
+function BuildDistributionArray(parameters, names) {
+    return parameters.reduce((result, left) => [...result, names.includes(left.name)], []);
+}
+function ZipDistributionArray(arguments_, distributionArray, result = []) {
+    const [argumentLeft, ...argumentRight] = arguments_;
+    const [booleanLeft, ...booleanRight] = distributionArray;
+    return (Guard.IsGreaterThan(arguments_.length, 0)
+        ? Guard.IsGreaterThan(distributionArray.length, 0)
+            ? ZipDistributionArray(argumentRight, booleanRight, [...result, [booleanLeft, argumentLeft]])
+            : result
+        : result);
+}
+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(zipped) {
+    return zipped.reduce((result, left) => {
+        return Guard.IsEqual(left[0], true)
+            ? Cross(result, Expand(left[1]))
+            : Cross(result, [left[1]]); // - no-expansion
+    }, [[]]);
+}
+export function DistributeArguments(parameters, arguments_, expression) {
+    const distributionNames = CollectDistributionNames(expression);
+    const distributionArray = BuildDistributionArray(parameters, distributionNames);
+    const zippedArguments = ZipDistributionArray(arguments_, distributionArray);
+    return (IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
+        ? Distribute(zippedArguments)
+        : [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 TState } from '../instantiate.mjs';
+import { type TEvaluateUnion } from '../evaluate/index.mjs';
 import { type TInstantiateType } from '../instantiate.mjs';
 import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TState } 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<Parameters, 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 { DistributeArguments } 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 = DistributeArguments(parameters, 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/call/resolve-arguments.mjs

@@ -11,9 +11,9 @@ import { IsCall } from '../../types/call.mjs';
 function AssertArgumentExtends(name, type, extends_) {
     if (IsInfer(type) || IsCall(type) || ExtendsResult.IsExtendsTrueLike(Extends({}, type, extends_)))
         return;
-    const cause = { parameter: name, extends: extends_, received: type };
+    const cause = { parameter: name, expect: extends_, actual: type };
     // @ts-ignore - no definition for { cause } options 
-    throw new Error('Generic argument does not satify constraint', { cause });
+    throw new Error(`Argument for parameter ${name} does not satisfy constraint`, { cause });
 }
 function BindArgument(context, state, name, extends_, type) {
     const instantiatedArgument = InstantiateType(context, state, type);

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.9",
   "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