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

package/build/import/compiler/compiler.mjs

@@ -1,16 +1,22 @@
 import { TransformEncode, TransformDecode, HasTransform, TransformDecodeCheckError, TransformEncodeCheckError } from '../value/transform/index.mjs';
-import { IsArray, IsString, IsNumber, IsBigInt } from '../value/guard/index.mjs';
 import { Errors } from '../errors/index.mjs';
 import { TypeSystemPolicy } from '../system/index.mjs';
 import { Deref } from '../value/deref/index.mjs';
 import { Hash } from '../value/hash/index.mjs';
 import { Kind } from '../type/symbols/index.mjs';
-import { TSchema as IsSchemaType } from '../type/guard/type.mjs';
 import { TypeRegistry, FormatRegistry } from '../type/registry/index.mjs';
 import { KeyOfPattern } from '../type/keyof/index.mjs';
 import { ExtendsUndefinedCheck } from '../type/extends/extends-undefined.mjs';
 import { Never } from '../type/never/index.mjs';
 // ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+import { IsArray, IsString, IsNumber, IsBigInt } from '../value/guard/index.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsSchema } from '../type/guard/type.mjs';
+// ------------------------------------------------------------------
 // TypeCheck
 // ------------------------------------------------------------------
 export class TypeCheck {
@@ -202,8 +208,8 @@ export var TypeCompiler;
             yield `${value}.length >= ${schema.minItems}`;
         const elementExpression = CreateExpression(schema.items, references, 'value');
         yield `${value}.every((${parameter}) => ${elementExpression})`;
-        if (IsSchemaType(schema.contains) || IsNumber(schema.minContains) || IsNumber(schema.maxContains)) {
-            const containsSchema = IsSchemaType(schema.contains) ? schema.contains : Never();
+        if (IsSchema(schema.contains) || IsNumber(schema.minContains) || IsNumber(schema.maxContains)) {
+            const containsSchema = IsSchema(schema.contains) ? schema.contains : Never();
             const checkExpression = CreateExpression(containsSchema, references, 'value');
             const checkMinContains = IsNumber(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
             const checkMaxContains = IsNumber(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
@@ -275,7 +281,7 @@ export var TypeCompiler;
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`;
             yield `(${check1} && ${check2})`;
         }
-        else if (IsSchemaType(schema.unevaluatedProperties)) {
+        else if (IsSchema(schema.unevaluatedProperties)) {
             const keyCheck = CreateVariable(`${new RegExp(KeyOfPattern(schema))};`);
             const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`;
             yield `(${check1} && ${check2})`;
@@ -365,7 +371,7 @@ export var TypeCompiler;
         const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
         const variable = CreateVariable(`${new RegExp(patternKey)}`);
         const check1 = CreateExpression(patternSchema, references, 'value');
-        const check2 = IsSchemaType(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? 'false' : 'true';
+        const check2 = IsSchema(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? 'false' : 'true';
         const expression = `(${variable}.test(key) ? ${check1} : ${check2})`;
         yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`;
     }
@@ -589,10 +595,10 @@ export var TypeCompiler;
         state.variables.clear();
         state.functions.clear();
         state.instances.clear();
-        if (!IsSchemaType(schema))
+        if (!IsSchema(schema))
             throw new TypeCompilerTypeGuardError(schema);
         for (const schema of references)
-            if (!IsSchemaType(schema))
+            if (!IsSchema(schema))
                 throw new TypeCompilerTypeGuardError(schema);
         return Build(schema, references, options);
     }

package/build/import/errors/errors.mjs

@@ -1,4 +1,3 @@
-import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from '../value/guard/index.mjs';
 import { TypeSystemPolicy } from '../system/index.mjs';
 import { KeyOfPattern } from '../type/keyof/index.mjs';
 import { TypeRegistry, FormatRegistry } from '../type/registry/index.mjs';
@@ -8,9 +7,14 @@ import { Deref } from '../value/deref/index.mjs';
 import { Hash } from '../value/hash/index.mjs';
 import { Kind } from '../type/symbols/index.mjs';
 import { Never } from '../type/never/index.mjs';
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
+// ValueGuard
+// ------------------------------------------------------------------
+// prettier-ignore
+import { IsArray, IsUint8Array, IsDate, IsPromise, IsFunction, IsAsyncIterator, IsIterator, IsBoolean, IsNumber, IsBigInt, IsString, IsSymbol, IsInteger, IsNull, IsUndefined } from '../value/guard/index.mjs';
+// ------------------------------------------------------------------
 // ValueErrorType
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 export var ValueErrorType;
 (function (ValueErrorType) {
     ValueErrorType[ValueErrorType["ArrayContains"] = 0] = "ArrayContains";
@@ -77,9 +81,9 @@ export var ValueErrorType;
     ValueErrorType[ValueErrorType["Union"] = 61] = "Union";
     ValueErrorType[ValueErrorType["Void"] = 62] = "Void";
 })(ValueErrorType || (ValueErrorType = {}));
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // ValueErrors
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 export class ValueErrorsUnknownTypeError extends Error {
     schema;
     constructor(schema) {
@@ -87,21 +91,21 @@ export class ValueErrorsUnknownTypeError extends Error {
         this.schema = schema;
     }
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // EscapeKey
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function EscapeKey(key) {
     return key.replace(/~/g, '~0').replace(/\//g, '~1'); // RFC6901 Path
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // Guards
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 function IsDefined(value) {
     return value !== undefined;
 }
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 // ValueErrorIterator
-// --------------------------------------------------------------------------
+// ------------------------------------------------------------------
 export class ValueErrorIterator {
     iterator;
     constructor(iterator) {

package/build/import/type/awaited/awaited.mjs

@@ -5,7 +5,7 @@ import { CloneType } from '../clone/type.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TIntersect as IsIntersectType, TUnion as IsUnionType, TPromise as IsPromiseType } from '../guard/type.mjs';
+import { IsIntersect, IsUnion, IsPromise } from '../guard/type.mjs';
 // prettier-ignore
 function FromRest(T) {
     const [L, ...R] = T;
@@ -27,9 +27,9 @@ function FromPromise(T) {
 }
 // prettier-ignore
 function FromSchema(T) {
-    return (IsIntersectType(T) ? FromIntersect(T.allOf) :
-        IsUnionType(T) ? FromUnion(T.anyOf) :
-            IsPromiseType(T) ? FromPromise(T.item) :
+    return (IsIntersect(T) ? FromIntersect(T.allOf) :
+        IsUnion(T) ? FromUnion(T.anyOf) :
+            IsPromise(T) ? FromPromise(T.item) :
                 T);
 }
 /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */

package/build/import/type/deref/deref.mjs

@@ -5,7 +5,7 @@ import { IsUndefined } from '../guard/value.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TConstructor as IsConstructorType, TFunction as IsFunctionType, TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TPromise as IsPromiseType, TAsyncIterator as IsAsyncIteratorType, TIterator as IsIteratorType, TRef as IsRefType, } from '../guard/type.mjs';
+import { IsConstructor, IsFunction, IsIntersect, IsUnion, IsTuple, IsArray, IsObject, IsPromise, IsAsyncIterator, IsIterator, IsRef, } from '../guard/type.mjs';
 function FromRest(schema, references) {
     return schema.map((schema) => Deref(schema, references));
 }
@@ -89,17 +89,17 @@ function FromRef(schema, references) {
 }
 // prettier-ignore
 export function DerefResolve(schema, references) {
-    return (IsConstructorType(schema) ? FromConstructor(schema, references) :
-        IsFunctionType(schema) ? FromFunction(schema, references) :
-            IsIntersectType(schema) ? FromIntersect(schema, references) :
-                IsUnionType(schema) ? FromUnion(schema, references) :
-                    IsTupleType(schema) ? FromTuple(schema, references) :
-                        IsArrayType(schema) ? FromArray(schema, references) :
-                            IsObjectType(schema) ? FromObject(schema, references) :
-                                IsPromiseType(schema) ? FromPromise(schema, references) :
-                                    IsAsyncIteratorType(schema) ? FromAsyncIterator(schema, references) :
-                                        IsIteratorType(schema) ? FromIterator(schema, references) :
-                                            IsRefType(schema) ? FromRef(schema, references) :
+    return (IsConstructor(schema) ? FromConstructor(schema, references) :
+        IsFunction(schema) ? FromFunction(schema, references) :
+            IsIntersect(schema) ? FromIntersect(schema, references) :
+                IsUnion(schema) ? FromUnion(schema, references) :
+                    IsTuple(schema) ? FromTuple(schema, references) :
+                        IsArray(schema) ? FromArray(schema, references) :
+                            IsObject(schema) ? FromObject(schema, references) :
+                                IsPromise(schema) ? FromPromise(schema, references) :
+                                    IsAsyncIterator(schema) ? FromAsyncIterator(schema, references) :
+                                        IsIterator(schema) ? FromIterator(schema, references) :
+                                            IsRef(schema) ? FromRef(schema, references) :
                                                 schema);
 }
 /** `[Json]` Creates a dereferenced type */

package/build/import/type/exclude/exclude.mjs

@@ -4,13 +4,16 @@ import { Never } from '../never/index.mjs';
 import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
 import { CloneType } from '../clone/type.mjs';
 import { ExcludeFromMappedResult } from './exclude-from-mapped-result.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
 // prettier-ignore
-import { TMappedResult as IsMappedResultType, TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType } from '../guard/type.mjs';
+import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/type.mjs';
 // prettier-ignore
 function ExcludeResolve(L, R) {
-    return (IsTemplateLiteralType(L) ? ExcludeResolve(TemplateLiteralToUnion(L), R) :
-        IsTemplateLiteralType(R) ? ExcludeResolve(L, TemplateLiteralToUnion(R)) :
-            IsUnionType(L) ? (() => {
+    return (IsTemplateLiteral(L) ? ExcludeResolve(TemplateLiteralToUnion(L), R) :
+        IsTemplateLiteral(R) ? ExcludeResolve(L, TemplateLiteralToUnion(R)) :
+            IsUnion(L) ? (() => {
                 const narrowed = L.anyOf.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
                 return (narrowed.length === 1 ? narrowed[0] : Union(narrowed));
             })() :
@@ -19,7 +22,7 @@ function ExcludeResolve(L, R) {
 }
 /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
 export function Exclude(unionType, excludedMembers, options = {}) {
-    if (IsMappedResultType(unionType)) {
+    if (IsMappedResult(unionType)) {
         return ExcludeFromMappedResult(unionType, excludedMembers, options);
     }
     else {