typebox 0.0.1 → 1.0.0-rc

package/build/type/action/pick.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TKeysToIndexer } from '../engine/helpers/keys-to-indexer.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Pick action. */
+export type TPickDeferred<Type extends TSchema, Indexer extends TSchema> = (TDeferred<'Pick', [Type, Indexer]>);
+/** Creates a deferred Pick action. */
+export declare function PickDeferred<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TPickDeferred<Type, Indexer>;
+/** Applies a Pick action using the given types. */
+export type TPick<Type extends TSchema, Indexer extends TSchema> = (TInstantiate<{}, TPickDeferred<Type, Indexer>>);
+/** Applies a Pick action using the given types. */
+export declare function Pick<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: [...Indexer], options?: TSchemaOptions): TPick<Type, TKeysToIndexer<Indexer>>;
+/** Applies a Pick action using the given types. */
+export declare function Pick<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TPick<Type, Indexer>;

package/build/type/action/pick.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Deferred } from '../types/deferred.mjs';
+import { KeysToIndexer } from '../engine/helpers/keys-to-indexer.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Pick action. */
+export function PickDeferred(type, indexer, options = {}) {
+    return Deferred('Pick', [type, indexer], options);
+}
+/** Applies a Pick action using the given types. */
+export function Pick(type, indexer_or_keys, options = {}) {
+    const indexer = Guard.IsArray(indexer_or_keys) ? KeysToIndexer(indexer_or_keys) : indexer_or_keys;
+    return Instantiate({}, PickDeferred(type, indexer, options));
+}

package/build/type/action/required.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Required action. */
+export type TRequiredDeferred<Type extends TSchema> = (TDeferred<'Required', [Type]>);
+/** Creates a deferred Required action. */
+export declare function RequiredDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TDeferred<"Required", [Type]>;
+/** Applies a Required action to the given type. */
+export type TRequired<Type extends TSchema> = (TInstantiate<{}, TRequiredDeferred<Type>>);
+/** Applies a Required action to the given type. */
+export declare function Required<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRequired<Type>;

package/build/type/action/required.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Required action. */
+export function RequiredDeferred(type, options = {}) {
+    return Deferred('Required', [type], options);
+}
+/** Applies a Required action to the given type. */
+export function Required(type, options = {}) {
+    return Instantiate({}, RequiredDeferred(type, options));
+}

package/build/type/action/return-type.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred ReturnType action. */
+export type TReturnTypeDeferred<Type extends TSchema> = (TDeferred<'ReturnType', [Type]>);
+/** Creates a deferred ReturnType action. */
+export declare function ReturnTypeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReturnTypeDeferred<Type>;
+/** Applies a ReturnType action to the given type. */
+export type TReturnType<Type extends TSchema> = (TInstantiate<{}, TReturnTypeDeferred<Type>>);
+/** Applies a ReturnType action to the given type. */
+export declare function ReturnType<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReturnType<Type>;

package/build/type/action/return-type.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred ReturnType action. */
+export function ReturnTypeDeferred(type, options = {}) {
+    return Deferred('ReturnType', [type], options);
+}
+/** Applies a ReturnType action to the given type. */
+export function ReturnType(type, options = {}) {
+    return Instantiate({}, ReturnTypeDeferred(type, options));
+}

package/build/type/action/uncapitalize.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Uncapitalize action. */
+export type TUncapitalizeDeferred<Type extends TSchema> = (TDeferred<'Uncapitalize', [Type]>);
+/** Creates a deferred Uncapitalize action. */
+export declare function UncapitalizeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUncapitalizeDeferred<Type>;
+/** Applies a Uncapitalize action to the given type. */
+export type TUncapitalize<Type extends TSchema> = (TInstantiate<{}, TUncapitalizeDeferred<Type>>);
+/** Applies a Uncapitalize action to the given type. */
+export declare function Uncapitalize<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUncapitalize<Type>;

package/build/type/action/uncapitalize.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Uncapitalize action. */
+export function UncapitalizeDeferred(type, options = {}) {
+    return Deferred('Uncapitalize', [type], options);
+}
+/** Applies a Uncapitalize action to the given type. */
+export function Uncapitalize(type, options = {}) {
+    return Instantiate({}, UncapitalizeDeferred(type, options));
+}

