typebox 1.0.31 → 1.0.33

package/build/cjs/type/engine/cyclic/dependencies.js

@@ -0,0 +1,56 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclicDependencies = CyclicDependencies;
+const index_1 = require("../../../system/unreachable/index");
+const array_1 = require("../../types/array");
+const async_iterator_1 = require("../../types/async-iterator");
+const constructor_1 = require("../../types/constructor");
+const function_1 = require("../../types/function");
+const intersect_1 = require("../../types/intersect");
+const iterator_1 = require("../../types/iterator");
+const object_1 = require("../../types/object");
+const promise_1 = require("../../types/promise");
+const properties_1 = require("../../types/properties");
+const record_1 = require("../../types/record");
+const tuple_1 = require("../../types/tuple");
+const union_1 = require("../../types/union");
+const ref_1 = require("../../types/ref");
+const interface_1 = require("../../action/interface");
+function FromRef(context, ref, result) {
+    return (result.includes(ref)
+        ? result
+        : ref in context
+            ? FromType(context, context[ref], [...result, ref])
+            : (0, index_1.Unreachable)());
+}
+function FromProperties(context, properties, result) {
+    const types = (0, properties_1.PropertyValues)(properties);
+    return FromTypes(context, types, result);
+}
+function FromTypes(context, types, result) {
+    return types.reduce((result, left) => {
+        return FromType(context, left, result);
+    }, result);
+}
+function FromType(context, type, result) {
+    return ((0, ref_1.IsRef)(type) ? FromRef(context, type.$ref, result) :
+        (0, array_1.IsArray)(type) ? FromType(context, type.items, result) :
+            (0, async_iterator_1.IsAsyncIterator)(type) ? FromType(context, type.iteratorItems, result) :
+                (0, constructor_1.IsConstructor)(type) ? FromTypes(context, [...type.parameters, type.instanceType], result) :
+                    (0, function_1.IsFunction)(type) ? FromTypes(context, [...type.parameters, type.returnType], result) :
+                        (0, interface_1.IsInterfaceDeferred)(type) ? FromProperties(context, type.parameters[1], result) :
+                            (0, intersect_1.IsIntersect)(type) ? FromTypes(context, type.allOf, result) :
+                                (0, iterator_1.IsIterator)(type) ? FromType(context, type.iteratorItems, result) :
+                                    (0, object_1.IsObject)(type) ? FromProperties(context, type.properties, result) :
+                                        (0, promise_1.IsPromise)(type) ? FromType(context, type.item, result) :
+                                            (0, union_1.IsUnion)(type) ? FromTypes(context, type.anyOf, result) :
+                                                (0, tuple_1.IsTuple)(type) ? FromTypes(context, type.items, result) :
+                                                    (0, record_1.IsRecord)(type) ? FromType(context, (0, record_1.RecordValue)(type), result) :
+                                                        result);
+}
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+function CyclicDependencies(context, key, type) {
+    const result = FromType(context, type, [key]);
+    return result;
+}

package/build/cjs/type/engine/cyclic/extends.d.ts

@@ -0,0 +1,31 @@
+import { type TSchema } from '../../types/schema';
+import { type TAny } from '../../types/any';
+import { type TArray } from '../../types/array';
+import { type TAsyncIterator } from '../../types/async-iterator';
+import { type TConstructor } from '../../types/constructor';
+import { type TCyclic } from '../../types/cyclic';
+import { type TFunction } from '../../types/function';
+import { type TIntersect } from '../../types/intersect';
+import { type TIterator } from '../../types/iterator';
+import { type TObject } from '../../types/object';
+import { type TPromise } from '../../types/promise';
+import { type TProperties } from '../../types/properties';
+import { type TRecord } from '../../types/record';
+import { type TRef } from '../../types/ref';
+import { type TTuple } from '../../types/tuple';
+import { type TUnion } from '../../types/union';
+import { type TUnknown } from '../../types/unknown';
+type TFromRef<_Ref extends string> = (TAny);
+type TFromProperties<Properties extends TProperties, Result extends TProperties = {
+    [Key in keyof Properties]: TFromType<Properties[Key]>;
+}> = {
+    [Key in keyof Result]: Result[Key];
+};
+type TFromTypes<Types extends TSchema[], Result extends TSchema[] = []> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Right, [...Result, TFromType<Left>]> : Result;
+type TFromType<Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TFromType<Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TFromType<Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<InstanceType>> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TFromTypes<Parameters>, TFromType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromTypes<Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TFromType<Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TFromProperties<Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TFromType<Type>> : Type extends TRecord<infer Pattern extends string, infer Value extends TSchema> ? TRecord<Pattern, TFromType<Value>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromTypes<Types>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TFromTypes<Types>> : Type);
+type TCyclicAnyFromParameters<Defs extends TProperties, Ref extends string> = (Ref extends keyof Defs ? TFromType<Defs[Ref]> : TUnknown);
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+export type TCyclicExtends<Type extends TCyclic, Result extends TSchema = TCyclicAnyFromParameters<Type['$defs'], Type['$ref']>> = Result;
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+export declare function CyclicExtends<Type extends TCyclic>(type: Type): TCyclicExtends<Type>;
+export {};

