@sinclair/typebox 0.25.23 → 0.26.0-dev

package/value/create.js

@@ -27,9 +27,12 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+exports.ValueCreate = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
 const Types = require("../typebox");
-const index_1 = require("../custom/index");
+const check_1 = require("./check");
+// --------------------------------------------------------------------------
+// Errors
+// --------------------------------------------------------------------------
 class ValueCreateUnknownTypeError extends Error {
     constructor(schema) {
         super('ValueCreate: Unknown type');
@@ -44,46 +47,64 @@ class ValueCreateNeverTypeError extends Error {
     }
 }
 exports.ValueCreateNeverTypeError = ValueCreateNeverTypeError;
+class ValueCreateIntersectTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Can only create values for intersected objects and non-varying primitive types. Consider using a default value.');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateIntersectTypeError = ValueCreateIntersectTypeError;
+// --------------------------------------------------------------------------
+// ValueCreate
+// --------------------------------------------------------------------------
 var ValueCreate;
 (function (ValueCreate) {
-    function Any(schema, references) {
-        if (schema.default !== undefined) {
+    function Any(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
             return {};
         }
     }
-    function Array(schema, references) {
+    function Array(schema) {
         if (schema.uniqueItems === true && schema.default === undefined) {
             throw new Error('ValueCreate.Array: Arrays with uniqueItems require a default value');
         }
-        else if (schema.default !== undefined) {
+        else if ('default' in schema) {
             return schema.default;
         }
         else if (schema.minItems !== undefined) {
             return globalThis.Array.from({ length: schema.minItems }).map((item) => {
-                return ValueCreate.Create(schema.items, references);
+                return ValueCreate.Create(schema.items);
             });
         }
         else {
             return [];
         }
     }
-    function Boolean(schema, references) {
-        if (schema.default !== undefined) {
+    function BigInt(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return globalThis.BigInt(0);
+        }
+    }
+    function Boolean(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
             return false;
         }
     }
-    function Constructor(schema, references) {
-        if (schema.default !== undefined) {
+    function Constructor(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
-            const value = ValueCreate.Create(schema.returns, references);
+            const value = ValueCreate.Create(schema.returns);
             if (typeof value === 'object' && !globalThis.Array.isArray(value)) {
                 return class {
                     constructor() {
@@ -100,8 +121,8 @@ var ValueCreate;
             }
         }
     }
-    function Date(schema, references) {
-        if (schema.default !== undefined) {
+    function Date(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else if (schema.minimumTimestamp !== undefined) {
@@ -111,16 +132,16 @@ var ValueCreate;
             return new globalThis.Date(0);
         }
     }
-    function Function(schema, references) {
-        if (schema.default !== undefined) {
+    function Function(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
-            return () => ValueCreate.Create(schema.returns, references);
+            return () => ValueCreate.Create(schema.returns);
         }
     }
-    function Integer(schema, references) {
-        if (schema.default !== undefined) {
+    function Integer(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else if (schema.minimum !== undefined) {
@@ -130,27 +151,46 @@ var ValueCreate;
             return 0;
         }
     }
-    function Literal(schema, references) {
-        if (schema.default !== undefined) {
+    function Intersect(schema) {
+        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))
+                throw new ValueCreateIntersectTypeError(schema);
+            return value;
+        }
+    }
+    function Literal(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
             return schema.const;
         }
     }
-    function Never(schema, references) {
+    function Never(schema) {
         throw new ValueCreateNeverTypeError(schema);
     }
-    function Null(schema, references) {
-        if (schema.default !== undefined) {
+    function Not(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else {
+            return Visit(schema.allOf[1]);
+        }
+    }
+    function Null(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
             return null;
         }
     }
-    function Number(schema, references) {
-        if (schema.default !== undefined) {
+    function Number(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else if (schema.minimum !== undefined) {
@@ -160,74 +200,60 @@ var ValueCreate;
             return 0;
         }
     }
-    function Object(schema, references) {
-        if (schema.default !== undefined) {
+    function Object(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
             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, references) } : { ...acc };
+                    return required.has(key) ? { ...acc, [key]: ValueCreate.Create(schema) } : { ...acc };
                 }, {}));
         }
     }
-    function Promise(schema, references) {
-        if (schema.default !== undefined) {
+    function Promise(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
-            return globalThis.Promise.resolve(ValueCreate.Create(schema.item, references));
+            return globalThis.Promise.resolve(ValueCreate.Create(schema.item));
         }
     }
-    function Record(schema, references) {
+    function Record(schema) {
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-        if (schema.default !== undefined) {
+        if ('default' in schema) {
             return schema.default;
         }
         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, references) };
+                return { ...acc, [key]: Create(valueSchema) };
             }, {});
         }
         else {
             return {};
         }
     }
-    function Recursive(schema, references) {
-        if (schema.default !== undefined) {
-            return schema.default;
-        }
-        else {
-            throw new Error('ValueCreate.Recursive: Recursive types require a default value');
-        }
-    }
-    function Ref(schema, references) {
-        if (schema.default !== undefined) {
+    function Ref(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
-            const reference = references.find((reference) => reference.$id === schema.$ref);
-            if (reference === undefined)
-                throw new Error(`ValueCreate.Ref: Cannot find schema with $id '${schema.$ref}'.`);
-            return Visit(reference, references);
+            return Visit(Types.ReferenceRegistry.DerefOne(schema));
         }
     }
-    function Self(schema, references) {
-        if (schema.default !== undefined) {
+    function Self(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
-            const reference = references.find((reference) => reference.$id === schema.$ref);
-            if (reference === undefined)
-                throw new Error(`ValueCreate.Self: Cannot locate schema with $id '${schema.$ref}'`);
-            return Visit(reference, references);
+            return Visit(Types.ReferenceRegistry.DerefOne(schema));
         }
     }
-    function String(schema, references) {
+    function String(schema) {
         if (schema.pattern !== undefined) {
-            if (schema.default === undefined) {
+            if (!('default' in schema)) {
                 throw new Error('ValueCreate.String: String types with patterns must specify a default value');
             }
             else {
@@ -235,7 +261,7 @@ var ValueCreate;
             }
         }
         else if (schema.format !== undefined) {
-            if (schema.default === undefined) {
+            if (!('default' in schema)) {
                 throw new Error('ValueCreate.String: String types with formats must specify a default value');
             }
             else {
@@ -243,7 +269,7 @@ var ValueCreate;
             }
         }
         else {
-            if (schema.default !== undefined) {
+            if ('default' in schema) {
                 return schema.default;
             }
             else if (schema.minLength !== undefined) {
@@ -256,38 +282,49 @@ var ValueCreate;
             }
         }
     }
-    function Tuple(schema, references) {
-        if (schema.default !== undefined) {
+    function Symbol(schema) {
+        if ('default' in schema) {
+            return schema.default;
+        }
+        else if ('value' in schema) {
+            return globalThis.Symbol.for(schema.value);
+        }
+        else {
+            return globalThis.Symbol();
+        }
+    }
+    function Tuple(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         if (schema.items === undefined) {
             return [];
         }
         else {
-            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create(schema.items[index], references));
+            return globalThis.Array.from({ length: schema.minItems }).map((_, index) => ValueCreate.Create(schema.items[index]));
         }
     }
-    function Undefined(schema, references) {
-        if (schema.default !== undefined) {
+    function Undefined(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
             return undefined;
         }
     }
-    function Union(schema, references) {
-        if (schema.default !== undefined) {
+    function Union(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else if (schema.anyOf.length === 0) {
             throw new Error('ValueCreate.Union: Cannot create Union with zero variants');
         }
         else {
-            return ValueCreate.Create(schema.anyOf[0], references);
+            return ValueCreate.Create(schema.anyOf[0]);
         }
     }
-    function Uint8Array(schema, references) {
-        if (schema.default !== undefined) {
+    function Uint8Array(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else if (schema.minByteLength !== undefined) {
@@ -297,24 +334,24 @@ var ValueCreate;
             return new globalThis.Uint8Array(0);
         }
     }
-    function Unknown(schema, references) {
-        if (schema.default !== undefined) {
+    function Unknown(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
             return {};
         }
     }
-    function Void(schema, references) {
-        if (schema.default !== undefined) {
+    function Void(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
-            return null;
+            return void 0;
         }
     }
-    function UserDefined(schema, references) {
-        if (schema.default !== undefined) {
+    function UserDefined(schema) {
+        if ('default' in schema) {
             return schema.default;
         }
         else {
@@ -322,67 +359,72 @@ var ValueCreate;
         }
     }
     /** Creates a value from the given schema. If the schema specifies a default value, then that value is returned. */
-    function Visit(schema, references) {
-        const anyReferences = schema.$id === undefined ? references : [schema, ...references];
+    function Visit(schema) {
         const anySchema = schema;
         switch (anySchema[Types.Kind]) {
             case 'Any':
-                return Any(anySchema, anyReferences);
+                return Any(anySchema);
             case 'Array':
-                return Array(anySchema, anyReferences);
+                return Array(anySchema);
+            case 'BigInt':
+                return BigInt(anySchema);
             case 'Boolean':
-                return Boolean(anySchema, anyReferences);
+                return Boolean(anySchema);
             case 'Constructor':
-                return Constructor(anySchema, anyReferences);
+                return Constructor(anySchema);
             case 'Date':
-                return Date(anySchema, anyReferences);
+                return Date(anySchema);
             case 'Function':
-                return Function(anySchema, anyReferences);
+                return Function(anySchema);
             case 'Integer':
-                return Integer(anySchema, anyReferences);
+                return Integer(anySchema);
+            case 'Intersect':
+                return Intersect(anySchema);
             case 'Literal':
-                return Literal(anySchema, anyReferences);
+                return Literal(anySchema);
             case 'Never':
-                return Never(anySchema, anyReferences);
+                return Never(anySchema);
+            case 'Not':
+                return Not(anySchema);
             case 'Null':
-                return Null(anySchema, anyReferences);
+                return Null(anySchema);
             case 'Number':
-                return Number(anySchema, anyReferences);
+                return Number(anySchema);
             case 'Object':
-                return Object(anySchema, anyReferences);
+                return Object(anySchema);
             case 'Promise':
-                return Promise(anySchema, anyReferences);
+                return Promise(anySchema);
             case 'Record':
-                return Record(anySchema, anyReferences);
-            case 'Rec':
-                return Recursive(anySchema, anyReferences);
+                return Record(anySchema);
             case 'Ref':
-                return Ref(anySchema, anyReferences);
+                return Ref(anySchema);
             case 'Self':
-                return Self(anySchema, anyReferences);
+                return Self(anySchema);
             case 'String':
-                return String(anySchema, anyReferences);
+                return String(anySchema);
+            case 'Symbol':
+                return Symbol(anySchema);
             case 'Tuple':
-                return Tuple(anySchema, anyReferences);
+                return Tuple(anySchema);
             case 'Undefined':
-                return Undefined(anySchema, anyReferences);
+                return Undefined(anySchema);
             case 'Union':
-                return Union(anySchema, anyReferences);
+                return Union(anySchema);
             case 'Uint8Array':
-                return Uint8Array(anySchema, anyReferences);
+                return Uint8Array(anySchema);
             case 'Unknown':
-                return Unknown(anySchema, anyReferences);
+                return Unknown(anySchema);
             case 'Void':
-                return Void(anySchema, anyReferences);
+                return Void(anySchema);
             default:
-                if (!index_1.Custom.Has(anySchema[Types.Kind]))
+                if (!Types.TypeRegistry.Has(anySchema[Types.Kind]))
                     throw new ValueCreateUnknownTypeError(anySchema);
-                return UserDefined(anySchema, anyReferences);
+                return UserDefined(anySchema);
         }
     }
     ValueCreate.Visit = Visit;
-    function Create(schema, references) {
-        return Visit(schema, references);
+    function Create(schema) {
+        return Visit(schema);
     }
     ValueCreate.Create = Create;
 })(ValueCreate = exports.ValueCreate || (exports.ValueCreate = {}));

package/{hash → value}/hash.js

@@ -48,6 +48,8 @@ var ValueHash;
         ByteMarker[ByteMarker["Array"] = 6] = "Array";
         ByteMarker[ByteMarker["Date"] = 7] = "Date";
         ByteMarker[ByteMarker["Uint8Array"] = 8] = "Uint8Array";
+        ByteMarker[ByteMarker["Symbol"] = 9] = "Symbol";
+        ByteMarker[ByteMarker["BigInt"] = 10] = "BigInt";
     })(ByteMarker || (ByteMarker = {}));
     // ----------------------------------------------------
     // State
@@ -79,6 +81,12 @@ var ValueHash;
     function IsNumber(value) {
         return typeof value === 'number';
     }
+    function IsSymbol(value) {
+        return typeof value === 'symbol';
+    }
+    function IsBigInt(value) {
+        return typeof value === 'bigint';
+    }
     function IsObject(value) {
         return typeof value === 'object' && value !== null && !IsArray(value) && !IsDate(value) && !IsUint8Array(value);
     }
@@ -92,50 +100,61 @@ var ValueHash;
     // Encoding
     // ----------------------------------------------------
     function Array(value) {
-        Fnv1A64(ByteMarker.Array);
+        FNV1A64(ByteMarker.Array);
         for (const item of value) {
             Visit(item);
         }
     }
     function Boolean(value) {
-        Fnv1A64(ByteMarker.Boolean);
-        Fnv1A64(value ? 1 : 0);
+        FNV1A64(ByteMarker.Boolean);
+        FNV1A64(value ? 1 : 0);
+    }
+    function BigInt(value) {
+        FNV1A64(ByteMarker.BigInt);
+        F64In.setBigInt64(0, value);
+        for (const byte of F64Out) {
+            FNV1A64(byte);
+        }
     }
     function Date(value) {
-        Fnv1A64(ByteMarker.Date);
+        FNV1A64(ByteMarker.Date);
         Visit(value.getTime());
     }
     function Null(value) {
-        Fnv1A64(ByteMarker.Null);
+        FNV1A64(ByteMarker.Null);
     }
     function Number(value) {
-        Fnv1A64(ByteMarker.Number);
+        FNV1A64(ByteMarker.Number);
         F64In.setFloat64(0, value);
         for (const byte of F64Out) {
-            Fnv1A64(byte);
+            FNV1A64(byte);
         }
     }
     function Object(value) {
-        Fnv1A64(ByteMarker.Object);
+        FNV1A64(ByteMarker.Object);
         for (const key of globalThis.Object.keys(value).sort()) {
             Visit(key);
             Visit(value[key]);
         }
     }
     function String(value) {
-        Fnv1A64(ByteMarker.String);
+        FNV1A64(ByteMarker.String);
         for (let i = 0; i < value.length; i++) {
-            Fnv1A64(value.charCodeAt(i));
+            FNV1A64(value.charCodeAt(i));
         }
     }
+    function Symbol(value) {
+        FNV1A64(ByteMarker.Symbol);
+        Visit(value.description);
+    }
     function Uint8Array(value) {
-        Fnv1A64(ByteMarker.Uint8Array);
+        FNV1A64(ByteMarker.Uint8Array);
         for (let i = 0; i < value.length; i++) {
-            Fnv1A64(value[i]);
+            FNV1A64(value[i]);
         }
     }
     function Undefined(value) {
-        return Fnv1A64(ByteMarker.Undefined);
+        return FNV1A64(ByteMarker.Undefined);
     }
     function Visit(value) {
         if (IsArray(value)) {
@@ -144,6 +163,9 @@ var ValueHash;
         else if (IsBoolean(value)) {
             Boolean(value);
         }
+        else if (IsBigInt(value)) {
+            BigInt(value);
+        }
         else if (IsDate(value)) {
             Date(value);
         }
@@ -159,6 +181,9 @@ var ValueHash;
         else if (IsString(value)) {
             String(value);
         }
+        else if (IsSymbol(value)) {
+            Symbol(value);
+        }
         else if (IsUint8Array(value)) {
             Uint8Array(value);
         }
@@ -169,7 +194,7 @@ var ValueHash;
             throw new ValueHashError(value);
         }
     }
-    function Fnv1A64(byte) {
+    function FNV1A64(byte) {
         Hash = Hash ^ Bytes[byte];
         Hash = (Hash * Prime) % Size;
     }

package/value/index.d.ts

@@ -1,4 +1,5 @@
 export { ValueError, ValueErrorType } from '../errors/index';
+export { ValueHash } from './hash';
 export { Edit, Insert, Update, Delete } from './delta';
 export * from './pointer';
 export * from './value';

package/value/index.js

@@ -41,9 +41,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Delete = exports.Update = exports.Insert = exports.Edit = exports.ValueErrorType = void 0;
+exports.Delete = exports.Update = exports.Insert = exports.Edit = exports.ValueHash = exports.ValueErrorType = void 0;
 var index_1 = require("../errors/index");
 Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
+var hash_1 = require("./hash");
+Object.defineProperty(exports, "ValueHash", { enumerable: true, get: function () { return hash_1.ValueHash; } });
 var delta_1 = require("./delta");
 Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return delta_1.Edit; } });
 Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return delta_1.Insert; } });

package/value/value.d.ts

@@ -3,23 +3,17 @@ 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;
     /** 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, 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;