package/build/type/action/uppercase.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Uppercase action. */
+export type TUppercaseDeferred<Type extends TSchema> = (TDeferred<'Uppercase', [Type]>);
+/** Creates a deferred Uppercase action. */
+export declare function UppercaseDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUppercaseDeferred<Type>;
+/** Applies a Uppercase action to the given type. */
+export type TUppercase<Type extends TSchema> = (TInstantiate<{}, TUppercaseDeferred<Type>>);
+/** Applies a Uppercase action to the given type. */
+export declare function Uppercase<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUppercase<Type>;

package/build/type/action/uppercase.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Uppercase action. */
+export function UppercaseDeferred(type, options = {}) {
+    return Deferred('Uppercase', [type], options);
+}
+/** Applies a Uppercase action to the given type. */
+export function Uppercase(type, options = {}) {
+    return Instantiate({}, UppercaseDeferred(type, options));
+}

package/build/type/engine/awaited/index.d.mts

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

package/build/type/engine/awaited/index.mjs

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

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

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TPromise } from '../../types/promise.mjs';
+import { type TAwaitedDeferred } from '../../action/awaited.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TAwaitedAction<Type extends TSchema> = (Type extends TPromise<infer Type extends TSchema> ? TAwaitedAction<Type> : Type);
+type TAwaitedImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAwaitedAction<InstantiateType>;
+export type TAwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TAwaitedImmediate<Context, State, Type> : TAwaitedDeferred<Type>;
+export declare function AwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAwaitedInstantiate<Context, State, Type>;
+export {};

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

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsPromise } from '../../types/promise.mjs';
+import { AwaitedDeferred } from '../../action/awaited.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function AwaitedAction(type) {
+    return (IsPromise(type)
+        ? AwaitedAction(type.item)
+        : type);
+}
+function AwaitedImmediate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return Memory.Update(AwaitedAction(instantiatedType), {}, options);
+}
+export function AwaitedInstantiate(context, state, type, options) {
+    return (CanInstantiate(context, [type])
+        ? AwaitedImmediate(context, state, type, options)
+        : AwaitedDeferred(type, options));
+}

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

@@ -0,0 +1,20 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+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 TInstantiateType } from '../instantiate.mjs';
+import { type TInstantiateTypes } from '../instantiate.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];
+}, 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;
+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

@@ -0,0 +1,38 @@
+// deno-fmt-ignore-file
+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 { InstantiateType } from '../instantiate.mjs';
+import { InstantiateTypes } from '../instantiate.mjs';
+// ----------------------------------------------------------------------------
+// Call: Infrastructure
+// ----------------------------------------------------------------------------
+import { ResolveTarget } from './resolve-target.mjs';
+import { ResolveArgumentsContext } from './resolve-arguments.mjs';
+function Peek(callstack) {
+    return (Guard.IsGreaterThan(callstack.length, 0) ? callstack[0] : '');
+}
+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 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);
+    return InstantiateType(context, state, returnType);
+}
+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_));
+}

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

@@ -0,0 +1,13 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TBindArgument<Context extends TProperties, State extends TState, Name extends string, Extends extends TSchema, Type extends TSchema, InstantiatedArgument extends TSchema = TInstantiateType<Context, State, Type>> = Memory.TAssign<Context, {
+    [_ in Name]: InstantiatedArgument;
+}>;
+type TBindArguments<Context extends TProperties, State extends TState, ParameterLeft extends TParameter, ParameterRight extends TParameter[], Arguments extends TSchema[], InstantiatedExtends extends TSchema = TInstantiateType<Context, State, ParameterLeft['extends']>, InstantiatedEquals extends TSchema = TInstantiateType<Context, State, ParameterLeft['equals']>> = (Arguments extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TBindParameters<TBindArgument<Context, State, ParameterLeft['name'], InstantiatedExtends, Left>, State, ParameterRight, Right> : TBindParameters<TBindArgument<Context, State, ParameterLeft['name'], InstantiatedExtends, InstantiatedEquals>, State, ParameterRight, []>);
+type TBindParameters<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[]> = (Parameters extends [infer Left extends TParameter, ...infer Right extends TParameter[]] ? TBindArguments<Context, State, Left, Right, Arguments> : Context);
+export type TResolveArgumentsContext<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[], Result extends TProperties = TBindParameters<Context, State, Parameters, Arguments>> = Result;
+export declare function ResolveArgumentsContext<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[]>(context: Context, state: State, parameters: [...Parameters], arguments_: [...Arguments]): TResolveArgumentsContext<Context, State, Parameters, Arguments>;
+export {};

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