package/build/cjs/type/engine/cyclic/extends.js

@@ -0,0 +1,56 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclicExtends = CyclicExtends;
+const index_1 = require("../../../guard/index");
+const any_1 = require("../../types/any");
+const array_1 = require("../../types/array");
+const async_iterator_1 = require("../../types/async-iterator");
+const constructor_1 = require("../../types/constructor");
+const function_1 = require("../../types/function");
+const intersect_1 = require("../../types/intersect");
+const iterator_1 = require("../../types/iterator");
+const object_1 = require("../../types/object");
+const promise_1 = require("../../types/promise");
+const record_1 = require("../../types/record");
+const ref_1 = require("../../types/ref");
+const tuple_1 = require("../../types/tuple");
+const union_1 = require("../../types/union");
+const unknown_1 = require("../../types/unknown");
+function FromRef(_ref) {
+    return (0, any_1.Any)();
+}
+function FromProperties(properties) {
+    return index_1.Guard.Keys(properties).reduce((result, key) => {
+        return { ...result, [key]: FromType(properties[key]) };
+    }, {});
+}
+function FromTypes(types) {
+    return types.reduce((result, left) => {
+        return [...result, FromType(left)];
+    }, []);
+}
+function FromType(type) {
+    return ((0, ref_1.IsRef)(type) ? FromRef(type.$ref) :
+        (0, array_1.IsArray)(type) ? (0, array_1.Array)(FromType(type.items), (0, array_1.ArrayOptions)(type)) :
+            (0, async_iterator_1.IsAsyncIterator)(type) ? (0, async_iterator_1.AsyncIterator)(FromType(type.iteratorItems)) :
+                (0, constructor_1.IsConstructor)(type) ? (0, constructor_1.Constructor)(FromTypes(type.parameters), FromType(type.instanceType)) :
+                    (0, function_1.IsFunction)(type) ? (0, function_1.Function)(FromTypes(type.parameters), FromType(type.returnType)) :
+                        (0, intersect_1.IsIntersect)(type) ? (0, intersect_1.Intersect)(FromTypes(type.allOf)) :
+                            (0, iterator_1.IsIterator)(type) ? (0, iterator_1.Iterator)(FromType(type.iteratorItems)) :
+                                (0, object_1.IsObject)(type) ? (0, object_1.Object)(FromProperties(type.properties)) :
+                                    (0, promise_1.IsPromise)(type) ? (0, promise_1.Promise)(FromType(type.item)) :
+                                        (0, record_1.IsRecord)(type) ? (0, record_1.Record)((0, record_1.RecordKey)(type), FromType((0, record_1.RecordValue)(type))) :
+                                            (0, union_1.IsUnion)(type) ? (0, union_1.Union)(FromTypes(type.anyOf)) :
+                                                (0, tuple_1.IsTuple)(type) ? (0, tuple_1.Tuple)(FromTypes(type.items)) :
+                                                    type);
+}
+function CyclicAnyFromParameters(defs, ref) {
+    return (ref in defs
+        ? FromType(defs[ref])
+        : (0, unknown_1.Unknown)());
+}
+/** Transforms TCyclic TRef's into TAny's. This function is used prior to TExtends checks to enable cyclics to be structurally checked and terminated (with TAny) at first point of recursion, what would otherwise be a recursive TRef.*/
+function CyclicExtends(type) {
+    return CyclicAnyFromParameters(type.$defs, type.$ref);
+}

