typebox 1.1.8 → 1.1.9

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

@@ -1,10 +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<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>;
+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

@@ -2,6 +2,26 @@
 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]
@@ -15,13 +35,18 @@ function Cross(current, variants) {
         return [...result, ...Append(current, left)];
     }, []);
 }
-function Distribute(types) {
-    return types.reduce((result, type) => {
-        return Cross(result, Expand(type));
+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 DistributedArguments(arguments_, expression) {
+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(arguments_)
+        ? Distribute(zippedArguments)
         : [arguments_]);
 }

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

@@ -5,9 +5,9 @@ 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 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';
@@ -17,7 +17,7 @@ type TCallDispatch<Context extends TProperties, State extends TState, Target ext
     callstack: [...State['callstack'], Target['$ref']];
 }, Expression>> = TInstantiateType<Context, State, ReturnType>;
 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;
+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

@@ -9,7 +9,7 @@ import { InstantiateTypes } from '../instantiate.mjs';
 // ------------------------------------------------------------------
 // Infrastructure
 // ------------------------------------------------------------------
-import { DistributedArguments } from './distribute-arguments.mjs';
+import { DistributeArguments } from './distribute-arguments.mjs';
 import { ResolveTarget } from './resolve-target.mjs';
 import { ResolveArgumentsContext } from './resolve-arguments.mjs';
 function Peek(state) {
@@ -29,7 +29,7 @@ function CallDistributed(context, state, target, parameters, expression, distrib
     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 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;

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/package.json

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