@@ -0,0 +1,39 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsSchema } from '../../types/schema.mjs';
+import { InstantiateType } from '../instantiate.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { IsInfer } from '../../types/infer.mjs';
+import { IsCall } from '../../types/call.mjs';
+// ------------------------------------------------------------------
+// AssertArgument
+// ------------------------------------------------------------------
+function AssertArgumentExtends(name, type, extends_) {
+    if (IsInfer(type) || IsCall(type) || ExtendsResult.IsExtendsTrueLike(Extends({}, type, extends_)))
+        return;
+    const cause = { parameter: name, extends: extends_, received: type };
+    // @ts-ignore - no definition for { cause } options 
+    throw new Error('Generic argument does not satify constraint', { cause });
+}
+function BindArgument(context, state, name, extends_, type) {
+    const instantiatedArgument = InstantiateType(context, state, type);
+    AssertArgumentExtends(name, instantiatedArgument, extends_);
+    return Memory.Assign(context, { [name]: instantiatedArgument });
+}
+function BindArguments(context, state, parameterLeft, parameterRight, arguments_) {
+    const instantiatedExtends = InstantiateType(context, state, parameterLeft.extends);
+    const instantiatedEquals = InstantiateType(context, state, parameterLeft.equals);
+    const [left, ...right] = arguments_;
+    return (IsSchema(left)
+        ? BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, left), state, parameterRight, right)
+        : BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, instantiatedEquals), state, parameterRight, []));
+}
+function BindParameters(context, state, parameters, arguments_) {
+    const [left, ...right] = parameters;
+    return (IsSchema(left)
+        ? BindArguments(context, state, left, right, arguments_)
+        : context);
+}
+export function ResolveArgumentsContext(context, state, parameters, arguments_) {
+    return BindParameters(context, state, parameters, arguments_);
+}

package/build/type/engine/call/resolve-target.d.mts

@@ -0,0 +1,25 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TGeneric } from '../../types/generic.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+import { type TNever } from '../../types/never.mjs';
+type TFromNotResolvable = ([
+    '(not-resolvable)',
+    TNever
+]);
+type TFromNotGeneric = ([
+    '(not-generic)',
+    TNever
+]);
+type TFromGeneric<Name extends string, Parameters extends TParameter[], Expression extends TSchema> = ([
+    Name,
+    TGeneric<Parameters, Expression>
+]);
+type TFromRef<Context extends TProperties, Ref extends string, Arguments extends TSchema[]> = (Ref extends keyof Context ? TFromType<Context, Ref, Context[Ref], Arguments> : TFromNotResolvable);
+type TFromType<Context extends TProperties, Name extends string, Type extends TSchema, Arguments extends TSchema[]> = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TFromGeneric<Name, Parameters, Expression> : Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Arguments> : TFromNotGeneric);
+/** Resolves a named generic target from the context, or returns TNever if it cannot be resolved or is not generic. */
+export type TResolveTarget<Context extends TProperties, Target extends TSchema, Arguments extends TSchema[], Result extends [string, TSchema] = TFromType<Context, '(anonymous)', Target, Arguments>> = Result;
+/** Resolves a named generic target from the context, or returns TNever if it cannot be resolved or is not generic. */
+export declare function ResolveTarget<Context extends TProperties, Target extends TSchema, Arguments extends TSchema[]>(context: Context, target: Target, arguments_: [...Arguments]): TFromType<Context, '(anonymous)', Target, Arguments>;
+export {};

