@sinclair/typebox 0.26.0-dev.3 → 0.26.0-dev.5

package/value/create.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+exports.ValueCreate = exports.ValueCreateDereferenceError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
 const Types = require("../typebox");
 const check_1 = require("./check");
 // --------------------------------------------------------------------------
@@ -54,12 +54,28 @@ class ValueCreateIntersectTypeError extends Error {
     }
 }
 exports.ValueCreateIntersectTypeError = ValueCreateIntersectTypeError;
+class ValueCreateDereferenceError extends Error {
+    constructor(schema) {
+        super(`ValueCreate: Unable to dereference schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.ValueCreateDereferenceError = ValueCreateDereferenceError;
 // --------------------------------------------------------------------------
 // ValueCreate
 // --------------------------------------------------------------------------
 var ValueCreate;
 (function (ValueCreate) {
-    function Any(schema) {
+    // --------------------------------------------------------
+    // Guards
+    // --------------------------------------------------------
+    function IsString(value) {
+        return typeof value === 'string';
+    }
+    // --------------------------------------------------------
+    // Types
+    // --------------------------------------------------------
+    function Any(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -67,7 +83,7 @@ var ValueCreate;
             return {};
         }
     }
-    function Array(schema) {
+    function Array(schema, references) {
         if (schema.uniqueItems === true && schema.default === undefined) {
             throw new Error('ValueCreate.Array: Arrays with uniqueItems require a default value');
         }
@@ -76,14 +92,14 @@ var ValueCreate;
         }
         else if (schema.minItems !== undefined) {
             return globalThis.Array.from({ length: schema.minItems }).map((item) => {
-                return ValueCreate.Create(schema.items);
+                return ValueCreate.Create(schema.items, references);
             });
         }
         else {
             return [];
         }
     }
-    function BigInt(schema) {
+    function BigInt(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -91,7 +107,7 @@ var ValueCreate;
             return globalThis.BigInt(0);
         }
     }
-    function Boolean(schema) {
+    function Boolean(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -99,12 +115,12 @@ var ValueCreate;
             return false;
         }
     }
-    function Constructor(schema) {
+    function Constructor(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
         else {
-            const value = ValueCreate.Create(schema.returns);
+            const value = ValueCreate.Create(schema.returns, references);
             if (typeof value === 'object' && !globalThis.Array.isArray(value)) {
                 return class {
                     constructor() {
@@ -121,7 +137,7 @@ var ValueCreate;
             }
         }
     }
-    function Date(schema) {
+    function Date(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -132,15 +148,15 @@ var ValueCreate;
             return new globalThis.Date(0);
         }
     }
-    function Function(schema) {
+    function Function(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
         else {
-            return () => ValueCreate.Create(schema.returns);
+            return () => ValueCreate.Create(schema.returns, references);
         }
     }
-    function Integer(schema) {
+    function Integer(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -151,18 +167,18 @@ var ValueCreate;
             return 0;
         }
     }
-    function Intersect(schema) {
+    function Intersect(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
         else {
-            const value = schema.type === 'object' ? schema.allOf.reduce((acc, schema) => ({ ...acc, ...Visit(schema) }), {}) : schema.allOf.reduce((_, schema) => Visit(schema), undefined);
-            if (!check_1.ValueCheck.Check(schema, value))
+            const value = schema.type === 'object' ? schema.allOf.reduce((acc, schema) => ({ ...acc, ...Visit(schema, references) }), {}) : schema.allOf.reduce((_, schema) => Visit(schema, references), undefined);
+            if (!check_1.ValueCheck.Check(schema, references, value))
                 throw new ValueCreateIntersectTypeError(schema);
             return value;
         }
     }
-    function Literal(schema) {
+    function Literal(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -170,18 +186,18 @@ var ValueCreate;
             return schema.const;
         }
     }
-    function Never(schema) {
+    function Never(schema, references) {
         throw new ValueCreateNeverTypeError(schema);
     }
-    function Not(schema) {
+    function Not(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
         else {
-            return Visit(schema.allOf[1]);
+            return Visit(schema.allOf[1], references);
         }
     }
-    function Null(schema) {
+    function Null(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -189,7 +205,7 @@ var ValueCreate;
             return null;
         }
     }
-    function Number(schema) {
+    function Number(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -200,7 +216,7 @@ var ValueCreate;
             return 0;
         }
     }
-    function Object(schema) {
+    function Object(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -208,19 +224,19 @@ var ValueCreate;
             const required = new Set(schema.required);
             return (schema.default ||
                 globalThis.Object.entries(schema.properties).reduce((acc, [key, schema]) => {
-                    return required.has(key) ? { ...acc, [key]: ValueCreate.Create(schema) } : { ...acc };
+                    return required.has(key) ? { ...acc, [key]: ValueCreate.Create(schema, references) } : { ...acc };
                 }, {}));
         }
     }
-    function Promise(schema) {
+    function Promise(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
         else {
-            return globalThis.Promise.resolve(ValueCreate.Create(schema.item));
+            return globalThis.Promise.resolve(ValueCreate.Create(schema.item, references));
         }
     }
-    function Record(schema) {
+    function Record(schema, references) {
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         if ('default' in schema) {
             return schema.default;
@@ -228,30 +244,38 @@ var ValueCreate;
         else if (!(keyPattern === '^.*$' || keyPattern === '^(0|[1-9][0-9]*)$')) {
             const propertyKeys = keyPattern.slice(1, keyPattern.length - 1).split('|');
             return propertyKeys.reduce((acc, key) => {
-                return { ...acc, [key]: Create(valueSchema) };
+                return { ...acc, [key]: Create(valueSchema, references) };
             }, {});
         }
         else {
             return {};
         }
     }
-    function Ref(schema) {
+    function Ref(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
         else {
-            return Visit(Types.ReferenceRegistry.DerefOne(schema));
+            const index = references.findIndex((foreign) => foreign.$id === schema.$id);
+            if (index === -1)
+                throw new ValueCreateDereferenceError(schema);
+            const target = references[index];
+            return Visit(target, references);
         }
     }
-    function Self(schema) {
+    function Self(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
         else {
-            return Visit(Types.ReferenceRegistry.DerefOne(schema));
+            const index = references.findIndex((foreign) => foreign.$id === schema.$id);
+            if (index === -1)
+                throw new ValueCreateDereferenceError(schema);
+            const target = references[index];
+            return Visit(target, references);
         }
     }
-    function String(schema) {
+    function String(schema, references) {
         if (schema.pattern !== undefined) {
             if (!('default' in schema)) {
                 throw new Error('ValueCreate.String: String types with patterns must specify a default value');
@@ -282,7 +306,7 @@ var ValueCreate;
             }
         }
     }
-    function Symbol(schema) {
+    function Symbol(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -293,7 +317,7 @@ var ValueCreate;
             return globalThis.Symbol();
         }
     }
-    function Tuple(schema) {
+    function Tuple(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -301,10 +325,10 @@ var ValueCreate;
             return [];
         }
         else {
-            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create(schema.items[index]));
+            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create(schema.items[index], references));
         }
     }
-    function Undefined(schema) {
+    function Undefined(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -312,7 +336,7 @@ var ValueCreate;
             return undefined;
         }
     }
-    function Union(schema) {
+    function Union(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -320,10 +344,10 @@ var ValueCreate;
             throw new Error('ValueCreate.Union: Cannot create Union with zero variants');
         }
         else {
-            return ValueCreate.Create(schema.anyOf[0]);
+            return ValueCreate.Create(schema.anyOf[0], references);
         }
     }
-    function Uint8Array(schema) {
+    function Uint8Array(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -334,7 +358,7 @@ var ValueCreate;
             return new globalThis.Uint8Array(0);
         }
     }
-    function Unknown(schema) {
+    function Unknown(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -342,7 +366,7 @@ var ValueCreate;
             return {};
         }
     }
-    function Void(schema) {
+    function Void(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -350,7 +374,7 @@ var ValueCreate;
             return void 0;
         }
     }
-    function UserDefined(schema) {
+    function UserDefined(schema, references) {
         if ('default' in schema) {
             return schema.default;
         }
@@ -359,72 +383,73 @@ var ValueCreate;
         }
     }
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-    function Visit(schema) {
-        const anySchema = schema;
-        switch (anySchema[Types.Kind]) {
+    function Visit(schema, references) {
+        const references_ = IsString(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
+        switch (schema_[Types.Kind]) {
             case 'Any':
-                return Any(anySchema);
+                return Any(schema_, references_);
             case 'Array':
-                return Array(anySchema);
+                return Array(schema_, references_);
             case 'BigInt':
-                return BigInt(anySchema);
+                return BigInt(schema_, references_);
             case 'Boolean':
-                return Boolean(anySchema);
+                return Boolean(schema_, references_);
             case 'Constructor':
-                return Constructor(anySchema);
+                return Constructor(schema_, references_);
             case 'Date':
-                return Date(anySchema);
+                return Date(schema_, references_);
             case 'Function':
-                return Function(anySchema);
+                return Function(schema_, references_);
             case 'Integer':
-                return Integer(anySchema);
+                return Integer(schema_, references_);
             case 'Intersect':
-                return Intersect(anySchema);
+                return Intersect(schema_, references_);
             case 'Literal':
-                return Literal(anySchema);
+                return Literal(schema_, references_);
             case 'Never':
-                return Never(anySchema);
+                return Never(schema_, references_);
             case 'Not':
-                return Not(anySchema);
+                return Not(schema_, references_);
             case 'Null':
-                return Null(anySchema);
+                return Null(schema_, references_);
             case 'Number':
-                return Number(anySchema);
+                return Number(schema_, references_);
             case 'Object':
-                return Object(anySchema);
+                return Object(schema_, references_);
             case 'Promise':
-                return Promise(anySchema);
+                return Promise(schema_, references_);
             case 'Record':
-                return Record(anySchema);
+                return Record(schema_, references_);
             case 'Ref':
-                return Ref(anySchema);
+                return Ref(schema_, references_);
             case 'Self':
-                return Self(anySchema);
+                return Self(schema_, references_);
             case 'String':
-                return String(anySchema);
+                return String(schema_, references_);
             case 'Symbol':
-                return Symbol(anySchema);
+                return Symbol(schema_, references_);
             case 'Tuple':
-                return Tuple(anySchema);
+                return Tuple(schema_, references_);
             case 'Undefined':
-                return Undefined(anySchema);
+                return Undefined(schema_, references_);
             case 'Union':
-                return Union(anySchema);
+                return Union(schema_, references_);
             case 'Uint8Array':
-                return Uint8Array(anySchema);
+                return Uint8Array(schema_, references_);
             case 'Unknown':
-                return Unknown(anySchema);
+                return Unknown(schema_, references_);
             case 'Void':
-                return Void(anySchema);
+                return Void(schema_, references_);
             default:
-                if (!Types.TypeRegistry.Has(anySchema[Types.Kind]))
-                    throw new ValueCreateUnknownTypeError(anySchema);
-                return UserDefined(anySchema);
+                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                    throw new ValueCreateUnknownTypeError(schema_);
+                return UserDefined(schema_, references_);
         }
     }
     ValueCreate.Visit = Visit;
-    function Create(schema) {
-        return Visit(schema);
+    function Create(schema, references) {
+        return Visit(schema, references);
     }
     ValueCreate.Create = Create;
 })(ValueCreate = exports.ValueCreate || (exports.ValueCreate = {}));

package/value/value.d.ts

@@ -1,20 +1,30 @@
 import * as Types from '../typebox';
-import { ValueErrorIterator } from '../errors/index';
+import { ValueError } from '../errors/index';
 import { Edit } from './delta';
 /** Provides functions to perform structural updates to JavaScript values */
 export declare namespace Value {
+    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
+    function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): Types.Static<T>;
     /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
     function Cast<T extends Types.TSchema>(schema: T, value: unknown): Types.Static<T>;
     /** Creates a value from the given type */
+    function Create<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R]): Types.Static<T>;
+    /** Creates a value from the given type */
     function Create<T extends Types.TSchema>(schema: T): Types.Static<T>;
     /** Returns true if the value matches the given type. */
+    function Check<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
+    /** Returns true if the value matches the given type. */
     function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;
     /** Converts any type mismatched values to their target type if a conversion is possible. */
-    function Convert<T extends Types.TSchema>(schema: T, value: unknown): unknown;
+    function Convert<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
+    /** Converts any type mismatched values to their target type if a conversion is possible. */
+    function Convert<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;
     /** Returns a structural clone of the given value */
     function Clone<T>(value: T): T;
     /** Returns an iterator for each error in this value. */
-    function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrorIterator;
+    function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): IterableIterator<ValueError>;
+    /** Returns an iterator for each error in this value. */
+    function Errors<T extends Types.TSchema>(schema: T, value: unknown): IterableIterator<ValueError>;
     /** Returns true if left and right values are structurally equal */
     function Equal<T>(left: T, right: unknown): right is T;
     /** Returns edits to transform the current value into the next value */

package/value/value.js

@@ -40,24 +40,24 @@ const delta_1 = require("./delta");
 /** Provides functions to perform structural updates to JavaScript values */
 var Value;
 (function (Value) {
-    /** Casts a value into a given type. The return value will retain as much information of the original value as possible. Cast will convert string, number, boolean and date values if a reasonable conversion is possible. */
-    function Cast(schema, value) {
-        return cast_1.ValueCast.Cast(schema, value);
+    function Cast(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return cast_1.ValueCast.Cast(schema, references, value);
     }
     Value.Cast = Cast;
-    /** Creates a value from the given type */
-    function Create(schema) {
-        return create_1.ValueCreate.Create(schema);
+    function Create(...args) {
+        const [schema, references] = args.length === 2 ? [args[0], args[1]] : [args[0], []];
+        return create_1.ValueCreate.Create(schema, references);
     }
     Value.Create = Create;
-    /** Returns true if the value matches the given type. */
-    function Check(schema, value) {
-        return check_1.ValueCheck.Check(schema, value);
+    function Check(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return check_1.ValueCheck.Check(schema, references, value);
     }
     Value.Check = Check;
-    /** Converts any type mismatched values to their target type if a conversion is possible. */
-    function Convert(schema, value) {
-        return convert_1.ValueConvert.Convert(schema, value);
+    function Convert(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        return convert_1.ValueConvert.Convert(schema, references, value);
     }
     Value.Convert = Convert;
     /** Returns a structural clone of the given value */
@@ -65,9 +65,9 @@ var Value;
         return clone_1.ValueClone.Clone(value);
     }
     Value.Clone = Clone;
-    /** Returns an iterator for each error in this value. */
-    function Errors(schema, value) {
-        return index_1.ValueErrors.Errors(schema, value);
+    function* Errors(...args) {
+        const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+        yield* index_1.ValueErrors.Errors(schema, references, value);
     }
     Value.Errors = Errors;
     /** Returns true if left and right values are structurally equal */