typebox 1.0.5 → 1.0.7

package/build/compile/validator.d.mts

@@ -4,6 +4,7 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     private readonly context;
     private readonly type;
     private readonly isEvaluated;
+    private readonly hasCodec;
     private readonly code;
     private readonly check;
     constructor(context: Context, type: Type);
@@ -15,16 +16,22 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Type(): Type;
     /** Returns the generated code for this validator */
     Code(): string;
+    /** Checks a value matches the Validator type. */
     Check(value: unknown): value is StaticEncode<Type, Context>;
+    /** Returns errors for the given value. */
     Errors(value: unknown): TLocalizedValidationError[];
+    /** Cleans a value using the Validator type. */
     Clean(value: unknown): unknown;
+    /** Converts a value using the Validator type. */
     Convert(value: unknown): unknown;
+    /** Creates a value using the Validator type. */
     Create(): StaticEncode<Type, Context>;
+    /** Creates defaults using the Validator type. */
     Default(value: unknown): unknown;
-    /** Parses a value of this type */
+    /** Parses a value */
     Parse(value: unknown): StaticDecode<Type, Context>;
-    /** Decodes a value of this type */
+    /** Decodes a value */
     Decode(value: unknown): StaticDecode<Type, Context>;
-    /** Encodes a value of this type */
+    /** Encodes a value */
     Encode(value: unknown): StaticEncode<Type, Context>;
 }

package/build/compile/validator.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Environment } from '../system/environment/index.mjs';
 import { Base } from '../type/index.mjs';
-import { Errors, Clean, Convert, Create, Default, Parser, Decode, Encode } from '../value/index.mjs';
+import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser } from '../value/index.mjs';
 import { Build } from '../schema/index.mjs';
 // ------------------------------------------------------------------
 // ValidatorType<...>