package/build/type/engine/call/resolve-target.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+import { Generic, IsGeneric } from '../../types/generic.mjs';
+import { IsRef } from '../../types/ref.mjs';
+import { Never } from '../../types/never.mjs';
+function FromNotResolvable() {
+    return ['(not-resolvable)', Never()];
+}
+function FromNotGeneric() {
+    return ['(not-generic)', Never()];
+}
+function FromGeneric(name, parameters, expression) {
+    return [name, Generic(parameters, expression)];
+}
+function FromRef(context, ref, arguments_) {
+    return (ref in context
+        ? FromType(context, ref, context[ref], arguments_)
+        : FromNotResolvable());
+}
+function FromType(context, name, target, arguments_) {
+    return (IsGeneric(target) ? FromGeneric(name, target.parameters, target.expression) :
+        IsRef(target) ? FromRef(context, target.$ref, arguments_) :
+            FromNotGeneric());
+}
+/** Resolves a named generic target from the context, or returns TNever if it cannot be resolved or is not generic. */
+export function ResolveTarget(context, target, arguments_) {
+    return FromType(context, '(anonymous)', target, arguments_);
+}

package/build/type/engine/conditional/index.d.mts

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

package/build/type/engine/conditional/index.mjs

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

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

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TConditionalDeferred } from '../../action/conditional.mjs';
+type TConditionalImmediate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, InstaniatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstaniatedRight extends TSchema = TInstantiateType<Context, State, Right>, ExtendsResult extends ExtendsResult.TResult = TExtends<Context, InstaniatedLeft, InstaniatedRight>> = (ExtendsResult extends ExtendsResult.TExtendsUnion<infer InferredContext extends TProperties> ? TUnion<[TInstantiateType<InferredContext, State, True>, TInstantiateType<Context, State, False>]> : ExtendsResult extends ExtendsResult.TExtendsTrue<infer InferredContext extends TProperties> ? TInstantiateType<InferredContext, State, True> : TInstantiateType<Context, State, False>);
+export type TConditionalInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = TCanInstantiate<Context, [Left, Right]> extends true ? TConditionalImmediate<Context, State, Left, Right, True, False> : TConditionalDeferred<Left, Right, True, False>;
+export declare function ConditionalInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(context: Context, state: State, left: Left, right: Right, true_: True, false_: False, options: TSchemaOptions): TConditionalInstantiate<Context, State, Left, Right, True, False>;
+export {};

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

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { Union } from '../../types/union.mjs';
+import { Extends, ExtendsResult } from '../../extends/index.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+import { ConditionalDeferred } from '../../action/conditional.mjs';
+function ConditionalImmediate(context, state, left, right, true_, false_, options) {
+    const instantiatedLeft = InstantiateType(context, state, left);
+    const instantiatedRight = InstantiateType(context, state, right);
+    const extendsResult = Extends(context, instantiatedLeft, instantiatedRight);
+    return Memory.Update((ExtendsResult.IsExtendsUnion(extendsResult) ? Union([InstantiateType(extendsResult.inferred, state, true_), InstantiateType(context, state, false_)]) :
+        ExtendsResult.IsExtendsTrue(extendsResult) ? InstantiateType(extendsResult.inferred, state, true_) :
+            InstantiateType(context, state, false_)), {}, options);
+}
+export function ConditionalInstantiate(context, state, left, right, true_, false_, options) {
+    return (CanInstantiate(context, [left, right])
+        ? ConditionalImmediate(context, state, left, right, true_, false_, options)
+        : ConditionalDeferred(left, right, true_, false_, options));
+}

package/build/type/engine/constructor-parameters/index.d.mts

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

package/build/type/engine/constructor-parameters/index.mjs

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

package/build/type/engine/constructor-parameters/instantiate.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TNever } from '../../types/never.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TConstructorParametersDeferred } from '../../action/constructor-parameters.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TConstructorParametersAction<Type extends TSchema> = (Type extends TConstructor<infer Parameters extends TSchema[], infer _ extends TSchema> ? TInstantiateType<{}, {
+    callstack: [];
+}, TTuple<Parameters>> : TNever);
+type TConstructorParametersImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TConstructorParametersAction<InstantiatedType>;
+export type TConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TConstructorParametersImmediate<Context, State, Type> : TConstructorParametersDeferred<Type>;
+export declare function ConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TConstructorParametersInstantiate<Context, State, Type>;
+export {};

package/build/type/engine/constructor-parameters/instantiate.mjs

