@sinclair/typebox 0.26.0-dev.4 → 0.26.0

package/value/convert.js

@@ -27,26 +27,26 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueConvert = exports.ValueConvertUnknownTypeError = exports.ValueConvertReferenceTypeError = void 0;
+exports.ValueConvert = exports.ValueConvertDereferenceError = exports.ValueConvertUnknownTypeError = void 0;
 const Types = require("../typebox");
 const clone_1 = require("./clone");
 // ----------------------------------------------------------------------------------------------
 // Errors
 // ----------------------------------------------------------------------------------------------
-class ValueConvertReferenceTypeError extends Error {
+class ValueConvertUnknownTypeError extends Error {
     constructor(schema) {
-        super(`ValueConvert: Cannot locate referenced schema with $id '${schema.$ref}'`);
+        super('ValueConvert: Unknown type');
         this.schema = schema;
     }
 }
-exports.ValueConvertReferenceTypeError = ValueConvertReferenceTypeError;
-class ValueConvertUnknownTypeError extends Error {
+exports.ValueConvertUnknownTypeError = ValueConvertUnknownTypeError;
+class ValueConvertDereferenceError extends Error {
     constructor(schema) {
-        super('ValueConvert: Unknown type');
+        super(`ValueConvert: Unable to dereference schema with $id '${schema.$ref}'`);
         this.schema = schema;
     }
 }
-exports.ValueConvertUnknownTypeError = ValueConvertUnknownTypeError;
+exports.ValueConvertDereferenceError = ValueConvertDereferenceError;
 var ValueConvert;
 (function (ValueConvert) {
     // ----------------------------------------------------------------------------------------------
@@ -183,163 +183,172 @@ var ValueConvert;
     // ----------------------------------------------------------------------------------------------
     // Cast
     // ----------------------------------------------------------------------------------------------
-    function Any(schema, value) {
+    function Any(schema, references, value) {
         return value;
     }
-    function Array(schema, value) {
+    function Array(schema, references, value) {
         if (IsArray(value)) {
-            return value.map((value) => Visit(schema.items, value));
+            return value.map((value) => Visit(schema.items, references, value));
         }
         return value;
     }
-    function BigInt(schema, value) {
+    function BigInt(schema, references, value) {
         return TryConvertBigInt(value);
     }
-    function Boolean(schema, value) {
+    function Boolean(schema, references, value) {
         return TryConvertBoolean(value);
     }
-    function Constructor(schema, value) {
+    function Constructor(schema, references, value) {
         return clone_1.ValueClone.Clone(value);
     }
-    function Date(schema, value) {
+    function Date(schema, references, value) {
         return TryConvertDate(value);
     }
-    function Function(schema, value) {
+    function Function(schema, references, value) {
         return value;
     }
-    function Integer(schema, value) {
+    function Integer(schema, references, value) {
         return TryConvertInteger(value);
     }
-    function Intersect(schema, value) {
+    function Intersect(schema, references, value) {
         return value;
     }
-    function Literal(schema, value) {
+    function Literal(schema, references, value) {
         return TryConvertLiteral(schema, value);
     }
-    function Never(schema, value) {
+    function Never(schema, references, value) {
         return value;
     }
-    function Null(schema, value) {
+    function Null(schema, references, value) {
         return TryConvertNull(value);
     }
-    function Number(schema, value) {
+    function Number(schema, references, value) {
         return TryConvertNumber(value);
     }
-    function Object(schema, value) {
+    function Object(schema, references, value) {
         if (IsObject(value))
             return globalThis.Object.keys(schema.properties).reduce((acc, key) => {
-                return value[key] !== undefined ? { ...acc, [key]: Visit(schema.properties[key], value[key]) } : { ...acc };
+                return value[key] !== undefined ? { ...acc, [key]: Visit(schema.properties[key], references, value[key]) } : { ...acc };
             }, value);
         return value;
     }
-    function Promise(schema, value) {
+    function Promise(schema, references, value) {
         return value;
     }
-    function Record(schema, value) {
+    function Record(schema, references, value) {
         return value;
     }
-    function Ref(schema, value) {
-        return Visit(Types.ReferenceRegistry.DerefOne(schema), value);
-    }
-    function Self(schema, value) {
-        return Visit(Types.ReferenceRegistry.DerefOne(schema), value);
-    }
-    function String(schema, value) {
+    function Ref(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueConvertDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
+    function Self(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueConvertDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
+    }
+    function String(schema, references, value) {
         return TryConvertString(value);
     }
-    function Symbol(schema, value) {
+    function Symbol(schema, references, value) {
         return value;
     }
-    function Tuple(schema, value) {
+    function Tuple(schema, references, value) {
         if (IsArray(value) && schema.items !== undefined) {
             return value.map((value, index) => {
-                return index < schema.items.length ? Visit(schema.items[index], value) : value;
+                return index < schema.items.length ? Visit(schema.items[index], references, value) : value;
             });
         }
         return value;
     }
-    function Undefined(schema, value) {
+    function Undefined(schema, references, value) {
         return TryConvertUndefined(value);
     }
-    function Union(schema, value) {
+    function Union(schema, references, value) {
         return value;
     }
-    function Uint8Array(schema, value) {
+    function Uint8Array(schema, references, value) {
         return value;
     }
-    function Unknown(schema, value) {
+    function Unknown(schema, references, value) {
         return value;
     }
-    function Void(schema, value) {
+    function Void(schema, references, value) {
         return value;
     }
-    function UserDefined(schema, value) {
+    function UserDefined(schema, references, value) {
         return value;
     }
-    function Visit(schema, value) {
-        const anySchema = schema;
+    function Visit(schema, references, value) {
+        const references_ = IsString(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
         switch (schema[Types.Kind]) {
             case 'Any':
-                return Any(anySchema, value);
+                return Any(schema_, references_, value);
             case 'Array':
-                return Array(anySchema, value);
+                return Array(schema_, references_, value);
             case 'BigInt':
-                return BigInt(anySchema, value);
+                return BigInt(schema_, references_, value);
             case 'Boolean':
-                return Boolean(anySchema, value);
+                return Boolean(schema_, references_, value);
             case 'Constructor':
-                return Constructor(anySchema, value);
+                return Constructor(schema_, references_, value);
             case 'Date':
-                return Date(anySchema, value);
+                return Date(schema_, references_, value);
             case 'Function':
-                return Function(anySchema, value);
+                return Function(schema_, references_, value);
             case 'Integer':
-                return Integer(anySchema, value);
+                return Integer(schema_, references_, value);
             case 'Intersect':
-                return Intersect(anySchema, value);
+                return Intersect(schema_, references_, value);
             case 'Literal':
-                return Literal(anySchema, value);
+                return Literal(schema_, references_, value);
             case 'Never':
-                return Never(anySchema, value);
+                return Never(schema_, references_, value);
             case 'Null':
-                return Null(anySchema, value);
+                return Null(schema_, references_, value);
             case 'Number':
-                return Number(anySchema, value);
+                return Number(schema_, references_, value);
             case 'Object':
-                return Object(anySchema, value);
+                return Object(schema_, references_, value);
             case 'Promise':
-                return Promise(anySchema, value);
+                return Promise(schema_, references_, value);
             case 'Record':
-                return Record(anySchema, value);
+                return Record(schema_, references_, value);
             case 'Ref':
-                return Ref(anySchema, value);
+                return Ref(schema_, references_, value);
             case 'Self':
-                return Self(anySchema, value);
+                return Self(schema_, references_, value);
             case 'String':
-                return String(anySchema, value);
+                return String(schema_, references_, value);
             case 'Symbol':
-                return Symbol(anySchema, value);
+                return Symbol(schema_, references_, value);
             case 'Tuple':
-                return Tuple(anySchema, value);
+                return Tuple(schema_, references_, value);
             case 'Undefined':
-                return Undefined(anySchema, value);
+                return Undefined(schema_, references_, value);
             case 'Union':
-                return Union(anySchema, value);
+                return Union(schema_, references_, value);
             case 'Uint8Array':
-                return Uint8Array(anySchema, value);
+                return Uint8Array(schema_, references_, value);
             case 'Unknown':
-                return Unknown(anySchema, value);
+                return Unknown(schema_, references_, value);
             case 'Void':
-                return Void(anySchema, value);
+                return Void(schema_, references_, value);
             default:
-                if (!Types.TypeRegistry.Has(anySchema[Types.Kind]))
-                    throw new ValueConvertUnknownTypeError(anySchema);
-                return UserDefined(anySchema, value);
+                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                    throw new ValueConvertUnknownTypeError(schema_);
+                return UserDefined(schema_, references_, value);
         }
     }
     ValueConvert.Visit = Visit;
-    function Convert(schema, value) {
-        return Visit(schema, clone_1.ValueClone.Clone(value));
+    function Convert(schema, references, value) {
+        return Visit(schema, references, clone_1.ValueClone.Clone(value));
     }
     ValueConvert.Convert = Convert;
 })(ValueConvert = exports.ValueConvert || (exports.ValueConvert = {}));

package/value/create.d.ts

@@ -11,8 +11,12 @@ export declare class ValueCreateIntersectTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare class ValueCreateDereferenceError extends Error {
+    readonly schema: Types.TRef | Types.TSelf;
+    constructor(schema: Types.TRef | Types.TSelf);
+}
 export declare namespace ValueCreate {
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-    function Visit<T extends Types.TSchema>(schema: T): Types.Static<T>;
-    function Create<T extends Types.TSchema>(schema: T): Types.Static<T>;
+    function Visit(schema: Types.TSchema, references: Types.TSchema[]): unknown;
+    function Create<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): Types.Static<T>;
 }