@@ -12,6 +12,7 @@ export class Validator extends Base {
         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;
@@ -44,40 +45,48 @@ export class Validator extends Base {
     // ----------------------------------------------------------------
     // Base<...>
     // ----------------------------------------------------------------
+    /** Checks a value matches the Validator type. */
     Check(value) {
         return this.check(value);
     }
+    /** Returns errors for the given value. */
     Errors(value) {
         if (Environment.CanEvaluate() && this.check(value))
             return [];
         return Errors(this.context, this.type, value);
     }
+    /** Cleans a value using the Validator type. */
     Clean(value) {
         return Clean(this.context, this.type, value);
     }
+    /** Converts a value using the Validator type. */
     Convert(value) {
         return Convert(this.context, this.type, value);
     }
+    /** Creates a value using the Validator type. */
     Create() {
         return Create(this.context, this.type);
     }
+    /** Creates defaults using the Validator type. */
     Default(value) {
         return Default(this.context, this.type, value);
     }
     // ----------------------------------------------------------------
-    // Parse
+    // Parse | Decode | Encode
     // ----------------------------------------------------------------
-    /** Parses a value of this type */
+    /** Parses a value */
     Parse(value) {
         const result = this.Check(value) ? value : Parser(this.context, this.type, value);
         return result;
     }
-    /** Decodes a value of this type */
+    /** Decodes a value */
     Decode(value) {
-        return Decode(this.context, this.type, value);
+        const result = this.hasCodec ? Decode(this.context, this.type, value) : this.Parse(value);
+        return result;
     }
-    /** Encodes a value of this type */
+    /** Encodes a value */
     Encode(value) {
-        return Encode(this.context, this.type, value);
+        const result = this.hasCodec ? Encode(this.context, this.type, value) : this.Parse(value);
+        return result;
     }
 }

package/build/guard/guard.d.mts

@@ -34,6 +34,8 @@ export declare function IsLessThan<Type extends number | bigint>(left: Type, rig
 export declare function IsLessEqualThan<Type extends number | bigint>(left: Type, right: Type): boolean;
 export declare function IsGreaterEqualThan<Type extends number | bigint>(left: Type, right: Type): boolean;
 export declare function IsMultipleOf(dividend: bigint | number, divisor: bigint | number): boolean;
+/** Returns true if the value appears to be an instance of a class. */
+export declare function IsClassInstance(value: unknown): boolean;
 export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
 /** Returns the number of Unicode Grapheme Clusters */
 export declare function StringGraphemeCount(value: string): number;

package/build/guard/guard.mjs

@@ -102,6 +102,20 @@ export function IsMultipleOf(dividend, divisor) {
     return Math.min(Math.abs(mod), Math.abs(mod - divisor)) < tolerance;
 }
 // ------------------------------------------------------------------
+// IsClassInstance
+// ------------------------------------------------------------------
+/** Returns true if the value appears to be an instance of a class. */
+export function IsClassInstance(value) {
+    if (!IsObject(value))
+        return false;
+    const proto = globalThis.Object.getPrototypeOf(value);
+    if (IsNull(proto))
+        return false;
+    return IsEqual(typeof proto.constructor, 'function') &&
+        !(IsEqual(proto.constructor, globalThis.Object) ||
+            IsEqual(proto.constructor.name, 'Object'));
+}
+// ------------------------------------------------------------------
 // IsValueLike
 // ------------------------------------------------------------------
 export function IsValueLike(value) {

package/build/value/check/check.d.mts

@@ -1,5 +1,5 @@
 import type { Static, TProperties, TSchema } from '../../type/index.mjs';
-/** Checks a value matches the provided type. This function returns a TypeScript type predicate and does not throw. */
+/** Checks a value matches the provided type. */
 export declare function Check<const Type extends TSchema, Result extends unknown = Static<Type>>(type: Type, value: unknown): value is Result;
-/** Checks a value matches the provided type. This function returns a TypeScript type predicate and does not throw. */
+/** Checks a value matches the provided type. */
 export declare function Check<Context extends TProperties, const Type extends TSchema, Result extends unknown = Static<Type, Context>>(context: Context, type: Type, value: unknown): value is Result;

package/build/value/check/check.mjs

@@ -1,7 +1,7 @@
 // deno-fmt-ignore-file
 import { Arguments } from '../../system/arguments/index.mjs';
 import { Check as SchemaCheck } from '../../schema/index.mjs';
-/** Checks a value matches the provided type. This function returns a TypeScript type predicate and does not throw. */
+/** Checks a value matches the provided type. */
 export function Check(...args) {
     const [context, type, value] = Arguments.Match(args, {
         3: (context, type, value) => [context, type, value],

package/build/value/clone/clone.mjs

@@ -1,9 +1,22 @@
 // deno-fmt-ignore-file
 import { Guard, GlobalsGuard } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
-// Object
+// ClassInstance
+//
+// TypeBox does not support cloning arbitrary class instances. It treats
+// class instances as atomic values, similar to number, boolean, and
+// string. In the future, an implementation could detect the presence of
+// a .clone() method, but no formal specification for this behavior
+// exists, so we don't.
+//
 // ------------------------------------------------------------------
-function FromObject(value) {
+function FromClassInstance(value) {
+    return value; // atomic
+}
+// ------------------------------------------------------------------
+// ObjectInstance
+// ------------------------------------------------------------------
+function FromObjectInstance(value) {
     const result = {};
     for (const key of Object.getOwnPropertyNames(value)) {
         result[key] = Clone(value[key]);
@@ -14,6 +27,14 @@ function FromObject(value) {
     return result;
 }
 // ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    return (Guard.IsClassInstance(value)
+        ? FromClassInstance(value)
+        : FromObjectInstance(value));
+}
+// ------------------------------------------------------------------
 // Array
 // ------------------------------------------------------------------
 function FromArray(value) {

package/build/value/codec/has.mjs

@@ -46,6 +46,9 @@ function FromRecord(context, type) {
 // Ref
 // ------------------------------------------------------------------
 function FromRef(context, type) {
+    if (visited.has(type.$ref))
+        return false;
+    visited.add(type.$ref);
     return IsCodec(type) || (Guard.HasPropertyKey(context, type.$ref)
         && FromType(context, context[type.$ref]));
 }
@@ -75,11 +78,16 @@ function FromType(context, type) {
                                 IsUnion(type) ? FromUnion(context, type) :
                                     IsCodec(type));
 }
+// ------------------------------------------------------------------
+// Visited
+// ------------------------------------------------------------------
+const visited = new Set();
 /** Returns true if this type contains a Codec */
 export function HasCodec(...args) {
     const [context, type] = Arguments.Match(args, {
         2: (context, type) => [context, type],
         1: (type) => [{}, type]
     });
+    visited.clear();
     return FromType(context, type);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "A Runtime Type System for JavaScript",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "keywords": [
     "typescript",
     "jsonschema"

package/readme.md

@@ -33,7 +33,7 @@ import Type, { type Static } from 'typebox'
 const T = Type.Object({                             // const T = {
   x: Type.Number(),                                 //   type: 'object',
   y: Type.Number(),                                 //   required: ['x', 'y', 'z'],
-  z: Type.Number(),                                 //   properties: {
+  z: Type.Number()                                  //   properties: {
 })                                                  //     x: { type: 'number' },
                                                     //     y: { type: 'number' },
                                                     //     z: { type: 'number' }
@@ -55,19 +55,22 @@ TypeBox is a runtime type system that creates in-memory Json Schema objects that
 
 This library is designed to allow Json Schema to compose similar to how types compose within TypeScript's type system. It can be used as a simple tool to build up complex schematics or integrated into REST and RPC services to help validate data received over the wire.
 
-
-
 License: MIT
 
 ## Contents
 
+- [Upgrade](#Upgrade)
 - [Type](#Type)
 - [Script](#Script)
 - [Value](#Value)
 - [Compile](#Compile)
 - [Contribute](#Contribute)
 
+## Upgrade
+
+Refer to the following URL for information on upgrading from 0.34.x to 1.0.
 
+[1.0 Migration Guide](https://github.com/sinclairzx81/typebox/blob/main/changelog/1.0.0-migration.md)
 
 <a name="Type"></a>