package/build/cjs/type/engine/cyclic/index.d.ts

@@ -0,0 +1,6 @@
+export * from './candidates';
+export * from './check';
+export * from './dependencies';
+export * from './extends';
+export * from './instantiate';
+export * from './target';

package/build/cjs/type/engine/cyclic/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./candidates"), exports);
+__exportStar(require("./check"), exports);
+__exportStar(require("./dependencies"), exports);
+__exportStar(require("./extends"), exports);
+__exportStar(require("./instantiate"), exports);
+__exportStar(require("./target"), exports);

package/build/cjs/type/engine/cyclic/instantiate.d.ts

@@ -0,0 +1,20 @@
+import { type TSchema } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TCyclic } from '../../types/cyclic';
+import { type TObject } from '../../types/object';
+import { type TCyclicDependencies } from '../cyclic/dependencies';
+import { type TInterfaceDeferred } from '../../action/index';
+import { type TInstantiateProperties } from '../instantiate';
+import { type TInstantiateTypes } from '../instantiate';
+import { type TEvaluateIntersect } from '../evaluate/evaluate';
+type TCyclicInterface<Context extends TProperties, Heritage extends TSchema[], Properties extends TProperties, InstantiatedHeritage extends TSchema[] = TInstantiateTypes<Context, {
+    callstack: [];
+}, Heritage>, instantiatedProperties extends TProperties = TInstantiateProperties<{}, {
+    callstack: [];
+}, Properties>, EvaluatedInterface extends TSchema = TEvaluateIntersect<[...InstantiatedHeritage, TObject<instantiatedProperties>]>> = EvaluatedInterface;
+type TCyclicDefinitions<Context extends TProperties, Dependencies extends string[], Result extends TProperties = {
+    [Key in Extract<keyof Context, Dependencies[number]>]: Context[Key] extends TInterfaceDeferred<infer Heritage extends TSchema[], infer Properties extends TProperties> ? TCyclicInterface<Context, Heritage, Properties> : Context[Key];
+}> = Result;
+export type TInstantiateCyclic<Context extends TProperties, Ref extends string, Type extends TSchema, Dependencies extends string[] = TCyclicDependencies<Context, Ref, Type>, Definitions extends TProperties = TCyclicDefinitions<Context, Dependencies>, Result extends TSchema = TCyclic<Definitions, Ref>> = Result;
+export declare function InstantiateCyclic<Context extends TProperties, Ref extends string, Type extends TSchema>(context: Context, ref: Ref, type: Type): TInstantiateCyclic<Context, Ref, Type>;
+export {};

package/build/cjs/type/engine/cyclic/instantiate.js

@@ -0,0 +1,32 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstantiateCyclic = InstantiateCyclic;
+const index_1 = require("../../../guard/index");
+const cyclic_1 = require("../../types/cyclic");
+const object_1 = require("../../types/object");
+const dependencies_1 = require("../cyclic/dependencies");
+const index_2 = require("../../action/index");
+const instantiate_1 = require("../instantiate");
+const instantiate_2 = require("../instantiate");
+const evaluate_1 = require("../evaluate/evaluate");
+function CyclicInterface(context, heritage, properties) {
+    const instantiatedHeritage = (0, instantiate_2.InstantiateTypes)(context, { callstack: [] }, heritage);
+    const instantiatedProperties = (0, instantiate_1.InstantiateProperties)({}, { callstack: [] }, properties);
+    const evaluatedInterface = (0, evaluate_1.EvaluateIntersect)([...instantiatedHeritage, (0, object_1.Object)(instantiatedProperties)]);
+    return evaluatedInterface;
+}
+function CyclicDefinitions(context, dependencies) {
+    const keys = index_1.Guard.Keys(context).filter(key => dependencies.includes(key));
+    return keys.reduce((result, key) => {
+        const type = context[key];
+        const instantiatedType = (0, index_2.IsInterfaceDeferred)(type) ? CyclicInterface(context, type.parameters[0], type.parameters[1]) : type;
+        return { ...result, [key]: instantiatedType };
+    }, {});
+}
+function InstantiateCyclic(context, ref, type) {
+    const dependencies = (0, dependencies_1.CyclicDependencies)(context, ref, type);
+    const definitions = CyclicDefinitions(context, dependencies);
+    const result = (0, cyclic_1.Cyclic)(definitions, ref);
+    return result;
+}

