@sinclair/typebox 0.24.39 → 0.24.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.39",
+  "version": "0.24.40",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/value/cast.d.ts

@@ -1,12 +1,25 @@
 import * as Types from '../typebox';
-export declare class ValueCastUnknownTypeError extends Error {
+export declare class ValueCastReferenceTypeError extends Error {
+    readonly schema: Types.TRef | Types.TSelf;
+    constructor(schema: Types.TRef | Types.TSelf);
+}
+export declare class ValueCastArrayUniqueItemsTypeError extends Error {
     readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
+    readonly value: unknown;
+    constructor(schema: Types.TSchema, value: unknown);
 }
 export declare class ValueCastNeverTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare class ValueCastRecursiveTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
+export declare class ValueCastUnknownTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare namespace ValueCast {
     function Visit(schema: Types.TSchema, references: Types.TSchema[], value: any): any;
     function Cast<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: any): Types.Static<T>;

package/value/cast.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCast = exports.ValueCastNeverTypeError = exports.ValueCastUnknownTypeError = void 0;
+exports.ValueCast = 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");
@@ -72,13 +72,24 @@ var UnionValueCast;
     }
     UnionValueCast.Create = Create;
 })(UnionValueCast || (UnionValueCast = {}));
-class ValueCastUnknownTypeError extends Error {
+// -----------------------------------------------------------
+// Errors
+// -----------------------------------------------------------
+class ValueCastReferenceTypeError extends Error {
     constructor(schema) {
-        super('ValueCast: Unknown type');
+        super(`ValueCast: Cannot locate referenced schema with $id '${schema.$ref}'`);
         this.schema = schema;
     }
 }
-exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
+exports.ValueCastReferenceTypeError = ValueCastReferenceTypeError;
+class ValueCastArrayUniqueItemsTypeError extends Error {
+    constructor(schema, value) {
+        super('ValueCast: Array cast produced invalid data due to uniqueItems constraint');
+        this.schema = schema;
+        this.value = value;
+    }
+}
+exports.ValueCastArrayUniqueItemsTypeError = ValueCastArrayUniqueItemsTypeError;
 class ValueCastNeverTypeError extends Error {
     constructor(schema) {
         super('ValueCast: Never types cannot be cast');
@@ -86,11 +97,28 @@ class ValueCastNeverTypeError extends Error {
     }
 }
 exports.ValueCastNeverTypeError = ValueCastNeverTypeError;
+class ValueCastRecursiveTypeError extends Error {
+    constructor(schema) {
+        super('ValueCast.Recursive: Cannot cast recursive schemas');
+        this.schema = schema;
+    }
+}
+exports.ValueCastRecursiveTypeError = ValueCastRecursiveTypeError;
+class ValueCastUnknownTypeError extends Error {
+    constructor(schema) {
+        super('ValueCast: Unknown type');
+        this.schema = schema;
+    }
+}
+exports.ValueCastUnknownTypeError = ValueCastUnknownTypeError;
 var ValueCast;
 (function (ValueCast) {
     // -----------------------------------------------------------
-    // Convert
+    // Guards
     // -----------------------------------------------------------
+    function IsArray(value) {
+        return typeof value === 'object' && globalThis.Array.isArray(value);
+    }
     function IsString(value) {
         return typeof value === 'string';
     }
@@ -115,6 +143,9 @@ var ValueCast;
     function IsValueFalse(value) {
         return value === false || (IsNumber(value) && value === 0) || (IsBigInt(value) && value === 0n) || (IsString(value) && (value.toLowerCase() === 'false' || value === '0'));
     }
+    // -----------------------------------------------------------
+    // Convert
+    // -----------------------------------------------------------
     function TryConvertString(value) {
         return IsValueToString(value) ? value.toString() : value;
     }
@@ -136,9 +167,16 @@ var ValueCast;
     function Array(schema, references, value) {
         if (check_1.ValueCheck.Check(schema, references, value))
             return value;
-        if (!globalThis.Array.isArray(value))
-            return create_1.ValueCreate.Create(schema, references);
-        return value.map((val) => Visit(schema.items, references, val));
+        const created = IsArray(value) ? 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, references, value));
+        if (schema.uniqueItems !== true)
+            return casted;
+        const unique = [...new Set(casted)];
+        if (!check_1.ValueCheck.Check(schema, references, unique))
+            throw new ValueCastArrayUniqueItemsTypeError(schema, unique);
+        return unique;
     }
     function Boolean(schema, references, value) {
         const conversion = TryConvertBoolean(value);
@@ -210,18 +248,18 @@ var ValueCast;
         return result;
     }
     function Recursive(schema, references, value) {
-        throw new Error('ValueCast.Recursive: Cannot cast recursive schemas');
+        throw new ValueCastRecursiveTypeError(schema);
     }
     function Ref(schema, references, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);
         if (reference === undefined)
-            throw new Error(`ValueCast.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+            throw new ValueCastReferenceTypeError(schema);
         return Visit(reference, references, value);
     }
     function Self(schema, references, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);
         if (reference === undefined)
-            throw new Error(`ValueCast.Self: Cannot find schema with $id '${schema.$ref}'.`);
+            throw new ValueCastReferenceTypeError(schema);
         return Visit(reference, references, value);
     }
     function String(schema, references, value) {