typebox 1.0.50 → 1.0.52

package/build/compile/validator.d.mts

@@ -7,14 +7,17 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     private readonly hasCodec;
     private readonly code;
     private readonly check;
+    /** Constructs a Validator with the given Context and Type. */
     constructor(context: Context, type: Type);
-    /** Returns true if this validator is using runtime eval optimizations */
+    /** Constructs a Validator with the given arguments. */
+    constructor(context: Context, type: Type, isEvaluated: boolean, hasCodec: boolean, code: string, check: (value: unknown) => boolean);
+    /** Returns true if this validator is using runtime eval optimizations. */
     IsEvaluated(): boolean;
-    /** Returns the Context for this validator */
+    /** Returns the Context for this validator. */
     Context(): Context;
-    /** Returns the Type for this validator */
+    /** Returns the Type for this validator. */
     Type(): Type;
-    /** Returns the generated code for this validator */
+    /** Returns the generated code for this validator. */
     Code(): string;
     /** Checks a value matches the Validator type. */
     Check(value: unknown): value is StaticEncode<Type, Context>;
@@ -28,6 +31,8 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Create(): StaticEncode<Type, Context>;
     /** Creates defaults using the Validator type. */
     Default(value: unknown): unknown;
+    /** Clones this validator. */
+    Clone(): Validator<Context, Type>;
     /** Parses a value */
     Parse(value: unknown): StaticDecode<Type, Context>;
     /** Decodes a value */

package/build/compile/validator.mjs

@@ -1,44 +1,62 @@
 // deno-fmt-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
 import { Environment } from '../system/environment/index.mjs';
 import { Base } from '../type/index.mjs';
 import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser } from '../value/index.mjs';
 import { Build } from '../schema/index.mjs';
 // ------------------------------------------------------------------