package/build/cjs/type/engine/cyclic/target.d.ts

@@ -0,0 +1,10 @@
+import { type TSchema } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TNever } from '../../types/never';
+import { type TRef } from '../../types/ref';
+type TResolve<Defs extends TProperties, Ref extends string> = (Ref extends keyof Defs ? Defs[Ref] extends TRef<infer Ref extends string> ? TResolve<Defs, Ref> : Defs[Ref] : TNever);
+/** Returns the target Type from the Defs or Never if target is non-resolvable */
+export type TCyclicTarget<Defs extends TProperties, Ref extends string, Result extends TSchema = TResolve<Defs, Ref>> = Result;
+/** Returns the target Type from the Defs or Never if target is non-resolvable */
+export declare function CyclicTarget<Defs extends TProperties, Ref extends string>(defs: Defs, ref: Ref): TCyclicTarget<Defs, Ref>;
+export {};

package/build/cjs/type/engine/cyclic/target.js

@@ -0,0 +1,19 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclicTarget = CyclicTarget;
+const never_1 = require("../../types/never");
+const ref_1 = require("../../types/ref");
+function Resolve(defs, ref) {
+    return (ref in defs
+        ? (0, ref_1.IsRef)(defs[ref])
+            // @ts-ignore 5.0.4 - does not see $ref
+            ? Resolve(defs, defs[ref].$ref)
+            : defs[ref]
+        : (0, never_1.Never)());
+}
+/** Returns the target Type from the Defs or Never if target is non-resolvable */
+function CyclicTarget(defs, ref) {
+    const result = Resolve(defs, ref);
+    return result;
+}

package/build/cjs/type/engine/enum/enum-to-union.d.ts

@@ -0,0 +1,14 @@
+import { type TSchema } from '../../types/schema';
+import { type TEnum, type TEnumValue } from '../../types/enum';
+import { type TUnion } from '../../types/union';
+import { type TLiteral } from '../../types/literal';
+import { type TNull } from '../../types/null';
+import { type TNever } from '../../types/never';
+type TFromEnumValue<Value extends TEnumValue, Result extends TSchema = Value extends string | number ? TLiteral<Value> : Value extends null ? TNull : TNever> = Result;
+export type TEnumValuesToVariants<Values extends TEnumValue[], Result extends TSchema[] = []> = (Values extends [infer Left extends TEnumValue, ...infer Right extends TEnumValue[]] ? TEnumValuesToVariants<Right, [...Result, TFromEnumValue<Left>]> : Result);
+export declare function EnumValuesToVariants<Values extends TEnumValue[]>(values: [...Values]): TEnumValuesToVariants<Values>;
+export type TEnumValuesToUnion<Values extends TEnumValue[], Variants extends TSchema[] = TEnumValuesToVariants<Values>, Results extends TSchema = TUnion<Variants>> = Results;
+export declare function EnumValuesToUnion<Values extends TEnumValue[]>(values: [...Values]): TEnumValuesToUnion<Values>;
+export type TEnumToUnion<Type extends TEnum, Result extends TSchema = TEnumValuesToUnion<Type['enum']>> = Result;
+export declare function EnumToUnion<Type extends TEnum>(type: Type): TEnumToUnion<Type>;
+export {};

package/build/cjs/type/engine/enum/enum-to-union.js

@@ -0,0 +1,29 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumValuesToVariants = EnumValuesToVariants;
+exports.EnumValuesToUnion = EnumValuesToUnion;
+exports.EnumToUnion = EnumToUnion;
+const index_1 = require("../../../guard/index");
+const union_1 = require("../../types/union");
+const literal_1 = require("../../types/literal");
+const null_1 = require("../../types/null");
+const never_1 = require("../../types/never");
+function FromEnumValue(value) {
+    return (index_1.Guard.IsString(value) || index_1.Guard.IsNumber(value) ? (0, literal_1.Literal)(value) :
+        index_1.Guard.IsNull(value) ? (0, null_1.Null)() :
+            (0, never_1.Never)());
+}
+function EnumValuesToVariants(values) {
+    const result = values.map(value => FromEnumValue(value));
+    return result;
+}
+function EnumValuesToUnion(values) {
+    const variants = EnumValuesToVariants(values);
+    const result = (0, union_1.Union)(variants);
+    return result;
+}
+function EnumToUnion(type) {
+    const result = EnumValuesToUnion(type.enum);
+    return result;
+}