@@ -0,0 +1,21 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsConstructor } from '../../types/constructor.mjs';
+import { Never } from '../../types/never.mjs';
+import { Tuple } from '../../types/tuple.mjs';
+import { ConstructorParametersDeferred } from '../../action/constructor-parameters.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function ConstructorParametersAction(type) {
+    return (IsConstructor(type)
+        ? InstantiateType({}, { callstack: [] }, Tuple(type.parameters))
+        : Never());
+}
+function ConstructorParametersImmediate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return Memory.Update(ConstructorParametersAction(instantiatedType), {}, options);
+}
+export function ConstructorParametersInstantiate(context, state, type, options) {
+    return (CanInstantiate(context, [type])
+        ? ConstructorParametersImmediate(context, state, type, options)
+        : ConstructorParametersDeferred(type, options));
+}

package/build/type/engine/cyclic/candidates.d.mts

@@ -0,0 +1,9 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TProperties, TPropertyKeys } from '../../types/properties.mjs';
+import { type TCyclicCheck } from './check.mjs';
+type TResolveCandidateKeys<Context extends TProperties, Keys extends string[], Result extends string[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Context ? TCyclicCheck<[Left], Context, Context[Left]> extends true ? TResolveCandidateKeys<Context, Right, [...Result, Left]> : TResolveCandidateKeys<Context, Right, Result> : TUnreachable : Result);
+/** Returns keys for context types that need to be transformed to TCyclic. */
+export type TCyclicCandidates<Context extends TProperties, Keys extends string[] = TPropertyKeys<Context>, Result extends string[] = TResolveCandidateKeys<Context, Keys>> = Result;
+/** Returns keys for context types that need to be transformed to TCyclic. */
+export declare function CyclicCandidates<Context extends TProperties>(context: Context): TCyclicCandidates<Context>;
+export {};

package/build/type/engine/cyclic/candidates.mjs

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { Unreachable } from '../../../system/unreachable/index.mjs';
+import { PropertyKeys } from '../../types/properties.mjs';
+import { CyclicCheck } from './check.mjs';
+function ResolveCandidateKeys(context, keys) {
+    return keys.reduce((result, left) => {
+        return left in context
+            ? CyclicCheck([left], context, context[left])
+                ? [...result, left]
+                : result
+            : Unreachable();
+    }, []);
+}
+/** Returns keys for context types that need to be transformed to TCyclic. */
+export function CyclicCandidates(context) {
+    const keys = PropertyKeys(context);
+    const result = ResolveCandidateKeys(context, keys);
+    return result;
+}

package/build/type/engine/cyclic/check.d.mts

@@ -0,0 +1,24 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TAsyncIterator } from '../../types/async-iterator.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TIterator } from '../../types/iterator.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TPromise } from '../../types/promise.mjs';
+import { type TProperties, type TPropertyValues } from '../../types/properties.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TInterfaceDeferred } from '../../action/interface.mjs';
+type TFromRef<Stack extends string[], Context extends TProperties, Ref extends string> = Ref extends Stack[number] ? true : TFromType<[...Stack, Ref], Context, Context[Ref]>;
+type TFromProperties<Stack extends string[], Context extends TProperties, Properties extends TProperties, Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Stack, Context, Types>;
+type TFromTypes<Stack extends string[], Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromType<Stack, Context, Left> extends true ? true : TFromTypes<Stack, Context, Right> : false;
+type TFromType<Stack extends string[], Context extends TProperties, Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Stack, Context, Ref> : Type extends TArray<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, InstanceType]> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, ReturnType]> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TPromise<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Stack, Context, Type> : false);
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+export type TCyclicCheck<Stack extends string[], Context extends TProperties, Type extends TSchema, Result extends boolean = TFromType<Stack, Context, Type>> = Result;
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+export declare function CyclicCheck<Stack extends string[], Context extends TProperties, Type extends TSchema>(stack: [...Stack], context: Context, type: Type): TCyclicCheck<Stack, Context, Type>;
+export {};

package/build/type/engine/cyclic/check.mjs

