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

package/build/require/value/check/check.js

@@ -44,10 +44,10 @@ function IsDefined(value) {
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
-function TAny(schema, references, value) {
+function FromAny(schema, references, value) {
     return true;
 }
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if (!(0, index_9.IsArray)(value))
         return false;
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
@@ -88,10 +88,10 @@ function TArray(schema, references, value) {
     }
     return true;
 }
-function TAsyncIterator(schema, references, value) {
+function FromAsyncIterator(schema, references, value) {
     return (0, index_9.IsAsyncIterator)(value);
 }
-function TBigInt(schema, references, value) {
+function FromBigInt(schema, references, value) {
     if (!(0, index_9.IsBigInt)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -111,13 +111,13 @@ function TBigInt(schema, references, value) {
     }
     return true;
 }
-function TBoolean(schema, references, value) {
+function FromBoolean(schema, references, value) {
     return (0, index_9.IsBoolean)(value);
 }
-function TConstructor(schema, references, value) {
+function FromConstructor(schema, references, value) {
     return Visit(schema.returns, references, value.prototype);
 }
-function TDate(schema, references, value) {
+function FromDate(schema, references, value) {
     if (!(0, index_9.IsDate)(value))
         return false;
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
@@ -137,10 +137,10 @@ function TDate(schema, references, value) {
     }
     return true;
 }
-function TFunction(schema, references, value) {
+function FromFunction(schema, references, value) {
     return (0, index_9.IsFunction)(value);
 }
-function TInteger(schema, references, value) {
+function FromInteger(schema, references, value) {
     if (!(0, index_9.IsInteger)(value)) {
         return false;
     }
@@ -161,7 +161,7 @@ function TInteger(schema, references, value) {
     }
     return true;
 }
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const check1 = schema.allOf.every((schema) => Visit(schema, references, value));
     if (schema.unevaluatedProperties === false) {
         const keyPattern = new RegExp((0, index_5.KeyOfPattern)(schema));
@@ -177,22 +177,22 @@ function TIntersect(schema, references, value) {
         return check1;
     }
 }
-function TIterator(schema, references, value) {
+function FromIterator(schema, references, value) {
     return (0, index_9.IsIterator)(value);
 }
-function TLiteral(schema, references, value) {
+function FromLiteral(schema, references, value) {
     return value === schema.const;
 }
-function TNever(schema, references, value) {
+function FromNever(schema, references, value) {
     return false;
 }
-function TNot(schema, references, value) {
+function FromNot(schema, references, value) {
     return !Visit(schema.not, references, value);
 }
-function TNull(schema, references, value) {
+function FromNull(schema, references, value) {
     return (0, index_9.IsNull)(value);
 }
-function TNumber(schema, references, value) {
+function FromNumber(schema, references, value) {
     if (!index_1.TypeSystemPolicy.IsNumberLike(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -212,7 +212,7 @@ function TNumber(schema, references, value) {
     }
     return true;
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if (!index_1.TypeSystemPolicy.IsObjectLike(value))
         return false;
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -256,10 +256,10 @@ function TObject(schema, references, value) {
         return true;
     }
 }
-function TPromise(schema, references, value) {
+function FromPromise(schema, references, value) {
     return (0, index_9.IsPromise)(value);
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if (!index_1.TypeSystemPolicy.IsRecordLike(value)) {
         return false;
     }
@@ -286,10 +286,10 @@ function TRecord(schema, references, value) {
         : true;
     return check1 && check2 && check3;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit((0, index_2.Deref)(schema, references), references, value);
 }
-function TString(schema, references, value) {
+function FromString(schema, references, value) {
     if (!(0, index_9.IsString)(value)) {
         return false;
     }
@@ -314,16 +314,16 @@ function TString(schema, references, value) {
     }
     return true;
 }
-function TSymbol(schema, references, value) {
+function FromSymbol(schema, references, value) {
     return (0, index_9.IsSymbol)(value);
 }
-function TTemplateLiteral(schema, references, value) {
+function FromTemplateLiteral(schema, references, value) {
     return (0, index_9.IsString)(value) && new RegExp(schema.pattern).test(value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit((0, index_2.Deref)(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if (!(0, index_9.IsArray)(value)) {
         return false;
     }
@@ -342,13 +342,13 @@ function TTuple(schema, references, value) {
     }
     return true;
 }
-function TUndefined(schema, references, value) {
+function FromUndefined(schema, references, value) {
     return (0, index_9.IsUndefined)(value);
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     return schema.anyOf.some((inner) => Visit(inner, references, value));
 }
-function TUint8Array(schema, references, value) {
+function FromUint8Array(schema, references, value) {
     if (!(0, index_9.IsUint8Array)(value)) {
         return false;
     }
@@ -360,13 +360,13 @@ function TUint8Array(schema, references, value) {
     }
     return true;
 }
-function TUnknown(schema, references, value) {
+function FromUnknown(schema, references, value) {
     return true;
 }
-function TVoid(schema, references, value) {
+function FromVoid(schema, references, value) {
     return index_1.TypeSystemPolicy.IsVoidLike(value);
 }
-function TKind(schema, references, value) {
+function FromKind(schema, references, value) {
     if (!index_7.TypeRegistry.Has(schema[index_4.Kind]))
         return false;
     const func = index_7.TypeRegistry.Get(schema[index_4.Kind]);
@@ -377,69 +377,69 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema_[index_4.Kind]) {
         case 'Any':
-            return TAny(schema_, references_, value);
+            return FromAny(schema_, references_, value);
         case 'Array':
-            return TArray(schema_, references_, value);
+            return FromArray(schema_, references_, value);
         case 'AsyncIterator':
-            return TAsyncIterator(schema_, references_, value);
+            return FromAsyncIterator(schema_, references_, value);
         case 'BigInt':
-            return TBigInt(schema_, references_, value);
+            return FromBigInt(schema_, references_, value);
         case 'Boolean':
-            return TBoolean(schema_, references_, value);
+            return FromBoolean(schema_, references_, value);
         case 'Constructor':
-            return TConstructor(schema_, references_, value);
+            return FromConstructor(schema_, references_, value);
         case 'Date':
-            return TDate(schema_, references_, value);
+            return FromDate(schema_, references_, value);
         case 'Function':
-            return TFunction(schema_, references_, value);
+            return FromFunction(schema_, references_, value);
         case 'Integer':
-            return TInteger(schema_, references_, value);
+            return FromInteger(schema_, references_, value);
         case 'Intersect':
-            return TIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, value);
         case 'Iterator':
-            return TIterator(schema_, references_, value);
+            return FromIterator(schema_, references_, value);
         case 'Literal':
-            return TLiteral(schema_, references_, value);
+            return FromLiteral(schema_, references_, value);
         case 'Never':
-            return TNever(schema_, references_, value);
+            return FromNever(schema_, references_, value);
         case 'Not':
-            return TNot(schema_, references_, value);
+            return FromNot(schema_, references_, value);
         case 'Null':
-            return TNull(schema_, references_, value);
+            return FromNull(schema_, references_, value);
         case 'Number':
-            return TNumber(schema_, references_, value);
+            return FromNumber(schema_, references_, value);
         case 'Object':
-            return TObject(schema_, references_, value);
+            return FromObject(schema_, references_, value);
         case 'Promise':
-            return TPromise(schema_, references_, value);
+            return FromPromise(schema_, references_, value);
         case 'Record':
-            return TRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, value);
         case 'Ref':
-            return TRef(schema_, references_, value);
+            return FromRef(schema_, references_, value);
         case 'String':
-            return TString(schema_, references_, value);
+            return FromString(schema_, references_, value);
         case 'Symbol':
-            return TSymbol(schema_, references_, value);
+            return FromSymbol(schema_, references_, value);
         case 'TemplateLiteral':
-            return TTemplateLiteral(schema_, references_, value);
+            return FromTemplateLiteral(schema_, references_, value);
         case 'This':
-            return TThis(schema_, references_, value);
+            return FromThis(schema_, references_, value);
         case 'Tuple':
-            return TTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, value);
         case 'Undefined':
-            return TUndefined(schema_, references_, value);
+            return FromUndefined(schema_, references_, value);
         case 'Union':
-            return TUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, value);
         case 'Uint8Array':
-            return TUint8Array(schema_, references_, value);
+            return FromUint8Array(schema_, references_, value);
         case 'Unknown':
-            return TUnknown(schema_, references_, value);
+            return FromUnknown(schema_, references_, value);
         case 'Void':
-            return TVoid(schema_, references_, value);
+            return FromVoid(schema_, references_, value);
         default:
             if (!index_7.TypeRegistry.Has(schema_[index_4.Kind]))
                 throw new ValueCheckUnknownTypeError(schema_);
-            return TKind(schema_, references_, value);
+            return FromKind(schema_, references_, value);
     }
 }
 /** Returns true if the value matches the given type. */

package/build/require/value/clean/clean.js

@@ -26,12 +26,12 @@ function IsCheckable(schema) {
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if (!(0, index_6.IsArray)(value))
         return value;
     return value.map((value) => Visit(schema.items, references, value));
 }
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const unevaluatedProperties = schema.unevaluatedProperties;
     const intersections = schema.allOf.map((schema) => Visit(schema, references, (0, index_3.Clone)(value)));
     const composite = intersections.reduce((acc, value) => ((0, index_6.IsObject)(value) ? { ...acc, ...value } : value), {});
@@ -47,7 +47,7 @@ function TIntersect(schema, references, value) {
     }
     return composite;
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if (!(0, index_6.IsObject)(value) || (0, index_6.IsArray)(value))
         return value; // Check IsArray for AllowArrayObject configuration
     const additionalProperties = schema.additionalProperties;
@@ -64,7 +64,7 @@ function TObject(schema, references, value) {
     }
     return value;
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if (!(0, index_6.IsObject)(value))
         return value;
     const additionalProperties = schema.additionalProperties;
@@ -84,13 +84,13 @@ function TRecord(schema, references, value) {
     }
     return value;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit((0, index_4.Deref)(schema, references), references, value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit((0, index_4.Deref)(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if (!(0, index_6.IsArray)(value))
         return value;
     if ((0, index_6.IsUndefined)(schema.items))
@@ -104,7 +104,7 @@ function TTuple(schema, references, value) {
         ? value.slice(0, length)
         : value;
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     for (const inner of schema.anyOf) {
         if (IsCheckable(inner) && (0, index_2.Check)(inner, value)) {
             return Visit(inner, references, value);
@@ -117,21 +117,21 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema_[index_5.Kind]) {
         case 'Array':
-            return TArray(schema_, references_, value);
+            return FromArray(schema_, references_, value);
         case 'Intersect':
-            return TIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, value);
         case 'Object':
-            return TObject(schema_, references_, value);
+            return FromObject(schema_, references_, value);
         case 'Record':
-            return TRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, value);
         case 'Ref':
-            return TRef(schema_, references_, value);
+            return FromRef(schema_, references_, value);
         case 'This':
-            return TThis(schema_, references_, value);
+            return FromThis(schema_, references_, value);
         case 'Tuple':
-            return TTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, value);
         case 'Union':
-            return TUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, value);
         default:
             return value;
     }

package/build/require/value/convert/convert.js

@@ -126,42 +126,42 @@ function Default(value) {
 // ------------------------------------------------------------------
 // Convert
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if ((0, index_6.IsArray)(value)) {
         return value.map((value) => Visit(schema.items, references, value));
     }
     return value;
 }
-function TBigInt(schema, references, value) {
+function FromBigInt(schema, references, value) {
     return TryConvertBigInt(value);
 }
-function TBoolean(schema, references, value) {
+function FromBoolean(schema, references, value) {
     return TryConvertBoolean(value);
 }
-function TDate(schema, references, value) {
+function FromDate(schema, references, value) {
     return TryConvertDate(value);
 }
-function TInteger(schema, references, value) {
+function FromInteger(schema, references, value) {
     return TryConvertInteger(value);
 }
 // prettier-ignore
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const allObjects = schema.allOf.every(schema => (0, type_1.IsObject)(schema));
     if (allObjects)
         return Visit((0, index_5.Composite)(schema.allOf), references, value);
     return Visit(schema.allOf[0], references, value); // todo: fix this
 }
-function TLiteral(schema, references, value) {
+function FromLiteral(schema, references, value) {
     return TryConvertLiteral(schema, value);
 }
-function TNull(schema, references, value) {
+function FromNull(schema, references, value) {
     return TryConvertNull(value);
 }
-function TNumber(schema, references, value) {
+function FromNumber(schema, references, value) {
     return TryConvertNumber(value);
 }
 // prettier-ignore
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     const isConvertable = (0, index_6.IsObject)(value);
     if (!isConvertable)
         return value;
@@ -171,7 +171,7 @@ function TObject(schema, references, value) {
             : ({ ...value });
     }, value);
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[propertyKey];
     const result = {};
@@ -180,20 +180,20 @@ function TRecord(schema, references, value) {
     }
     return result;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit((0, index_3.Deref)(schema, references), references, value);
 }
-function TString(schema, references, value) {
+function FromString(schema, references, value) {
     return TryConvertString(value);
 }
-function TSymbol(schema, references, value) {
+function FromSymbol(schema, references, value) {
     return (0, index_6.IsString)(value) || (0, index_6.IsNumber)(value) ? Symbol(value) : value;
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit((0, index_3.Deref)(schema, references), references, value);
 }
 // prettier-ignore
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     const isConvertable = (0, index_6.IsArray)(value) && !(0, index_6.IsUndefined)(schema.items);
     if (!isConvertable)
         return value;
@@ -203,10 +203,10 @@ function TTuple(schema, references, value) {
             : value;
     });
 }
-function TUndefined(schema, references, value) {
+function FromUndefined(schema, references, value) {
     return TryConvertUndefined(value);
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     for (const subschema of schema.anyOf) {
         const converted = Visit(subschema, references, value);
         if ((0, index_2.Check)(subschema, references, converted)) {
@@ -220,41 +220,41 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema[index_4.Kind]) {
         case 'Array':
-            return TArray(schema_, references_, value);
+            return FromArray(schema_, references_, value);
         case 'BigInt':
-            return TBigInt(schema_, references_, value);
+            return FromBigInt(schema_, references_, value);
         case 'Boolean':
-            return TBoolean(schema_, references_, value);
+            return FromBoolean(schema_, references_, value);
         case 'Date':
-            return TDate(schema_, references_, value);
+            return FromDate(schema_, references_, value);
         case 'Integer':
-            return TInteger(schema_, references_, value);
+            return FromInteger(schema_, references_, value);
         case 'Intersect':
-            return TIntersect(schema_, references_, value);
+            return FromIntersect(schema_, references_, value);
         case 'Literal':
-            return TLiteral(schema_, references_, value);
+            return FromLiteral(schema_, references_, value);
         case 'Null':
-            return TNull(schema_, references_, value);
+            return FromNull(schema_, references_, value);
         case 'Number':
-            return TNumber(schema_, references_, value);
+            return FromNumber(schema_, references_, value);
         case 'Object':
-            return TObject(schema_, references_, value);
+            return FromObject(schema_, references_, value);
         case 'Record':
-            return TRecord(schema_, references_, value);
+            return FromRecord(schema_, references_, value);
         case 'Ref':
-            return TRef(schema_, references_, value);
+            return FromRef(schema_, references_, value);
         case 'String':
-            return TString(schema_, references_, value);
+            return FromString(schema_, references_, value);
         case 'Symbol':
-            return TSymbol(schema_, references_, value);
+            return FromSymbol(schema_, references_, value);
         case 'This':
-            return TThis(schema_, references_, value);
+            return FromThis(schema_, references_, value);
         case 'Tuple':
-            return TTuple(schema_, references_, value);
+            return FromTuple(schema_, references_, value);
         case 'Undefined':
-            return TUndefined(schema_, references_, value);
+            return FromUndefined(schema_, references_, value);
         case 'Union':
-            return TUnion(schema_, references_, value);
+            return FromUnion(schema_, references_, value);
         default:
             return Default(value);
     }