package/build/cjs/type/engine/enum/index.d.ts

@@ -0,0 +1,2 @@
+export * from './enum-to-union';
+export * from './typescript-enum-to-enum-values';

package/build/cjs/type/engine/enum/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./enum-to-union"), exports);
+__exportStar(require("./typescript-enum-to-enum-values"), exports);

package/build/cjs/type/engine/enum/typescript-enum-to-enum-values.d.ts

@@ -0,0 +1,8 @@
+import { type TEnumValue } from '../../types/enum';
+import { type TUnionToTuple } from '../helpers/union';
+export type TTypeScriptEnumLike = Record<PropertyKey, TEnumValue>;
+export declare function IsTypeScriptEnumLike(value: unknown): value is TTypeScriptEnumLike;
+type TReduceEnumValues<Keys extends string[], Type extends TTypeScriptEnumLike, Result extends TEnumValue[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TReduceEnumValues<Right, Type, [...Result, Type[Left]]> : Result);
+export type TTypeScriptEnumToEnumValues<Type extends TTypeScriptEnumLike, EnumKeys extends string[] = TUnionToTuple<Extract<keyof Type, string>>, Elements extends TEnumValue[] = TReduceEnumValues<EnumKeys, Type>> = Elements;
+export declare function TypeScriptEnumToEnumValues<Type extends TTypeScriptEnumLike>(type: Type): TTypeScriptEnumToEnumValues<Type>;
+export {};

package/build/cjs/type/engine/enum/typescript-enum-to-enum-values.js

@@ -0,0 +1,13 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsTypeScriptEnumLike = IsTypeScriptEnumLike;
+exports.TypeScriptEnumToEnumValues = TypeScriptEnumToEnumValues;
+const index_1 = require("../../../guard/index");
+function IsTypeScriptEnumLike(value) {
+    return index_1.Guard.IsObjectNotArray(value);
+}
+function TypeScriptEnumToEnumValues(type) {
+    const keys = index_1.Guard.Keys(type).filter((key) => isNaN(key));
+    return keys.reduce((result, key) => [...result, type[key]], []);
+}

package/build/cjs/type/engine/evaluate/broaden.d.ts

@@ -0,0 +1,16 @@
+import { type TSchema } from '../../types/schema';
+import { type TAny } from '../../types/any';
+import { type TNever } from '../../types/never';
+import { type TObject } from '../../types/object';
+import { type TUnion } from '../../types/union';
+import { type TCompare, ResultRightInside, ResultLeftInside, ResultEqual } from './compare';
+import { type TFlatten } from './flatten';
+import { type TEvaluateType } from './evaluate';
+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);
+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>;
+export {};

package/build/cjs/type/engine/evaluate/broaden.js

@@ -0,0 +1,51 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Broaden = Broaden;
+const index_1 = require("../../../guard/index");
+const schema_1 = require("../../types/schema");
+const any_1 = require("../../types/any");
+const never_1 = require("../../types/never");
+const object_1 = require("../../types/object");
+const union_1 = require("../../types/union");
+const compare_1 = require("./compare");
+const flatten_1 = require("./flatten");
+const evaluate_1 = require("./evaluate");
+function BroadFilter(type, types) {
+    return types.filter(left => {
+        return (0, compare_1.Compare)(type, left) === compare_1.ResultRightInside
+            ? false
+            : true;
+    });
+}
+function IsBroadestType(type, types) {
+    const result = types.some(left => {
+        const result = (0, compare_1.Compare)(type, left);
+        return index_1.Guard.IsEqual(result, compare_1.ResultLeftInside) || index_1.Guard.IsEqual(result, compare_1.ResultEqual);
+    });
+    return index_1.Guard.IsEqual(result, false);
+}
+function BroadenType(type, types) {
+    const evaluated = (0, evaluate_1.EvaluateType)(type);
+    return ((0, any_1.IsAny)(evaluated) ? [evaluated] :
+        IsBroadestType(evaluated, types)
+            ? [...BroadFilter(evaluated, types), evaluated]
+            : types);
+}
+function BroadenTypes(types, result = []) {
+    const [left, ...right] = types;
+    return ((0, schema_1.IsSchema)(left)
+        ? (0, object_1.IsObject)(left)
+            ? BroadenTypes(right, [...result, left]) // special: push object type
+            : BroadenTypes(right, BroadenType(left, result))
+        : result);
+}
+/** Broadens a set of types and returns either the most broad type, or union or disjoint types. */
+function Broaden(types) {
+    const broadened = BroadenTypes(types);
+    const flattened = (0, flatten_1.Flatten)(broadened);
+    const result = (flattened.length === 0 ? (0, never_1.Never)() :
+        flattened.length === 1 ? flattened[0] :
+            (0, union_1.Union)(flattened));
+    return result;
+}

