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

package/build/import/value/transform/has.mjs

@@ -9,67 +9,67 @@ import { IsTransform, IsSchema } from '../../type/guard/type.mjs';
 // ------------------------------------------------------------------
 import { IsString, IsUndefined } from '../guard/index.mjs';
 // prettier-ignore
-function TArray(schema, references) {
+function FromArray(schema, references) {
     return IsTransform(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
-function TAsyncIterator(schema, references) {
+function FromAsyncIterator(schema, references) {
     return IsTransform(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
-function TConstructor(schema, references) {
+function FromConstructor(schema, references) {
     return IsTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
-function TFunction(schema, references) {
+function FromFunction(schema, references) {
     return IsTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
-function TIntersect(schema, references) {
+function FromIntersect(schema, references) {
     return IsTransform(schema) || IsTransform(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
-function TIterator(schema, references) {
+function FromIterator(schema, references) {
     return IsTransform(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
-function TNot(schema, references) {
+function FromNot(schema, references) {
     return IsTransform(schema) || Visit(schema.not, references);
 }
 // prettier-ignore
-function TObject(schema, references) {
+function FromObject(schema, references) {
     return (IsTransform(schema) ||
         Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
         (IsSchema(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
 }
 // prettier-ignore
-function TPromise(schema, references) {
+function FromPromise(schema, references) {
     return IsTransform(schema) || Visit(schema.item, references);
 }
 // prettier-ignore
-function TRecord(schema, references) {
+function FromRecord(schema, references) {
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
     const property = schema.patternProperties[pattern];
     return IsTransform(schema) || Visit(property, references) || (IsSchema(schema.additionalProperties) && IsTransform(schema.additionalProperties));
 }
 // prettier-ignore
-function TRef(schema, references) {
+function FromRef(schema, references) {
     if (IsTransform(schema))
         return true;
     return Visit(Deref(schema, references), references);
 }
 // prettier-ignore
-function TThis(schema, references) {
+function FromThis(schema, references) {
     if (IsTransform(schema))
         return true;
     return Visit(Deref(schema, references), references);
 }
 // prettier-ignore
-function TTuple(schema, references) {
+function FromTuple(schema, references) {
     return IsTransform(schema) || (!IsUndefined(schema.items) && schema.items.some((schema) => Visit(schema, references)));
 }
 // prettier-ignore
-function TUnion(schema, references) {
+function FromUnion(schema, references) {
     return IsTransform(schema) || schema.anyOf.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
@@ -82,33 +82,33 @@ function Visit(schema, references) {
         visited.add(schema.$id);
     switch (schema[Kind]) {
         case 'Array':
-            return TArray(schema_, references_);
+            return FromArray(schema_, references_);
         case 'AsyncIterator':
-            return TAsyncIterator(schema_, references_);
+            return FromAsyncIterator(schema_, references_);
         case 'Constructor':
-            return TConstructor(schema_, references_);
+            return FromConstructor(schema_, references_);
         case 'Function':
-            return TFunction(schema_, references_);
+            return FromFunction(schema_, references_);
         case 'Intersect':
-            return TIntersect(schema_, references_);
+            return FromIntersect(schema_, references_);
         case 'Iterator':
-            return TIterator(schema_, references_);
+            return FromIterator(schema_, references_);
         case 'Not':
-            return TNot(schema_, references_);
+            return FromNot(schema_, references_);
         case 'Object':
-            return TObject(schema_, references_);
+            return FromObject(schema_, references_);
         case 'Promise':
-            return TPromise(schema_, references_);
+            return FromPromise(schema_, references_);
         case 'Record':
-            return TRecord(schema_, references_);
+            return FromRecord(schema_, references_);
         case 'Ref':
-            return TRef(schema_, references_);
+            return FromRef(schema_, references_);
         case 'This':
-            return TThis(schema_, references_);
+            return FromThis(schema_, references_);
         case 'Tuple':
-            return TTuple(schema_, references_);
+            return FromTuple(schema_, references_);
         case 'Union':
-            return TUnion(schema_, references_);
+            return FromUnion(schema_, references_);
         default:
             return IsTransform(schema);
     }

package/build/require/compiler/compiler.js

@@ -196,10 +196,10 @@ var TypeCompiler;
     // ----------------------------------------------------------------
     // Types
     // ----------------------------------------------------------------
-    function* TAny(schema, references, value) {
+    function* FromAny(schema, references, value) {
         yield 'true';
     }
-    function* TArray(schema, references, value) {
+    function* FromArray(schema, references, value) {
         yield `Array.isArray(${value})`;
         const [parameter, accumulator] = [CreateParameter('value', 'any'), CreateParameter('acc', 'number')];
         if ((0, index_10.IsNumber)(schema.maxItems))
@@ -223,10 +223,10 @@ var TypeCompiler;
             yield `((${parameter}) => { ${block} )(${value})`;
         }
     }
-    function* TAsyncIterator(schema, references, value) {
+    function* FromAsyncIterator(schema, references, value) {
         yield `(typeof value === 'object' && Symbol.asyncIterator in ${value})`;
     }
-    function* TBigInt(schema, references, value) {
+    function* FromBigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
         if ((0, index_10.IsBigInt)(schema.exclusiveMaximum))
             yield `${value} < BigInt(${schema.exclusiveMaximum})`;
@@ -239,13 +239,13 @@ var TypeCompiler;
         if ((0, index_10.IsBigInt)(schema.multipleOf))
             yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
     }
-    function* TBoolean(schema, references, value) {
+    function* FromBoolean(schema, references, value) {
         yield `(typeof ${value} === 'boolean')`;
     }
-    function* TConstructor(schema, references, value) {
+    function* FromConstructor(schema, references, value) {
         yield* Visit(schema.returns, references, `${value}.prototype`);
     }
-    function* TDate(schema, references, value) {
+    function* FromDate(schema, references, value) {
         yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
         if ((0, index_10.IsNumber)(schema.exclusiveMaximumTimestamp))
             yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
@@ -258,10 +258,10 @@ var TypeCompiler;
         if ((0, index_10.IsNumber)(schema.multipleOfTimestamp))
             yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`;
     }
-    function* TFunction(schema, references, value) {
+    function* FromFunction(schema, references, value) {
         yield `(typeof ${value} === 'function')`;
     }
-    function* TInteger(schema, references, value) {
+    function* FromInteger(schema, references, value) {
         yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
         if ((0, index_10.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
@@ -274,7 +274,7 @@ var TypeCompiler;
         if ((0, index_10.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
-    function* TIntersect(schema, references, value) {
+    function* FromIntersect(schema, references, value) {
         const check1 = schema.allOf.map((schema) => CreateExpression(schema, references, value)).join(' && ');
         if (schema.unevaluatedProperties === false) {
             const keyCheck = CreateVariable(`${new RegExp((0, index_8.KeyOfPattern)(schema))};`);
@@ -290,10 +290,10 @@ var TypeCompiler;
             yield `(${check1})`;
         }
     }
-    function* TIterator(schema, references, value) {
+    function* FromIterator(schema, references, value) {
         yield `(typeof value === 'object' && Symbol.iterator in ${value})`;
     }
-    function* TLiteral(schema, references, value) {
+    function* FromLiteral(schema, references, value) {
         if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
             yield `(${value} === ${schema.const})`;
         }
@@ -301,17 +301,17 @@ var TypeCompiler;
             yield `(${value} === '${LiteralString.Escape(schema.const)}')`;
         }
     }
-    function* TNever(schema, references, value) {
+    function* FromNever(schema, references, value) {
         yield `false`;
     }
-    function* TNot(schema, references, value) {
+    function* FromNot(schema, references, value) {
         const expression = CreateExpression(schema.not, references, value);
         yield `(!${expression})`;
     }
-    function* TNull(schema, references, value) {
+    function* FromNull(schema, references, value) {
         yield `(${value} === null)`;
     }
-    function* TNumber(schema, references, value) {
+    function* FromNumber(schema, references, value) {
         yield Policy.IsNumberLike(value);
         if ((0, index_10.IsNumber)(schema.exclusiveMaximum))
             yield `${value} < ${schema.exclusiveMaximum}`;
@@ -324,7 +324,7 @@ var TypeCompiler;
         if ((0, index_10.IsNumber)(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
     }
-    function* TObject(schema, references, value) {
+    function* FromObject(schema, references, value) {
         yield Policy.IsObjectLike(value);
         if ((0, index_10.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
@@ -359,10 +359,10 @@ var TypeCompiler;
             yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
         }
     }
-    function* TPromise(schema, references, value) {
+    function* FromPromise(schema, references, value) {
         yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
     }
-    function* TRecord(schema, references, value) {
+    function* FromRecord(schema, references, value) {
         yield Policy.IsRecordLike(value);
         if ((0, index_10.IsNumber)(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
@@ -375,7 +375,7 @@ var TypeCompiler;
         const expression = `(${variable}.test(key) ? ${check1} : ${check2})`;
         yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`;
     }
-    function* TRef(schema, references, value) {
+    function* FromRef(schema, references, value) {
         const target = (0, index_4.Deref)(schema, references);
         // Reference: If we have seen this reference before we can just yield and return the function call.
         // If this isn't the case we defer to visit to generate and set the function for subsequent passes.
@@ -383,7 +383,7 @@ var TypeCompiler;
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
         yield* Visit(target, references, value);
     }
-    function* TString(schema, references, value) {
+    function* FromString(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
         if ((0, index_10.IsNumber)(schema.maxLength))
             yield `${value}.length <= ${schema.maxLength}`;
@@ -397,19 +397,19 @@ var TypeCompiler;
             yield `format('${schema.format}', ${value})`;
         }
     }
-    function* TSymbol(schema, references, value) {
+    function* FromSymbol(schema, references, value) {
         yield `(typeof ${value} === 'symbol')`;
     }
-    function* TTemplateLiteral(schema, references, value) {
+    function* FromTemplateLiteral(schema, references, value) {
         yield `(typeof ${value} === 'string')`;
         const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
         yield `${variable}.test(${value})`;
     }
-    function* TThis(schema, references, value) {
+    function* FromThis(schema, references, value) {
         // Note: This types are assured to be hoisted prior to this call. Just yield the function.
         yield `${CreateFunctionName(schema.$ref)}(${value})`;
     }
-    function* TTuple(schema, references, value) {
+    function* FromTuple(schema, references, value) {
         yield `Array.isArray(${value})`;
         if (schema.items === undefined)
             return yield `${value}.length === 0`;
@@ -419,27 +419,27 @@ var TypeCompiler;
             yield `${expression}`;
         }
     }
-    function* TUndefined(schema, references, value) {
+    function* FromUndefined(schema, references, value) {
         yield `${value} === undefined`;
     }
-    function* TUnion(schema, references, value) {
+    function* FromUnion(schema, references, value) {
         const expressions = schema.anyOf.map((schema) => CreateExpression(schema, references, value));
         yield `(${expressions.join(' || ')})`;
     }
-    function* TUint8Array(schema, references, value) {
+    function* FromUint8Array(schema, references, value) {
         yield `${value} instanceof Uint8Array`;
         if ((0, index_10.IsNumber)(schema.maxByteLength))
             yield `(${value}.length <= ${schema.maxByteLength})`;
         if ((0, index_10.IsNumber)(schema.minByteLength))
             yield `(${value}.length >= ${schema.minByteLength})`;
     }
-    function* TUnknown(schema, references, value) {
+    function* FromUnknown(schema, references, value) {
         yield 'true';
     }
-    function* TVoid(schema, references, value) {
+    function* FromVoid(schema, references, value) {
         yield Policy.IsVoidLike(value);
     }
-    function* TKind(schema, references, value) {
+    function* FromKind(schema, references, value) {
         const instance = state.instances.size;
         state.instances.set(instance, schema);
         yield `kind('${schema[index_6.Kind]}', ${instance}, ${value})`;
@@ -463,69 +463,69 @@ var TypeCompiler;
         }
         switch (schema_[index_6.Kind]) {
             case 'Any':
-                return yield* TAny(schema_, references_, value);
+                return yield* FromAny(schema_, references_, value);
             case 'Array':
-                return yield* TArray(schema_, references_, value);
+                return yield* FromArray(schema_, references_, value);
             case 'AsyncIterator':
-                return yield* TAsyncIterator(schema_, references_, value);
+                return yield* FromAsyncIterator(schema_, references_, value);
             case 'BigInt':
-                return yield* TBigInt(schema_, references_, value);
+                return yield* FromBigInt(schema_, references_, value);
             case 'Boolean':
-                return yield* TBoolean(schema_, references_, value);
+                return yield* FromBoolean(schema_, references_, value);
             case 'Constructor':
-                return yield* TConstructor(schema_, references_, value);
+                return yield* FromConstructor(schema_, references_, value);
             case 'Date':
-                return yield* TDate(schema_, references_, value);
+                return yield* FromDate(schema_, references_, value);
             case 'Function':
-                return yield* TFunction(schema_, references_, value);
+                return yield* FromFunction(schema_, references_, value);
             case 'Integer':
-                return yield* TInteger(schema_, references_, value);
+                return yield* FromInteger(schema_, references_, value);
             case 'Intersect':
-                return yield* TIntersect(schema_, references_, value);
+                return yield* FromIntersect(schema_, references_, value);
             case 'Iterator':
-                return yield* TIterator(schema_, references_, value);
+                return yield* FromIterator(schema_, references_, value);
             case 'Literal':
-                return yield* TLiteral(schema_, references_, value);
+                return yield* FromLiteral(schema_, references_, value);
             case 'Never':
-                return yield* TNever(schema_, references_, value);
+                return yield* FromNever(schema_, references_, value);
             case 'Not':
-                return yield* TNot(schema_, references_, value);
+                return yield* FromNot(schema_, references_, value);
             case 'Null':
-                return yield* TNull(schema_, references_, value);
+                return yield* FromNull(schema_, references_, value);
             case 'Number':
-                return yield* TNumber(schema_, references_, value);
+                return yield* FromNumber(schema_, references_, value);
             case 'Object':
-                return yield* TObject(schema_, references_, value);
+                return yield* FromObject(schema_, references_, value);
             case 'Promise':
-                return yield* TPromise(schema_, references_, value);
+                return yield* FromPromise(schema_, references_, value);
             case 'Record':
-                return yield* TRecord(schema_, references_, value);
+                return yield* FromRecord(schema_, references_, value);
             case 'Ref':
-                return yield* TRef(schema_, references_, value);
+                return yield* FromRef(schema_, references_, value);
             case 'String':
-                return yield* TString(schema_, references_, value);
+                return yield* FromString(schema_, references_, value);
             case 'Symbol':
-                return yield* TSymbol(schema_, references_, value);
+                return yield* FromSymbol(schema_, references_, value);
             case 'TemplateLiteral':
-                return yield* TTemplateLiteral(schema_, references_, value);
+                return yield* FromTemplateLiteral(schema_, references_, value);
             case 'This':
-                return yield* TThis(schema_, references_, value);
+                return yield* FromThis(schema_, references_, value);
             case 'Tuple':
-                return yield* TTuple(schema_, references_, value);
+                return yield* FromTuple(schema_, references_, value);
             case 'Undefined':
-                return yield* TUndefined(schema_, references_, value);
+                return yield* FromUndefined(schema_, references_, value);
             case 'Union':
-                return yield* TUnion(schema_, references_, value);
+                return yield* FromUnion(schema_, references_, value);
             case 'Uint8Array':
-                return yield* TUint8Array(schema_, references_, value);
+                return yield* FromUint8Array(schema_, references_, value);
             case 'Unknown':
-                return yield* TUnknown(schema_, references_, value);
+                return yield* FromUnknown(schema_, references_, value);
             case 'Void':
-                return yield* TVoid(schema_, references_, value);
+                return yield* FromVoid(schema_, references_, value);
             default:
                 if (!index_7.TypeRegistry.Has(schema_[index_6.Kind]))
                     throw new TypeCompilerUnknownTypeError(schema);
-                return yield* TKind(schema_, references_, value);
+                return yield* FromKind(schema_, references_, value);
         }
     }
     // ----------------------------------------------------------------