@@ -0,0 +1,54 @@
+// deno-fmt-ignore-file
+import { IsSchema } from '../../types/schema.mjs';
+import { IsArray } from '../../types/array.mjs';
+import { IsAsyncIterator } from '../../types/async-iterator.mjs';
+import { IsConstructor } from '../../types/constructor.mjs';
+import { IsFunction } from '../../types/function.mjs';
+import { IsIntersect } from '../../types/intersect.mjs';
+import { IsIterator } from '../../types/iterator.mjs';
+import { IsObject } from '../../types/object.mjs';
+import { IsPromise } from '../../types/promise.mjs';
+import { PropertyValues } from '../../types/properties.mjs';
+import { IsRecord, RecordValue } from '../../types/record.mjs';
+import { IsTuple } from '../../types/tuple.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { IsRef } from '../../types/ref.mjs';
+import { IsInterfaceDeferred } from '../../action/interface.mjs';
+function FromRef(stack, context, ref) {
+    return (stack.includes(ref)
+        ? true
+        : FromType([...stack, ref], context, context[ref]));
+}
+function FromProperties(stack, context, properties) {
+    const types = PropertyValues(properties);
+    return FromTypes(stack, context, types);
+}
+function FromTypes(stack, context, types) {
+    const [left, ...right] = types;
+    return (IsSchema(left)
+        ? FromType(stack, context, left)
+            ? true
+            : FromTypes(stack, context, right)
+        : false);
+}
+function FromType(stack, context, type) {
+    return (IsRef(type) ? FromRef(stack, context, type.$ref) :
+        IsArray(type) ? FromType(stack, context, type.items) :
+            IsAsyncIterator(type) ? FromType(stack, context, type.iteratorItems) :
+                IsConstructor(type) ? FromTypes(stack, context, [...type.parameters, type.instanceType]) :
+                    IsFunction(type) ? FromTypes(stack, context, [...type.parameters, type.returnType]) :
+                        IsInterfaceDeferred(type) ? FromProperties(stack, context, type.parameters[1]) :
+                            IsIntersect(type) ? FromTypes(stack, context, type.allOf) :
+                                IsIterator(type) ? FromType(stack, context, type.iteratorItems) :
+                                    IsObject(type) ? FromProperties(stack, context, type.properties) :
+                                        IsPromise(type) ? FromType(stack, context, type.item) :
+                                            IsUnion(type) ? FromTypes(stack, context, type.anyOf) :
+                                                IsTuple(type) ? FromTypes(stack, context, type.items) :
+                                                    IsRecord(type) ? FromType(stack, context, RecordValue(type)) :
+                                                        false);
+}
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+export function CyclicCheck(stack, context, type) {
+    const result = FromType(stack, context, type);
+    return result;
+}

package/build/type/engine/cyclic/dependencies.d.mts

@@ -0,0 +1,25 @@
+import { type TUnreachable } from '../../../system/unreachable/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TAsyncIterator } from '../../types/async-iterator.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TIterator } from '../../types/iterator.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TPromise } from '../../types/promise.mjs';
+import { type TProperties, type TPropertyValues } from '../../types/properties.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TInterfaceDeferred } from '../../action/interface.mjs';
+type TFromRef<Context extends TProperties, Ref extends string, Dependencies extends string[]> = Ref extends Dependencies[number] ? Dependencies : Ref extends keyof Context ? TFromType<Context, Context[Ref], [...Dependencies, Ref]> : TUnreachable;
+type TFromProperties<Context extends TProperties, Properties extends TProperties, Dependencies extends string[], Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Context, Types, Dependencies>;
+type TFromTypes<Context extends TProperties, Types extends TSchema[], Dependencies extends string[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromTypes<Context, Right, TFromType<Context, Left, Dependencies>> : Dependencies;
+type TFromType<Context extends TProperties, Type extends TSchema, Result extends string[]> = (Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Result> : Type extends TArray<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Context, [...Parameters, InstanceType], Result> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Context, [...Parameters, ReturnType], Result> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TIterator<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Context, Properties, Result> : Type extends TPromise<infer Type extends TSchema> ? TFromType<Context, Type, Result> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Context, Types, Result> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Context, Type, Result> : Result);
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+export type TCyclicDependencies<Context extends TProperties, Key extends string, Type extends TSchema, Result extends string[] = TFromType<Context, Type, [Key]>> = Result;
+/** Returns dependent cyclic keys for the given type. This function is used to dead-type-eliminate (DTE) for initializing TCyclic types. */
+export declare function CyclicDependencies<Context extends TProperties, Key extends string, Type extends TSchema>(context: Context, key: Key, type: Type): TCyclicDependencies<Context, Key, Type>;
+export {};