@sinclair/typebox 0.32.0-dev-18 → 0.32.0-dev-19

package/build/require/errors/errors.js

@@ -2,19 +2,23 @@
 
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Errors = exports.ValueErrorIterator = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
-const index_1 = require("../value/guard/index");
-const index_2 = require("../system/index");
-const index_3 = require("../type/keyof/index");
-const index_4 = require("../type/registry/index");
+const index_1 = require("../system/index");
+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_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");
-// --------------------------------------------------------------------------
+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");
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+const index_8 = require("../value/guard/index");
+// ------------------------------------------------------------------
 // ValueErrorType
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 var ValueErrorType;
 (function (ValueErrorType) {
     ValueErrorType[ValueErrorType["ArrayContains"] = 0] = "ArrayContains";
@@ -81,9 +85,9 @@ var ValueErrorType;
     ValueErrorType[ValueErrorType["Union"] = 61] = "Union";
     ValueErrorType[ValueErrorType["Void"] = 62] = "Void";
 })(ValueErrorType || (exports.ValueErrorType = ValueErrorType = {}));
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // ValueErrors
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 class ValueErrorsUnknownTypeError extends Error {
     constructor(schema) {
         super('Unknown type');
@@ -91,21 +95,21 @@ class ValueErrorsUnknownTypeError extends Error {
     }
 }
 exports.ValueErrorsUnknownTypeError = ValueErrorsUnknownTypeError;
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // EscapeKey
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function EscapeKey(key) {
     return key.replace(/~/g, '~0').replace(/\//g, '~1'); // RFC6901 Path
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Guards
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function IsDefined(value) {
     return value !== undefined;
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // ValueErrorIterator
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 class ValueErrorIterator {
     constructor(iterator) {
         this.iterator = iterator;
@@ -131,7 +135,7 @@ function Create(type, schema, path, value) {
 // --------------------------------------------------------------------------
 function* TAny(schema, references, path, value) { }
 function* TArray(schema, references, path, value) {
-    if (!(0, index_1.IsArray)(value)) {
+    if (!(0, index_8.IsArray)(value)) {
         return yield Create(ValueErrorType.Array, schema, path, value);
     }
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
@@ -145,7 +149,7 @@ function* TArray(schema, references, path, value) {
     }
     // prettier-ignore
     if (schema.uniqueItems === true && !((function () { const set = new Set(); for (const element of value) {
-        const hashed = (0, index_6.Hash)(element);
+        const hashed = (0, index_5.Hash)(element);
         if (set.has(hashed)) {
             return false;
         }
@@ -159,24 +163,24 @@ function* TArray(schema, references, path, value) {
     if (!(IsDefined(schema.contains) || IsDefined(schema.minContains) || IsDefined(schema.maxContains))) {
         return;
     }
-    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_8.Never)();
+    const containsSchema = IsDefined(schema.contains) ? schema.contains : (0, index_7.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_1.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
+    if ((0, index_8.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
         yield Create(ValueErrorType.ArrayMinContains, schema, path, value);
     }
-    if ((0, index_1.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
+    if ((0, index_8.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
         yield Create(ValueErrorType.ArrayMaxContains, schema, path, value);
     }
 }
 function* TAsyncIterator(schema, references, path, value) {
-    if (!(0, index_1.IsAsyncIterator)(value))
+    if (!(0, index_8.IsAsyncIterator)(value))
         yield Create(ValueErrorType.AsyncIterator, schema, path, value);
 }
 function* TBigInt(schema, references, path, value) {
-    if (!(0, index_1.IsBigInt)(value))
+    if (!(0, index_8.IsBigInt)(value))
         return yield Create(ValueErrorType.BigInt, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path, value);
@@ -195,14 +199,14 @@ function* TBigInt(schema, references, path, value) {
     }
 }
 function* TBoolean(schema, references, path, value) {
-    if (!(0, index_1.IsBoolean)(value))
+    if (!(0, index_8.IsBoolean)(value))
         yield Create(ValueErrorType.Boolean, schema, path, value);
 }
 function* TConstructor(schema, references, path, value) {
     yield* Visit(schema.returns, references, path, value.prototype);
 }
 function* TDate(schema, references, path, value) {
-    if (!(0, index_1.IsDate)(value))
+    if (!(0, index_8.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);
@@ -221,11 +225,11 @@ function* TDate(schema, references, path, value) {
     }
 }
 function* TFunction(schema, references, path, value) {
-    if (!(0, index_1.IsFunction)(value))
+    if (!(0, index_8.IsFunction)(value))
         yield Create(ValueErrorType.Function, schema, path, value);
 }
 function* TInteger(schema, references, path, value) {
-    if (!(0, index_1.IsInteger)(value))
+    if (!(0, index_8.IsInteger)(value))
         return yield Create(ValueErrorType.Integer, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path, value);
@@ -252,7 +256,7 @@ function* TIntersect(schema, references, path, value) {
         }
     }
     if (schema.unevaluatedProperties === false) {
-        const keyCheck = new RegExp((0, index_3.KeyOfPattern)(schema));
+        const keyCheck = new RegExp((0, index_2.KeyOfPattern)(schema));
         for (const valueKey of Object.getOwnPropertyNames(value)) {
             if (!keyCheck.test(valueKey)) {
                 yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path}/${valueKey}`, value);
@@ -260,7 +264,7 @@ function* TIntersect(schema, references, path, value) {
         }
     }
     if (typeof schema.unevaluatedProperties === 'object') {
-        const keyCheck = new RegExp((0, index_3.KeyOfPattern)(schema));
+        const keyCheck = new RegExp((0, index_2.KeyOfPattern)(schema));
         for (const valueKey of Object.getOwnPropertyNames(value)) {
             if (!keyCheck.test(valueKey)) {
                 const next = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next();
@@ -271,7 +275,7 @@ function* TIntersect(schema, references, path, value) {
     }
 }
 function* TIterator(schema, references, path, value) {
-    if (!(0, index_1.IsIterator)(value))
+    if (!(0, index_8.IsIterator)(value))
         yield Create(ValueErrorType.Iterator, schema, path, value);
 }
 function* TLiteral(schema, references, path, value) {
@@ -286,11 +290,11 @@ function* TNot(schema, references, path, value) {
         yield Create(ValueErrorType.Not, schema, path, value);
 }
 function* TNull(schema, references, path, value) {
-    if (!(0, index_1.IsNull)(value))
+    if (!(0, index_8.IsNull)(value))
         yield Create(ValueErrorType.Null, schema, path, value);
 }
 function* TNumber(schema, references, path, value) {
-    if (!index_2.TypeSystemPolicy.IsNumberLike(value))
+    if (!index_1.TypeSystemPolicy.IsNumberLike(value))
         return yield Create(ValueErrorType.Number, schema, path, value);
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
         yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path, value);
@@ -309,7 +313,7 @@ function* TNumber(schema, references, path, value) {
     }
 }
 function* TObject(schema, references, path, value) {
-    if (!index_2.TypeSystemPolicy.IsObjectLike(value))
+    if (!index_1.TypeSystemPolicy.IsObjectLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
         yield Create(ValueErrorType.ObjectMinProperties, schema, path, value);
@@ -348,18 +352,18 @@ function* TObject(schema, references, path, value) {
             }
         }
         else {
-            if (index_2.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
+            if (index_1.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
                 yield* Visit(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey]);
             }
         }
     }
 }
 function* TPromise(schema, references, path, value) {
-    if (!(0, index_1.IsPromise)(value))
+    if (!(0, index_8.IsPromise)(value))
         yield Create(ValueErrorType.Promise, schema, path, value);
 }
 function* TRecord(schema, references, path, value) {
-    if (!index_2.TypeSystemPolicy.IsRecordLike(value))
+    if (!index_1.TypeSystemPolicy.IsRecordLike(value))
         return yield Create(ValueErrorType.Object, schema, path, value);
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
         yield Create(ValueErrorType.ObjectMinProperties, schema, path, value);
@@ -388,10 +392,10 @@ function* TRecord(schema, references, path, value) {
     }
 }
 function* TRef(schema, references, path, value) {
-    yield* Visit((0, index_5.Deref)(schema, references), references, path, value);
+    yield* Visit((0, index_4.Deref)(schema, references), references, path, value);
 }
 function* TString(schema, references, path, value) {
-    if (!(0, index_1.IsString)(value))
+    if (!(0, index_8.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);
@@ -399,18 +403,18 @@ function* TString(schema, references, path, value) {
     if (IsDefined(schema.maxLength) && !(value.length <= schema.maxLength)) {
         yield Create(ValueErrorType.StringMaxLength, schema, path, value);
     }
-    if ((0, index_1.IsString)(schema.pattern)) {
+    if ((0, index_8.IsString)(schema.pattern)) {
         const regex = new RegExp(schema.pattern);
         if (!regex.test(value)) {
             yield Create(ValueErrorType.StringPattern, schema, path, value);
         }
     }
-    if ((0, index_1.IsString)(schema.format)) {
-        if (!index_4.FormatRegistry.Has(schema.format)) {
+    if ((0, index_8.IsString)(schema.format)) {
+        if (!index_3.FormatRegistry.Has(schema.format)) {
             yield Create(ValueErrorType.StringFormatUnknown, schema, path, value);
         }
         else {
-            const format = index_4.FormatRegistry.Get(schema.format);
+            const format = index_3.FormatRegistry.Get(schema.format);
             if (!format(value)) {
                 yield Create(ValueErrorType.StringFormat, schema, path, value);
             }
@@ -418,11 +422,11 @@ function* TString(schema, references, path, value) {
     }
 }
 function* TSymbol(schema, references, path, value) {
-    if (!(0, index_1.IsSymbol)(value))
+    if (!(0, index_8.IsSymbol)(value))
         yield Create(ValueErrorType.Symbol, schema, path, value);
 }
 function* TTemplateLiteral(schema, references, path, value) {
-    if (!(0, index_1.IsString)(value))
+    if (!(0, index_8.IsString)(value))
         return yield Create(ValueErrorType.String, schema, path, value);
     const regex = new RegExp(schema.pattern);
     if (!regex.test(value)) {
@@ -430,10 +434,10 @@ function* TTemplateLiteral(schema, references, path, value) {
     }
 }
 function* TThis(schema, references, path, value) {
-    yield* Visit((0, index_5.Deref)(schema, references), references, path, value);
+    yield* Visit((0, index_4.Deref)(schema, references), references, path, value);
 }
 function* TTuple(schema, references, path, value) {
-    if (!(0, index_1.IsArray)(value))
+    if (!(0, index_8.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);
@@ -449,7 +453,7 @@ function* TTuple(schema, references, path, value) {
     }
 }
 function* TUndefined(schema, references, path, value) {
-    if (!(0, index_1.IsUndefined)(value))
+    if (!(0, index_8.IsUndefined)(value))
         yield Create(ValueErrorType.Undefined, schema, path, value);
 }
 function* TUnion(schema, references, path, value) {
@@ -465,7 +469,7 @@ function* TUnion(schema, references, path, value) {
     }
 }
 function* TUint8Array(schema, references, path, value) {
-    if (!(0, index_1.IsUint8Array)(value))
+    if (!(0, index_8.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);
@@ -476,18 +480,18 @@ function* TUint8Array(schema, references, path, value) {
 }
 function* TUnknown(schema, references, path, value) { }
 function* TVoid(schema, references, path, value) {
-    if (!index_2.TypeSystemPolicy.IsVoidLike(value))
+    if (!index_1.TypeSystemPolicy.IsVoidLike(value))
         yield Create(ValueErrorType.Void, schema, path, value);
 }
 function* TKind(schema, references, path, value) {
-    const check = index_4.TypeRegistry.Get(schema[index_7.Kind]);
+    const check = index_3.TypeRegistry.Get(schema[index_6.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_7.Kind]) {
+    switch (schema_[index_6.Kind]) {
         case 'Any':
             return yield* TAny(schema_, references_, path, value);
         case 'Array':
@@ -549,7 +553,7 @@ function* Visit(schema, references, path, value) {
         case 'Void':
             return yield* TVoid(schema_, references_, path, value);
         default:
-            if (!index_4.TypeRegistry.Has(schema_[index_7.Kind]))
+            if (!index_3.TypeRegistry.Has(schema_[index_6.Kind]))
                 throw new ValueErrorsUnknownTypeError(schema);
             return yield* TKind(schema_, references_, path, value);
     }

package/build/require/type/awaited/awaited.js

@@ -31,9 +31,9 @@ function FromPromise(T) {
 }
 // prettier-ignore
 function FromSchema(T) {
-    return ((0, type_2.TIntersect)(T) ? FromIntersect(T.allOf) :
-        (0, type_2.TUnion)(T) ? FromUnion(T.anyOf) :
-            (0, type_2.TPromise)(T) ? FromPromise(T.item) :
+    return ((0, type_2.IsIntersect)(T) ? FromIntersect(T.allOf) :
+        (0, type_2.IsUnion)(T) ? FromUnion(T.anyOf) :
+            (0, type_2.IsPromise)(T) ? FromPromise(T.item) :
                 T);
 }
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */

package/build/require/type/deref/deref.js

@@ -93,17 +93,17 @@ function FromRef(schema, references) {
 }
 // prettier-ignore
 function DerefResolve(schema, references) {
-    return ((0, type_2.TConstructor)(schema) ? FromConstructor(schema, references) :
-        (0, type_2.TFunction)(schema) ? FromFunction(schema, references) :
-            (0, type_2.TIntersect)(schema) ? FromIntersect(schema, references) :
-                (0, type_2.TUnion)(schema) ? FromUnion(schema, references) :
-                    (0, type_2.TTuple)(schema) ? FromTuple(schema, references) :
-                        (0, type_2.TArray)(schema) ? FromArray(schema, references) :
-                            (0, type_2.TObject)(schema) ? FromObject(schema, references) :
-                                (0, type_2.TPromise)(schema) ? FromPromise(schema, references) :
-                                    (0, type_2.TAsyncIterator)(schema) ? FromAsyncIterator(schema, references) :
-                                        (0, type_2.TIterator)(schema) ? FromIterator(schema, references) :
-                                            (0, type_2.TRef)(schema) ? FromRef(schema, references) :
+    return ((0, type_2.IsConstructor)(schema) ? FromConstructor(schema, references) :
+        (0, type_2.IsFunction)(schema) ? FromFunction(schema, references) :
+            (0, type_2.IsIntersect)(schema) ? FromIntersect(schema, references) :
+                (0, type_2.IsUnion)(schema) ? FromUnion(schema, references) :
+                    (0, type_2.IsTuple)(schema) ? FromTuple(schema, references) :
+                        (0, type_2.IsArray)(schema) ? FromArray(schema, references) :
+                            (0, type_2.IsObject)(schema) ? FromObject(schema, references) :
+                                (0, type_2.IsPromise)(schema) ? FromPromise(schema, references) :
+                                    (0, type_2.IsAsyncIterator)(schema) ? FromAsyncIterator(schema, references) :
+                                        (0, type_2.IsIterator)(schema) ? FromIterator(schema, references) :
+                                            (0, type_2.IsRef)(schema) ? FromRef(schema, references) :
                                                 schema);
 }
 exports.DerefResolve = DerefResolve;

package/build/require/type/exclude/exclude.js

@@ -8,13 +8,16 @@ const index_3 = require("../never/index");
 const index_4 = require("../extends/index");
 const type_1 = require("../clone/type");
 const exclude_from_mapped_result_1 = require("./exclude-from-mapped-result");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
 // prettier-ignore
 const type_2 = require("../guard/type");
 // prettier-ignore
 function ExcludeResolve(L, R) {
-    return ((0, type_2.TTemplateLiteral)(L) ? ExcludeResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
-        (0, type_2.TTemplateLiteral)(R) ? ExcludeResolve(L, (0, index_1.TemplateLiteralToUnion)(R)) :
-            (0, type_2.TUnion)(L) ? (() => {
+    return ((0, type_2.IsTemplateLiteral)(L) ? ExcludeResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
+        (0, type_2.IsTemplateLiteral)(R) ? ExcludeResolve(L, (0, index_1.TemplateLiteralToUnion)(R)) :
+            (0, type_2.IsUnion)(L) ? (() => {
                 const narrowed = L.anyOf.filter((inner) => (0, index_4.ExtendsCheck)(inner, R) === index_4.ExtendsResult.False);
                 return (narrowed.length === 1 ? narrowed[0] : (0, index_2.Union)(narrowed));
             })() :
@@ -23,7 +26,7 @@ function ExcludeResolve(L, R) {
 }
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 function Exclude(unionType, excludedMembers, options = {}) {
-    if ((0, type_2.TMappedResult)(unionType)) {
+    if ((0, type_2.IsMappedResult)(unionType)) {
         return (0, exclude_from_mapped_result_1.ExcludeFromMappedResult)(unionType, excludedMembers, options);
     }
     else {