package/build/cjs/type/engine/evaluate/compare.d.ts

@@ -0,0 +1,15 @@
+import { type TSchema } from '../../types/index';
+import { type TUnknown } from '../../types/unknown';
+import { type TExtends, ExtendsResult } from "../../extends/index";
+export declare const ResultEqual = "equal";
+export declare const ResultDisjoint = "disjoint";
+export declare const ResultLeftInside = "left-inside";
+export declare const ResultRightInside = "right-inside";
+export type TCompareResult = typeof ResultEqual | typeof ResultDisjoint | typeof ResultLeftInside | typeof ResultRightInside;
+/** Compares left and right types and determines their set relationship */
+export type TCompare<Left extends TSchema, Right extends TSchema, Extends extends [ExtendsResult.TResult, ExtendsResult.TResult] = [
+    Left extends TUnknown ? ExtendsResult.TExtendsFalse : TExtends<{}, Left, Right>,
+    Left extends TUnknown ? ExtendsResult.TExtendsTrue : TExtends<{}, Right, Left>
+]> = (Extends extends [ExtendsResult.TExtendsTrueLike, ExtendsResult.TExtendsTrueLike] ? typeof ResultEqual : Extends extends [ExtendsResult.TExtendsTrueLike, ExtendsResult.TExtendsFalse] ? typeof ResultLeftInside : Extends extends [ExtendsResult.TExtendsFalse, ExtendsResult.TExtendsTrueLike] ? typeof ResultRightInside : typeof ResultDisjoint);
+/** Compares left and right types and determines their set relationship. */
+export declare function Compare<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TCompare<Left, Right>;

package/build/cjs/type/engine/evaluate/compare.js

@@ -0,0 +1,25 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultRightInside = exports.ResultLeftInside = exports.ResultDisjoint = exports.ResultEqual = void 0;
+exports.Compare = Compare;
+const unknown_1 = require("../../types/unknown");
+const index_1 = require("../../extends/index");
+// ------------------------------------------------------------------
+// TCompare
+// ------------------------------------------------------------------
+exports.ResultEqual = 'equal';
+exports.ResultDisjoint = 'disjoint';
+exports.ResultLeftInside = 'left-inside';
+exports.ResultRightInside = 'right-inside';
+/** Compares left and right types and determines their set relationship. */
+function Compare(left, right) {
+    const extendsCheck = [
+        (0, unknown_1.IsUnknown)(left) ? index_1.ExtendsResult.ExtendsFalse() : (0, index_1.Extends)({}, left, right),
+        (0, unknown_1.IsUnknown)(left) ? index_1.ExtendsResult.ExtendsTrue({}) : (0, index_1.Extends)({}, right, left),
+    ];
+    return (index_1.ExtendsResult.IsExtendsTrueLike(extendsCheck[0]) && index_1.ExtendsResult.IsExtendsTrueLike(extendsCheck[1]) ? exports.ResultEqual :
+        index_1.ExtendsResult.IsExtendsTrueLike(extendsCheck[0]) && index_1.ExtendsResult.IsExtendsFalse(extendsCheck[1]) ? exports.ResultLeftInside :
+            index_1.ExtendsResult.IsExtendsFalse(extendsCheck[0]) && index_1.ExtendsResult.IsExtendsTrueLike(extendsCheck[1]) ? exports.ResultRightInside :
+                exports.ResultDisjoint);
+}

