@sinclair/typebox 0.32.0-dev-20 → 0.32.0-dev-22

package/build/import/value/check/check.mjs

@@ -40,10 +40,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 (!IsArray(value))
         return false;
     if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
@@ -84,10 +84,10 @@ function TArray(schema, references, value) {
     }
     return true;
 }
-function TAsyncIterator(schema, references, value) {
+function FromAsyncIterator(schema, references, value) {
     return IsAsyncIterator(value);
 }
-function TBigInt(schema, references, value) {
+function FromBigInt(schema, references, value) {
     if (!IsBigInt(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -107,13 +107,13 @@ function TBigInt(schema, references, value) {
     }
     return true;
 }
-function TBoolean(schema, references, value) {
+function FromBoolean(schema, references, value) {
     return 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 (!IsDate(value))
         return false;
     if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
@@ -133,10 +133,10 @@ function TDate(schema, references, value) {
     }
     return true;
 }
-function TFunction(schema, references, value) {
+function FromFunction(schema, references, value) {
     return IsFunction(value);
 }
-function TInteger(schema, references, value) {
+function FromInteger(schema, references, value) {
     if (!IsInteger(value)) {
         return false;
     }
@@ -157,7 +157,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(KeyOfPattern(schema));
@@ -173,22 +173,22 @@ function TIntersect(schema, references, value) {
         return check1;
     }
 }
-function TIterator(schema, references, value) {
+function FromIterator(schema, references, value) {
     return 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 IsNull(value);
 }
-function TNumber(schema, references, value) {
+function FromNumber(schema, references, value) {
     if (!TypeSystemPolicy.IsNumberLike(value))
         return false;
     if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
@@ -208,7 +208,7 @@ function TNumber(schema, references, value) {
     }
     return true;
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if (!TypeSystemPolicy.IsObjectLike(value))
         return false;
     if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
@@ -252,10 +252,10 @@ function TObject(schema, references, value) {
         return true;
     }
 }
-function TPromise(schema, references, value) {
+function FromPromise(schema, references, value) {
     return IsPromise(value);
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if (!TypeSystemPolicy.IsRecordLike(value)) {
         return false;
     }
@@ -282,10 +282,10 @@ function TRecord(schema, references, value) {
         : true;
     return check1 && check2 && check3;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TString(schema, references, value) {
+function FromString(schema, references, value) {
     if (!IsString(value)) {
         return false;
     }
@@ -310,16 +310,16 @@ function TString(schema, references, value) {
     }
     return true;
 }
-function TSymbol(schema, references, value) {
+function FromSymbol(schema, references, value) {
     return IsSymbol(value);
 }
-function TTemplateLiteral(schema, references, value) {
+function FromTemplateLiteral(schema, references, value) {
     return IsString(value) && new RegExp(schema.pattern).test(value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if (!IsArray(value)) {
         return false;
     }
@@ -338,13 +338,13 @@ function TTuple(schema, references, value) {
     }
     return true;
 }
-function TUndefined(schema, references, value) {
+function FromUndefined(schema, references, value) {
     return 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 (!IsUint8Array(value)) {
         return false;
     }
@@ -356,13 +356,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 TypeSystemPolicy.IsVoidLike(value);
 }
-function TKind(schema, references, value) {
+function FromKind(schema, references, value) {
     if (!TypeRegistry.Has(schema[Kind]))
         return false;
     const func = TypeRegistry.Get(schema[Kind]);
@@ -373,69 +373,69 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema_[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 (!TypeRegistry.Has(schema_[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/import/value/clean/clean.mjs

@@ -22,12 +22,12 @@ function IsCheckable(schema) {
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if (!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, Clone(value)));
     const composite = intersections.reduce((acc, value) => (IsObject(value) ? { ...acc, ...value } : value), {});
@@ -43,7 +43,7 @@ function TIntersect(schema, references, value) {
     }
     return composite;
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if (!IsObject(value) || IsArray(value))
         return value; // Check IsArray for AllowArrayObject configuration
     const additionalProperties = schema.additionalProperties;
@@ -60,7 +60,7 @@ function TObject(schema, references, value) {
     }
     return value;
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if (!IsObject(value))
         return value;
     const additionalProperties = schema.additionalProperties;
@@ -80,13 +80,13 @@ function TRecord(schema, references, value) {
     }
     return value;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     if (!IsArray(value))
         return value;
     if (IsUndefined(schema.items))
@@ -100,7 +100,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) && Check(inner, value)) {
             return Visit(inner, references, value);
@@ -113,21 +113,21 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema_[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/import/value/convert/convert.mjs

@@ -122,42 +122,42 @@ function Default(value) {
 // ------------------------------------------------------------------
 // Convert
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     if (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 => IsObjectType(schema));
     if (allObjects)
         return Visit(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 = IsObject(value);
     if (!isConvertable)
         return value;
@@ -167,7 +167,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 = {};
@@ -176,20 +176,20 @@ function TRecord(schema, references, value) {
     }
     return result;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit(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 IsString(value) || IsNumber(value) ? Symbol(value) : value;
 }
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     return Visit(Deref(schema, references), references, value);
 }
 // prettier-ignore
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     const isConvertable = IsArray(value) && !IsUndefined(schema.items);
     if (!isConvertable)
         return value;
@@ -199,10 +199,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 (Check(subschema, references, converted)) {
@@ -216,41 +216,41 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema[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);
     }