-// ValidatorType<...>
+// Validator<...>
 // ------------------------------------------------------------------
 export class Validator extends Base {
-    constructor(context, type) {
+    /** Constructs a Validator. */
+    constructor(...args) {
         super();
-        this.context = context;
-        this.type = type;
-        const result = Build(context, type).Evaluate();
-        this.hasCodec = HasCodec(context, type);
-        this.isEvaluated = result.IsEvaluated;
-        this.code = result.Code;
-        this.check = result.Check;
+        const matched = Arguments.Match(args, {
+            6: (context, type, isEvalulated, hasCodec, code, check) => [context, type, isEvalulated, hasCodec, code, check],
+            2: (context, type) => [context, type]
+        });
+        if (matched.length === 6) {
+            const [context, type, isEvaluated, hasCodec, code, check] = matched;
+            this.context = context;
+            this.type = type;
+            this.isEvaluated = isEvaluated;
+            this.hasCodec = hasCodec;
+            this.code = code;
+            this.check = check;
+        }
+        else {
+            const [context, type] = matched;
+            const result = Build(context, type).Evaluate();
+            this.hasCodec = HasCodec(context, type);
+            this.context = context;
+            this.type = type;
+            this.isEvaluated = result.IsEvaluated;
+            this.code = result.Code;
+            this.check = result.Check;
+        }
     }
     // ----------------------------------------------------------------
-    // Evaluated
+    // IsEvaluated
     // ----------------------------------------------------------------
-    /** Returns true if this validator is using runtime eval optimizations */
+    /** Returns true if this validator is using runtime eval optimizations. */
     IsEvaluated() {
         return this.isEvaluated;
     }
     // ----------------------------------------------------------------
-    // Schema
+    // Context | Type
     // ----------------------------------------------------------------
-    /** Returns the Context for this validator */
+    /** Returns the Context for this validator. */
     Context() {
         return this.context;
     }
-    /** Returns the Type for this validator */
+    /** Returns the Type for this validator. */
     Type() {
         return this.type;
     }
     // ----------------------------------------------------------------
     // Code
     // ----------------------------------------------------------------
-    /** Returns the generated code for this validator */
+    /** Returns the generated code for this validator. */
     Code() {
         return this.code;
     }
@@ -71,6 +89,10 @@ export class Validator extends Base {
     Default(value) {
         return Default(this.context, this.type, value);
     }
+    /** Clones this validator. */
+    Clone() {
+        return new Validator(this.context, this.type, this.isEvaluated, this.hasCodec, this.code, this.check);
+    }
     // ----------------------------------------------------------------
     // Parse | Decode | Encode
     // ----------------------------------------------------------------

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

@@ -156,7 +156,7 @@ type TInstantiateDeferred<Context extends TProperties, State extends TState, Act
     Action,
     Parameters
 ] extends ['Uppercase', [infer Type extends TSchema]] ? TUppercaseInstantiate<Context, State, Type> : TDeferred<Action, Parameters>);
-export type TInstantiateType<Context extends TProperties, State extends TState, Input extends TSchema, IsImmutable extends boolean = Input extends TImmutable ? true : false, ModifierState extends [TSchema, ModifierAction, ModifierAction] = TModifierActions<Input, Input extends TReadonly<Input> ? 'add' : 'none', Input extends TOptional<Input> ? 'add' : 'none'>, Type extends TSchema = ModifierState[0], Instantiated extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TInstantiateType<Context, State, Type>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithImmutable extends TSchema = IsImmutable extends true ? TImmutable<Instantiated> : Instantiated, WithModifiers extends TSchema = TApplyReadonly<ModifierState[1], TApplyOptional<ModifierState[2], WithImmutable>>> = WithModifiers;
+export type TInstantiateType<Context extends TProperties, State extends TState, Input extends TSchema, Immutable extends boolean = Input extends TImmutable ? true : false, Modifiers extends [TSchema, ModifierAction, ModifierAction] = TModifierActions<Input, Input extends TReadonly<Input> ? 'add' : 'none', Input extends TOptional<Input> ? 'add' : 'none'>, Type extends TSchema = Modifiers[0], Instantiated extends TSchema = (Type extends TRef<infer Ref extends string> ? TRefInstantiate<Context, State, Ref> : Type extends TArray<infer Type extends TSchema> ? TArray<TInstantiateType<Context, State, Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TInstantiateType<Context, State, Type>> : Type extends TCall<infer Target extends TSchema, infer Parameters extends TSchema[]> ? TCallInstantiate<Context, State, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, InstanceType>> : Type extends TDeferred<infer Action extends string, infer Types extends TSchema[]> ? TInstantiateDeferred<Context, State, Action, Types> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TInstantiateTypes<Context, State, Parameters>, TInstantiateType<Context, State, ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TInstantiateTypes<Context, State, Types>> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TInstantiateType<Context, State, Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<TInstantiateProperties<Context, State, Properties>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TInstantiateType<Context, State, Type>> : Type extends TRecord<infer Key extends string, infer Type extends TSchema> ? TRecord<Key, TInstantiateType<Context, State, Type>> : Type extends TRest<infer Type extends TSchema> ? TRest<TInstantiateType<Context, State, Type>> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TInstantiateElements<Context, State, Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TInstantiateTypes<Context, State, Types>> : Type), WithImmutable extends TSchema = Immutable extends true ? TImmutable<Instantiated> : Instantiated, WithModifiers extends TSchema = TApplyReadonly<Modifiers[1], TApplyOptional<Modifiers[2], WithImmutable>>> = WithModifiers;
 export declare function InstantiateType<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, input: Type): TInstantiateType<Context, State, Type>;
 /** Instantiates computed schematics using the given context and type. */
 export type TInstantiate<Context extends TProperties, Type extends TSchema> = (TInstantiateType<Context, {

package/build/type/engine/instantiate.mjs

@@ -13,6 +13,7 @@ import { IsReadonly, ReadonlyAdd, ReadonlyRemove } from '../types/_readonly.mjs'
 import { IsSchema } from '../types/schema.mjs';
 import { Array, IsArray, ArrayOptions } from '../types/array.mjs';
 import { AsyncIterator, IsAsyncIterator, AsyncIteratorOptions } from '../types/async-iterator.mjs';
+import { IsBase } from '../types/base.mjs';
 import { Constructor, IsConstructor, ConstructorOptions } from '../types/constructor.mjs';
 import { Deferred, IsDeferred } from '../types/deferred.mjs';
 import { Function as _Function, IsFunction, FunctionOptions } from '../types/function.mjs';
@@ -142,9 +143,9 @@ function InstantiateDeferred(context, state, action, parameters, options) {
                                                                                                                 Deferred(action, parameters, options));
 }
 export function InstantiateType(context, state, input) {
-    const isImmutable = IsImmutable(input);
-    const modifierActions = ModifierActions(input, IsReadonly(input) ? 'add' : 'none', IsOptional(input) ? 'add' : 'none');
-    const type = modifierActions[0];
+    const immutable = IsImmutable(input);
+    const modifiers = ModifierActions(input, IsReadonly(input) ? 'add' : 'none', IsOptional(input) ? 'add' : 'none');
+    const type = IsBase(modifiers[0]) ? modifiers[0].Clone() : modifiers[0];
     const instantiated = (IsRef(type) ? RefInstantiate(context, state, type.$ref) :
         IsArray(type) ? Array(InstantiateType(context, state, type.items), ArrayOptions(type)) :
             IsAsyncIterator(type) ? AsyncIterator(InstantiateType(context, state, type.iteratorItems), AsyncIteratorOptions(type)) :
@@ -161,8 +162,8 @@ export function InstantiateType(context, state, input) {
                                                         IsTuple(type) ? Tuple(InstantiateElements(context, state, type.items), TupleOptions(type)) :
                                                             IsUnion(type) ? Union(InstantiateTypes(context, state, type.anyOf), UnionOptions(type)) :
                                                                 type);
-    const withImmutable = isImmutable ? Immutable(instantiated) : instantiated;
-    const withModifiers = ApplyReadonly(modifierActions[1], ApplyOptional(modifierActions[2], withImmutable));
+    const withImmutable = immutable ? Immutable(instantiated) : instantiated;
+    const withModifiers = ApplyReadonly(modifiers[1], ApplyOptional(modifiers[2], withImmutable));
     return withModifiers;
 }
 /** Instantiates computed schematics using the given context and type. */

package/build/type/types/base.d.mts

@@ -18,6 +18,8 @@ export declare class Base<Value extends unknown = unknown> implements TSchema, X
     Default(value: unknown): unknown;
     /** Creates a new instance of this type */
     Create(): Value;
+    /** Clones this type  */
+    Clone(): Base;
 }
 /** Returns true if the given value is a Base type. */
 export declare function IsBase(value: unknown): value is Base;

package/build/type/types/base.mjs

@@ -4,25 +4,22 @@ import { IsKind } from './schema.mjs';
 // ------------------------------------------------------------------
 // Type.Base<...>
 // ------------------------------------------------------------------
+function BaseProperty(value) {
+    return {
+        enumerable: Settings.Get().enumerableKind,
+        writable: false,
+        configurable: false,
+        value
+    };
+}
 /** Base class for creating extension types. */
 export class Base {
     constructor() {
-        const configuration = {
-            enumerable: Settings.Get().enumerableKind,
-            writable: false,
-            configurable: false,
-        };
-        globalThis.Object.defineProperty(this, '~kind', {
-            ...configuration,
-            value: 'Base'
-        });
-        globalThis.Object.defineProperty(this, '~guard', {
-            ...configuration,
-            value: {
-                check: (value) => this.Check(value),
-                errors: (value) => this.Errors(value)
-            }
-        });
+        globalThis.Object.defineProperty(this, '~kind', BaseProperty('Base'));
+        globalThis.Object.defineProperty(this, '~guard', BaseProperty({
+            check: (value) => this.Check(value),
+            errors: (value) => this.Errors(value)
+        }));
     }
     /** Checks a value or returns false if invalid */
     Check(value) {
@@ -48,6 +45,10 @@ export class Base {
     Create() {
         throw new Error('Create not implemented');
     }
+    /** Clones this type  */
+    Clone() {
+        throw Error('Clone not implemented');
+    }
 }
 // ------------------------------------------------------------------
 // Guard

package/package.json

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