package/build/cjs/type/engine/evaluate/composite.d.ts

@@ -0,0 +1,30 @@
+import { type TUnreachable } from '../../../system/unreachable/index';
+import { type TReadonly, type TReadonlyAdd, type TReadonlyRemove } from '../../types/_readonly';
+import { type TOptional, type TOptionalAdd, type TOptionalRemove } from '../../types/_optional';
+import { type TSchema } from '../../types/schema';
+import { type TProperties } from '../../types/properties';
+import { type TObject } from '../../types/object';
+import { type TNever } from '../../types/never';
+import { type TTuple } from '../../types/tuple';
+import { type TTupleElementsToProperties } from '../tuple/to-object';
+import { type TEvaluateIntersect } from './evaluate';
+type TIsReadonlyProperty<Left extends TSchema, Right extends TSchema> = (Left extends TReadonly<Left> ? Right extends TReadonly<Right> ? true : false : false);
+type TIsOptionalProperty<Left extends TSchema, Right extends TSchema> = (Left extends TOptional<Left> ? Right extends TOptional<Right> ? true : false : false);
+type TCompositeProperty<Left extends TSchema, Right extends TSchema, IsReadonly extends boolean = TIsReadonlyProperty<Left, Right>, IsOptional extends boolean = TIsOptionalProperty<Left, Right>, Evaluated extends TSchema = TEvaluateIntersect<[Left, Right]>, Property extends TSchema = TReadonlyRemove<TOptionalRemove<Evaluated>>> = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? TReadonlyAdd<TOptionalAdd<Property>> : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? TReadonlyAdd<Property> : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? TOptionalAdd<Property> : Property);
+type TCompositePropertyKey<Left extends TProperties, Right extends TProperties, Key extends PropertyKey, Result extends TSchema = (Key extends keyof Left ? Key extends keyof Right ? TCompositeProperty<Left[Key], Right[Key]> : Left[Key] : Key extends keyof Right ? Right[Key] : TNever)> = Result;
+type TCompositeProperties<Left extends TProperties, Right extends TProperties, Result extends TProperties = {
+    [Key in keyof (Right & Left)]: TCompositePropertyKey<Left, Right, Key>;
+}> = Result;
+type TGetProperties<Type extends TSchema, Result extends TProperties = (Type extends TObject<infer Properties extends TProperties> ? Properties : Type extends TTuple<infer Types extends TSchema[]> ? TTupleElementsToProperties<Types> : TUnreachable)> = Result;
+export type TComposite<Left extends TSchema, Right extends TSchema, LeftProperties extends TProperties = TGetProperties<Left>, RightProperties extends TProperties = TGetProperties<Right>, Properties extends TProperties = TCompositeProperties<LeftProperties, RightProperties>, Result extends TSchema = TObject<Properties>> = Result;
+export declare function Composite<Left extends TSchema, Right extends TSchema>(left: Left, right: Right): TComposite<Left, Right>;
+export {};

package/build/cjs/type/engine/evaluate/composite.js

