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

package/value/cast.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCast = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = exports.ValueCastReferenceTypeError = void 0;
+exports.ValueCast = exports.ValueCastDereferenceError = exports.ValueCastUnknownTypeError = exports.ValueCastRecursiveTypeError = exports.ValueCastNeverTypeError = exports.ValueCastArrayUniqueItemsTypeError = exports.ValueCastReferenceTypeError = void 0;
 const Types = require("../typebox");
 const create_1 = require("./create");
 const check_1 = require("./check");
@@ -71,6 +71,13 @@ class ValueCastUnknownTypeError extends Error {
     }
 }
 exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
+class ValueCastDereferenceError extends Error {
+    constructor(schema) {
+        super(`ValueCast: Unable to dereference schema with $id '${schema.$ref}'`);
+        this.schema = schema;
+    }
+}
+exports.ValueCastDereferenceError = ValueCastDereferenceError;
 // ----------------------------------------------------------------------------------------------
 // The following will score a schema against a value. For objects, the score is the tally of
 // points awarded for each property of the value. Property points are (1.0 / propertyCount)
@@ -79,7 +86,7 @@ exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
 // ----------------------------------------------------------------------------------------------
 var UnionCastCreate;
 (function (UnionCastCreate) {
-    function Score(schema, value) {
+    function Score(schema, references, value) {
         if (schema[Types.Kind] === 'Object' && typeof value === 'object' && value !== null) {
             const object = schema;
             const keys = Object.keys(value);
@@ -87,19 +94,19 @@ var UnionCastCreate;
             const [point, max] = [1 / entries.length, entries.length];
             return entries.reduce((acc, [key, schema]) => {
                 const literal = schema[Types.Kind] === 'Literal' && schema.const === value[key] ? max : 0;
-                const checks = check_1.ValueCheck.Check(schema, value[key]) ? point : 0;
+                const checks = check_1.ValueCheck.Check(schema, references, value[key]) ? point : 0;
                 const exists = keys.includes(key) ? point : 0;
                 return acc + (literal + checks + exists);
             }, 0);
         }
         else {
-            return check_1.ValueCheck.Check(schema, value) ? 1 : 0;
+            return check_1.ValueCheck.Check(schema, references, value) ? 1 : 0;
         }
     }
-    function Select(union, value) {
+    function Select(union, references, value) {
         let [select, best] = [union.anyOf[0], 0];
         for (const schema of union.anyOf) {
-            const score = Score(schema, value);
+            const score = Score(schema, references, value);
             if (score > best) {
                 select = schema;
                 best = score;
@@ -107,13 +114,13 @@ var UnionCastCreate;
         }
         return select;
     }
-    function Create(union, value) {
+    function Create(union, references, value) {
         if (union.default !== undefined) {
             return union.default;
         }
         else {
-            const schema = Select(union, value);
-            return ValueCast.Cast(schema, value);
+            const schema = Select(union, references, value);
+            return ValueCast.Cast(schema, references, value);
         }
     }
     UnionCastCreate.Create = Create;
@@ -132,84 +139,87 @@ var ValueCast;
     function IsNumber(value) {
         return typeof value === 'number' && !isNaN(value);
     }
+    function IsString(value) {
+        return typeof value === 'string';
+    }
     // ----------------------------------------------------------------------------------------------
     // Cast
     // ----------------------------------------------------------------------------------------------
-    function Any(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
+    function Any(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
-    function Array(schema, value) {
-        if (check_1.ValueCheck.Check(schema, value))
+    function Array(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
             return clone_1.ValueClone.Clone(value);
-        const created = IsArray(value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
+        const created = IsArray(value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
         const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...globalThis.Array.from({ length: schema.minItems - created.length }, () => null)] : created;
         const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
-        const casted = maximum.map((value) => Visit(schema.items, value));
+        const casted = maximum.map((value) => Visit(schema.items, references, value));
         if (schema.uniqueItems !== true)
             return casted;
         const unique = [...new Set(casted)];
-        if (!check_1.ValueCheck.Check(schema, unique))
+        if (!check_1.ValueCheck.Check(schema, references, unique))
             throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
         return unique;
     }
-    function BigInt(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
+    function BigInt(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
-    function Boolean(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
+    function Boolean(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
-    function Constructor(schema, value) {
-        if (check_1.ValueCheck.Check(schema, value))
-            return create_1.ValueCreate.Create(schema);
+    function Constructor(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
+            return create_1.ValueCreate.Create(schema, references);
         const required = new Set(schema.returns.required || []);
         const result = function () { };
         for (const [key, property] of globalThis.Object.entries(schema.returns.properties)) {
             if (!required.has(key) && value.prototype[key] === undefined)
                 continue;
-            result.prototype[key] = Visit(property, value.prototype[key]);
+            result.prototype[key] = Visit(property, references, value.prototype[key]);
         }
         return result;
     }
-    function Date(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
+    function Date(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
-    function Function(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
+    function Function(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
-    function Integer(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
+    function Integer(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
-    function Intersect(schema, value) {
-        const created = create_1.ValueCreate.Create(schema);
+    function Intersect(schema, references, value) {
+        const created = create_1.ValueCreate.Create(schema, references);
         const mapped = IsObject(created) && IsObject(value) ? { ...created, ...value } : value;
-        return check_1.ValueCheck.Check(schema, mapped) ? mapped : create_1.ValueCreate.Create(schema);
+        return check_1.ValueCheck.Check(schema, references, mapped) ? mapped : create_1.ValueCreate.Create(schema, references);
     }
-    function Literal(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
+    function Literal(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
-    function Never(schema, value) {
+    function Never(schema, references, value) {
         throw new ValueCastNeverTypeError(schema);
     }
-    function Not(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema.allOf[1]);
+    function Not(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema.allOf[1], references);
     }
-    function Null(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
+    function Null(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
-    function Number(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
+    function Number(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
-    function Object(schema, value) {
-        if (check_1.ValueCheck.Check(schema, value))
+    function Object(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
             return value;
         if (value === null || typeof value !== 'object')
-            return create_1.ValueCreate.Create(schema);
+            return create_1.ValueCreate.Create(schema, references);
         const required = new Set(schema.required || []);
         const result = {};
         for (const [key, property] of globalThis.Object.entries(schema.properties)) {
             if (!required.has(key) && value[key] === undefined)
                 continue;
-            result[key] = Visit(property, value[key]);
+            result[key] = Visit(property, references, value[key]);
         }
         // additional schema properties
         if (typeof schema.additionalProperties === 'object') {
@@ -217,132 +227,141 @@ var ValueCast;
             for (const propertyName of globalThis.Object.getOwnPropertyNames(value)) {
                 if (propertyNames.includes(propertyName))
                     continue;
-                result[propertyName] = Visit(schema.additionalProperties, value[propertyName]);
+                result[propertyName] = Visit(schema.additionalProperties, references, value[propertyName]);
             }
         }
         return result;
     }
-    function Promise(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
+    function Promise(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
-    function Record(schema, value) {
-        if (check_1.ValueCheck.Check(schema, value))
+    function Record(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
             return clone_1.ValueClone.Clone(value);
         if (value === null || typeof value !== 'object' || globalThis.Array.isArray(value) || value instanceof globalThis.Date)
-            return create_1.ValueCreate.Create(schema);
+            return create_1.ValueCreate.Create(schema, references);
         const subschemaPropertyName = globalThis.Object.getOwnPropertyNames(schema.patternProperties)[0];
         const subschema = schema.patternProperties[subschemaPropertyName];
         const result = {};
         for (const [propKey, propValue] of globalThis.Object.entries(value)) {
-            result[propKey] = Visit(subschema, propValue);
+            result[propKey] = Visit(subschema, references, propValue);
         }
         return result;
     }
-    function Ref(schema, value) {
-        return Visit(Types.ReferenceRegistry.DerefOne(schema), value);
+    function Ref(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueCastDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
     }
-    function Self(schema, value) {
-        return Visit(Types.ReferenceRegistry.DerefOne(schema), value);
+    function Self(schema, references, value) {
+        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
+        if (index === -1)
+            throw new ValueCastDereferenceError(schema);
+        const target = references[index];
+        return Visit(target, references, value);
     }
-    function String(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? value : create_1.ValueCreate.Create(schema);
+    function String(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
-    function Symbol(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
+    function Symbol(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
-    function Tuple(schema, value) {
-        if (check_1.ValueCheck.Check(schema, value))
+    function Tuple(schema, references, value) {
+        if (check_1.ValueCheck.Check(schema, references, value))
             return clone_1.ValueClone.Clone(value);
         if (!globalThis.Array.isArray(value))
-            return create_1.ValueCreate.Create(schema);
+            return create_1.ValueCreate.Create(schema, references);
         if (schema.items === undefined)
             return [];
-        return schema.items.map((schema, index) => Visit(schema, value[index]));
+        return schema.items.map((schema, index) => Visit(schema, references, value[index]));
     }
-    function Undefined(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
+    function Undefined(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
-    function Union(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : UnionCastCreate.Create(schema, value);
+    function Union(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : UnionCastCreate.Create(schema, references, value);
     }
-    function Uint8Array(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
+    function Uint8Array(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
-    function Unknown(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
+    function Unknown(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
-    function Void(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
+    function Void(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
-    function UserDefined(schema, value) {
-        return check_1.ValueCheck.Check(schema, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema);
+    function UserDefined(schema, references, value) {
+        return check_1.ValueCheck.Check(schema, references, value) ? clone_1.ValueClone.Clone(value) : create_1.ValueCreate.Create(schema, references);
     }
-    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 'Not':
-                return Not(anySchema, value);
+                return Not(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 ValueCastUnknownTypeError(anySchema);
-                return UserDefined(anySchema, value);
+                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+                    throw new ValueCastUnknownTypeError(schema_);
+                return UserDefined(schema_, references_, value);
         }
     }
     ValueCast.Visit = Visit;
-    function Cast(schema, value) {
-        return Visit(schema, clone_1.ValueClone.Clone(value));
+    function Cast(schema, references, value) {
+        return Visit(schema, references, clone_1.ValueClone.Clone(value));
     }
     ValueCast.Cast = Cast;
 })(ValueCast = exports.ValueCast || (exports.ValueCast = {}));

package/value/check.d.ts

@@ -3,6 +3,10 @@ export declare class ValueCheckUnknownTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare class ValueCheckDereferenceError extends Error {
+    readonly schema: Types.TRef | Types.TSelf;
+    constructor(schema: Types.TRef | Types.TSelf);
+}
 export declare namespace ValueCheck {
-    function Check<T extends Types.TSchema>(schema: T, value: any): boolean;
+    function Check<T extends Types.TSchema>(schema: T, references: Types.TSchema[], value: any): boolean;
 }