@sinclair/typebox 0.32.0-dev-23 → 0.32.0-dev-25

package/build/require/errors/errors.js

@@ -7,15 +7,16 @@ const index_2 = require("../type/keyof/index");
 const index_3 = require("../type/registry/index");
 const extends_undefined_1 = require("../type/extends/extends-undefined");
 const function_1 = require("./function");
-const index_4 = require("../value/deref/index");
-const index_5 = require("../value/hash/index");
-const index_6 = require("../type/symbols/index");
-const index_7 = require("../type/never/index");
+const index_4 = require("../type/error/index");
+const index_5 = require("../value/deref/index");
+const index_6 = require("../value/hash/index");
+const index_7 = require("../type/symbols/index");
+const index_8 = require("../type/never/index");
 // ------------------------------------------------------------------
 // ValueGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-const index_8 = require("../value/guard/index");
+const index_9 = require("../value/guard/index");
 // ------------------------------------------------------------------
 // ValueErrorType
 // ------------------------------------------------------------------
@@ -88,7 +89,7 @@ var ValueErrorType;
 // ------------------------------------------------------------------
 // ValueErrors
 // ------------------------------------------------------------------
-class ValueErrorsUnknownTypeError extends Error {
+class ValueErrorsUnknownTypeError extends index_4.TypeBoxError {
     constructor(schema) {
         super('Unknown type');
         this.schema = schema;
@@ -135,7 +136,7 @@ function Create(type, schema, path, value) {
 // --------------------------------------------------------------------------
 function* FromAny(schema, references, path, value) { }
 function* FromArray(schema, references, path, value) {
-    if (!(0, index_8.IsArray)(value)) {
+    if (!(0, index_9.IsArray)(value)) {
         return yield Create(ValueErrorType.Array, schema, path, value);
     }
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
@@ -149,7 +150,7 @@ function* FromArray(schema, references, path, value) {
     }
     // prettier-ignore
     if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
-        const hashed = (0, index_5.Hash)(element);
+        const hashed = (0, index_6.Hash)(element);
         if (set.has(hashed)) {
             return false;
         }
@@ -163,24 +164,24 @@ function* FromArray(schema, references, path, value) {
     if (!(IsDefined(schema.contains) || IsDefined(schema.minContains) || IsDefined(schema.maxContains))) {
         return;
     }
-    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_7.Never)();
+    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_8.Never)();
     const containsCount = value.reduce((acc, value, index) => (Visit(containsSchema, references, `${path}${index}`, value).next().done === true ? acc + 1 : acc), 0);
     if (containsCount === 0) {
         yield Create(ValueErrorType.ArrayContains, schema, path, value);
     }
-    if ((0, index_8.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
+    if ((0, index_9.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
         yield Create(ValueErrorType.ArrayMinContains, schema, path, value);
     }
-    if ((0, index_8.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
+    if ((0, index_9.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
         yield Create(ValueErrorType.ArrayMaxContains, schema, path, value);
     }
 }
 function* FromAsyncIterator(schema, references, path, value) {
-    if (!(0, index_8.IsAsyncIterator)(value))
+    if (!(0, index_9.IsAsyncIterator)(value))
         yield Create(ValueErrorType.AsyncIterator, schema, path, value);
 }
 function* FromBigInt(schema, references, path, value) {
-    if (!(0, index_8.IsBigInt)(value))
+    if (!(0, index_9.IsBigInt)(value))
         return yield Create(ValueErrorType.BigInt, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path, value);
@@ -199,14 +200,14 @@ function* FromBigInt(schema, references, path, value) {
     }
 }
 function* FromBoolean(schema, references, path, value) {
-    if (!(0, index_8.IsBoolean)(value))
+    if (!(0, index_9.IsBoolean)(value))
         yield Create(ValueErrorType.Boolean, schema, path, value);
 }
 function* FromConstructor(schema, references, path, value) {
     yield* Visit(schema.returns, references, path, value.prototype);
 }
 function* FromDate(schema, references, path, value) {
-    if (!(0, index_8.IsDate)(value))
+    if (!(0, index_9.IsDate)(value))
         return yield Create(ValueErrorType.Date, schema, path, value);
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
         yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value);
@@ -225,11 +226,11 @@ function* FromDate(schema, references, path, value) {
     }
 }
 function* FromFunction(schema, references, path, value) {
-    if (!(0, index_8.IsFunction)(value))
+    if (!(0, index_9.IsFunction)(value))
         yield Create(ValueErrorType.Function, schema, path, value);
 }
 function* FromInteger(schema, references, path, value) {
-    if (!(0, index_8.IsInteger)(value))
+    if (!(0, index_9.IsInteger)(value))
         return yield Create(ValueErrorType.Integer, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path, value);
@@ -275,7 +276,7 @@ function* FromIntersect(schema, references, path, value) {
     }
 }
 function* FromIterator(schema, references, path, value) {
-    if (!(0, index_8.IsIterator)(value))
+    if (!(0, index_9.IsIterator)(value))
         yield Create(ValueErrorType.Iterator, schema, path, value);
 }
 function* FromLiteral(schema, references, path, value) {
@@ -290,7 +291,7 @@ function* FromNot(schema, references, path, value) {
         yield Create(ValueErrorType.Not, schema, path, value);
 }
 function* FromNull(schema, references, path, value) {
-    if (!(0, index_8.IsNull)(value))
+    if (!(0, index_9.IsNull)(value))
         yield Create(ValueErrorType.Null, schema, path, value);
 }
 function* FromNumber(schema, references, path, value) {
@@ -359,7 +360,7 @@ function* FromObject(schema, references, path, value) {
     }
 }
 function* FromPromise(schema, references, path, value) {
-    if (!(0, index_8.IsPromise)(value))
+    if (!(0, index_9.IsPromise)(value))
         yield Create(ValueErrorType.Promise, schema, path, value);
 }
 function* FromRecord(schema, references, path, value) {
@@ -392,10 +393,10 @@ function* FromRecord(schema, references, path, value) {
     }
 }
 function* FromRef(schema, references, path, value) {
-    yield* Visit((0, index_4.Deref)(schema, references), references, path, value);
+    yield* Visit((0, index_5.Deref)(schema, references), references, path, value);
 }
 function* FromString(schema, references, path, value) {
-    if (!(0, index_8.IsString)(value))
+    if (!(0, index_9.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) {
         yield Create(ValueErrorType.StringMinLength, schema, path, value);
@@ -403,13 +404,13 @@ function* FromString(schema, references, path, value) {
     if (IsDefined(schema.maxLength) && !(value.length <= schema.maxLength)) {
         yield Create(ValueErrorType.StringMaxLength, schema, path, value);
     }
-    if ((0, index_8.IsString)(schema.pattern)) {
+    if ((0, index_9.IsString)(schema.pattern)) {
         const regex = new RegExp(schema.pattern);
         if (!regex.test(value)) {
             yield Create(ValueErrorType.StringPattern, schema, path, value);
         }
     }
-    if ((0, index_8.IsString)(schema.format)) {
+    if ((0, index_9.IsString)(schema.format)) {
         if (!index_3.FormatRegistry.Has(schema.format)) {
             yield Create(ValueErrorType.StringFormatUnknown, schema, path, value);
         }
@@ -422,11 +423,11 @@ function* FromString(schema, references, path, value) {
     }
 }
 function* FromSymbol(schema, references, path, value) {
-    if (!(0, index_8.IsSymbol)(value))
+    if (!(0, index_9.IsSymbol)(value))
         yield Create(ValueErrorType.Symbol, schema, path, value);
 }
 function* FromTemplateLiteral(schema, references, path, value) {
-    if (!(0, index_8.IsString)(value))
+    if (!(0, index_9.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     const regex = new RegExp(schema.pattern);
     if (!regex.test(value)) {
@@ -434,10 +435,10 @@ function* FromTemplateLiteral(schema, references, path, value) {
     }
 }
 function* FromThis(schema, references, path, value) {
-    yield* Visit((0, index_4.Deref)(schema, references), references, path, value);
+    yield* Visit((0, index_5.Deref)(schema, references), references, path, value);
 }
 function* FromTuple(schema, references, path, value) {
-    if (!(0, index_8.IsArray)(value))
+    if (!(0, index_9.IsArray)(value))
         return yield Create(ValueErrorType.Tuple, schema, path, value);
     if (schema.items === undefined && !(value.length === 0)) {
         return yield Create(ValueErrorType.TupleLength, schema, path, value);
@@ -453,7 +454,7 @@ function* FromTuple(schema, references, path, value) {
     }
 }
 function* FromUndefined(schema, references, path, value) {
-    if (!(0, index_8.IsUndefined)(value))
+    if (!(0, index_9.IsUndefined)(value))
         yield Create(ValueErrorType.Undefined, schema, path, value);
 }
 function* FromUnion(schema, references, path, value) {
@@ -469,7 +470,7 @@ function* FromUnion(schema, references, path, value) {
     }
 }
 function* FromUint8Array(schema, references, path, value) {
-    if (!(0, index_8.IsUint8Array)(value))
+    if (!(0, index_9.IsUint8Array)(value))
         return yield Create(ValueErrorType.Uint8Array, schema, path, value);
     if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
         yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value);
@@ -484,14 +485,14 @@ function* FromVoid(schema, references, path, value) {
         yield Create(ValueErrorType.Void, schema, path, value);
 }
 function* FromKind(schema, references, path, value) {
-    const check = index_3.TypeRegistry.Get(schema[index_6.Kind]);
+    const check = index_3.TypeRegistry.Get(schema[index_7.Kind]);
     if (!check(schema, value))
         yield Create(ValueErrorType.Kind, schema, path, value);
 }
 function* Visit(schema, references, path, value) {
     const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
-    switch (schema_[index_6.Kind]) {
+    switch (schema_[index_7.Kind]) {
         case 'Any':
             return yield* FromAny(schema_, references_, path, value);
         case 'Array':
@@ -553,7 +554,7 @@ function* Visit(schema, references, path, value) {
         case 'Void':
             return yield* FromVoid(schema_, references_, path, value);
         default:
-            if (!index_3.TypeRegistry.Has(schema_[index_6.Kind]))
+            if (!index_3.TypeRegistry.Has(schema_[index_7.Kind]))
                 throw new ValueErrorsUnknownTypeError(schema);
             return yield* FromKind(schema_, references_, path, value);
     }

package/build/require/index.d.ts

@@ -3,6 +3,7 @@ export { PatternBoolean, PatternBooleanExact, PatternNumber, PatternNumberExact,
 export { TypeRegistry, FormatRegistry } from './type/registry/index';
 export { TypeGuard, ValueGuard } from './type/guard/index';
 export { CloneType, CloneRest } from './type/clone/type';
+export { TypeBoxError } from './type/error/index';
 export { Any, type TAny } from './type/any/index';
 export { Array, type TArray, type ArrayOptions } from './type/array/index';
 export { AsyncIterator, type TAsyncIterator } from './type/async-iterator/index';
@@ -21,7 +22,7 @@ export { Extends, type TExtends, type ExtendsFromMappedResult, type ExtendsFromM
 export { Extract, type TExtract, type TExtractFromMappedResult } from './type/extract/index';
 export { Function, type TFunction } from './type/function/index';
 export { Increment, type Assert, type AssertType, type AssertRest, type AssertProperties, type Ensure, type Evaluate, type TupleToIntersect, type TupleToUnion, type UnionToTuple } from './type/helpers/index';
-export { Index, IndexPropertyKeys, IndexFromMappedKey, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey } from './type/indexed/index';
+export { Index, IndexPropertyKeys, IndexFromMappedKey, IndexFromMappedResult, type TIndex, type TIndexPropertyKeys, type TIndexFromMappedKey, type TIndexFromMappedResult } from './type/indexed/index';
 export { InstanceType, type TInstanceType } from './type/instance-type/index';
 export { Integer, type TInteger, type IntegerOptions } from './type/integer/index';
 export { Intersect, IntersectEvaluated, type TIntersect, type TIntersectEvaluated, type IntersectOptions } from './type/intersect/index';