@@ -0,0 +1,66 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Composite = Composite;
+const index_1 = require("../../../system/unreachable/index");
+const index_2 = require("../../../guard/index");
+const _readonly_1 = require("../../types/_readonly");
+const _optional_1 = require("../../types/_optional");
+const object_1 = require("../../types/object");
+const never_1 = require("../../types/never");
+const tuple_1 = require("../../types/tuple");
+const to_object_1 = require("../tuple/to-object");
+const evaluate_1 = require("./evaluate");
+function IsReadonlyProperty(left, right) {
+    return ((0, _readonly_1.IsReadonly)(left) ? (0, _readonly_1.IsReadonly)(right) ? true : false : false);
+}
+function IsOptionalProperty(left, right) {
+    return ((0, _optional_1.IsOptional)(left) ? (0, _optional_1.IsOptional)(right) ? true : false : false);
+}
+function CompositeProperty(left, right) {
+    const isReadonly = IsReadonlyProperty(left, right);
+    const isOptional = IsOptionalProperty(left, right);
+    const evaluated = (0, evaluate_1.EvaluateIntersect)([left, right]);
+    // Modifiers need to be discarded and re-applied
+    const property = (0, _readonly_1.ReadonlyRemove)((0, _optional_1.OptionalRemove)(evaluated));
+    return (isReadonly && isOptional ? (0, _readonly_1.ReadonlyAdd)((0, _optional_1.OptionalAdd)(property)) :
+        isReadonly && !isOptional ? (0, _readonly_1.ReadonlyAdd)(property) :
+            !isReadonly && isOptional ? (0, _optional_1.OptionalAdd)(property) :
+                property);
+}
+function CompositePropertyKey(left, right, key) {
+    return (key in left
+        ? key in right
+            ? CompositeProperty(left[key], right[key])
+            : left[key]
+        : key in right
+            ? right[key]
+            : (0, never_1.Never)());
+}
+function CompositeProperties(left, right) {
+    const keys = new Set([...index_2.Guard.Keys(right), ...index_2.Guard.Keys(left)]);
+    return [...keys].reduce((result, key) => {
+        return { ...result, [key]: CompositePropertyKey(left, right, key) };
+    }, {});
+}
+// ------------------------------------------------------------------
+// deno-coverage-ignore-start - symmetric unreachable | internal
+//
+// Composite is called by Distribute which provisions the type as
+// either TObject ot TTuple. Fall-through unreachable.
+//
+// ------------------------------------------------------------------
+function GetProperties(type) {
+    const result = ((0, object_1.IsObject)(type) ? type.properties :
+        (0, tuple_1.IsTuple)(type) ? (0, to_object_1.TupleElementsToProperties)(type.items) :
+            (0, index_1.Unreachable)() // {}
+    );
+    return result;
+}
+function Composite(left, right) {
+    const leftProperties = GetProperties(left);
+    const rightProperties = GetProperties(right);
+    const properties = CompositeProperties(leftProperties, rightProperties);
+    return (0, object_1.Object)(properties);
+}

package/build/cjs/type/engine/evaluate/distribute.d.ts

@@ -0,0 +1,26 @@
+import { type TSchema } from '../../types/schema';
+import { type TIntersect } from '../../types/intersect';
+import { type TUnion } from '../../types/union';
+import { type TObject } from '../../types/object';
+import { type TTuple } from '../../types/tuple';
+import { type TComposite } from './composite';
+import { type TNarrow } from './narrow';
+import { type TEvaluateType } from "./evaluate";
+import { type TEvaluateIntersect } from "./evaluate";
+type TCanDistribute<Type extends TSchema> = Type extends TObject | TTuple ? true : false;
+type TDistributeNormalize<Type extends TSchema> = Type extends TIntersect<infer Types extends TSchema[]> ? TEvaluateIntersect<Types> : Type;
+type TDistributeOperation<Left extends TSchema, Right extends TSchema, NormalLeft extends TSchema = TDistributeNormalize<Left>, NormalRight extends TSchema = TDistributeNormalize<Right>, IsObjectLeft extends boolean = TCanDistribute<NormalLeft>, IsObjectRight extends boolean = TCanDistribute<NormalRight>, Result extends TSchema = ([
+    IsObjectLeft,
+    IsObjectRight
+] extends [true, true] ? TComposite<TEvaluateType<NormalLeft>, NormalRight> : [
+    IsObjectLeft,
+    IsObjectRight
+] extends [true, false] ? TEvaluateType<NormalLeft> : [
+    IsObjectLeft,
+    IsObjectRight
+] extends [false, true] ? NormalRight : TNarrow<TEvaluateType<NormalLeft>, NormalRight>)> = Result;
+type TDistributeType<Type extends TSchema, Distribution extends TSchema[], Result extends TSchema[] = []> = (Distribution extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeType<Type, Right, [...Result, TDistributeOperation<Type, Left>]> : Result extends [] ? [Type] : Result);
+type TDistributeUnion<Types extends TSchema[], Distribution extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDistributeUnion<Right, Distribution, [...Result, ...TDistribute<[Left], Distribution>]> : Result);
+export type TDistribute<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? Left extends TUnion<infer UnionTypes extends TSchema[]> ? TDistribute<Right, TDistributeUnion<UnionTypes, Result>> : TDistribute<Right, TDistributeType<Left, Result>> : Result);
+export declare function Distribute<Types extends TSchema[]>(types: [...Types], result?: TSchema[]): TDistribute<Types>;
+export {};