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

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);
     }

package/build/require/value/create/create.js

@@ -58,7 +58,7 @@ exports.ValueCreateRecursiveInstantiationError = ValueCreateRecursiveInstantiati
 // ------------------------------------------------------------------
 // Create
 // ------------------------------------------------------------------
-function TAny(schema, references) {
+function FromAny(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -66,7 +66,7 @@ function TAny(schema, references) {
         return {};
     }
 }
-function TArray(schema, references) {
+function FromArray(schema, references) {
     if (schema.uniqueItems === true && !(0, index_1.HasPropertyKey)(schema, 'default')) {
         throw new Error('ValueCreate.Array: Array with the uniqueItems constraint requires a default value');
     }
@@ -85,7 +85,7 @@ function TArray(schema, references) {
         return [];
     }
 }
-function TAsyncIterator(schema, references) {
+function FromAsyncIterator(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -93,7 +93,7 @@ function TAsyncIterator(schema, references) {
         return (async function* () { })();
     }
 }
-function TBigInt(schema, references) {
+function FromBigInt(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -101,7 +101,7 @@ function TBigInt(schema, references) {
         return BigInt(0);
     }
 }
-function TBoolean(schema, references) {
+function FromBoolean(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -109,7 +109,7 @@ function TBoolean(schema, references) {
         return false;
     }
 }
-function TConstructor(schema, references) {
+function FromConstructor(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -131,7 +131,7 @@ function TConstructor(schema, references) {
         }
     }
 }
-function TDate(schema, references) {
+function FromDate(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -142,7 +142,7 @@ function TDate(schema, references) {
         return new Date();
     }
 }
-function TFunction(schema, references) {
+function FromFunction(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -150,7 +150,7 @@ function TFunction(schema, references) {
         return () => Visit(schema.returns, references);
     }
 }
-function TInteger(schema, references) {
+function FromInteger(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -161,7 +161,7 @@ function TInteger(schema, references) {
         return 0;
     }
 }
-function TIntersect(schema, references) {
+function FromIntersect(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -182,7 +182,7 @@ function TIntersect(schema, references) {
         return value;
     }
 }
-function TIterator(schema, references) {
+function FromIterator(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -190,7 +190,7 @@ function TIterator(schema, references) {
         return (function* () { })();
     }
 }
-function TLiteral(schema, references) {
+function FromLiteral(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -198,10 +198,10 @@ function TLiteral(schema, references) {
         return schema.const;
     }
 }
-function TNever(schema, references) {
+function FromNever(schema, references) {
     throw new ValueCreateNeverTypeError(schema);
 }
-function TNot(schema, references) {
+function FromNot(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -209,7 +209,7 @@ function TNot(schema, references) {
         throw new ValueCreateNotTypeError(schema);
     }
 }
-function TNull(schema, references) {
+function FromNull(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -217,7 +217,7 @@ function TNull(schema, references) {
         return null;
     }
 }
-function TNumber(schema, references) {
+function FromNumber(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -228,7 +228,7 @@ function TNumber(schema, references) {
         return 0;
     }
 }
-function TObject(schema, references) {
+function FromObject(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -240,7 +240,7 @@ function TObject(schema, references) {
             }, {}));
     }
 }
-function TPromise(schema, references) {
+function FromPromise(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -248,7 +248,7 @@ function TPromise(schema, references) {
         return Promise.resolve(Visit(schema.item, references));
     }
 }
-function TRecord(schema, references) {
+function FromRecord(schema, references) {
     const [keyPattern, valueSchema] = Object.entries(schema.patternProperties)[0];
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
@@ -263,7 +263,7 @@ function TRecord(schema, references) {
         return {};
     }
 }
-function TRef(schema, references) {
+function FromRef(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -271,7 +271,7 @@ function TRef(schema, references) {
         return Visit((0, index_3.Deref)(schema, references), references);
     }
 }
-function TString(schema, references) {
+function FromString(schema, references) {
     if (schema.pattern !== undefined) {
         if (!(0, index_1.HasPropertyKey)(schema, 'default')) {
             throw new Error('ValueCreate.String: String types with patterns must specify a default value');
@@ -302,7 +302,7 @@ function TString(schema, references) {
         }
     }
 }
-function TSymbol(schema, references) {
+function FromSymbol(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -313,17 +313,16 @@ function TSymbol(schema, references) {
         return Symbol();
     }
 }
-function TTemplateLiteral(schema, references) {
+function FromTemplateLiteral(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
-    const expression = (0, index_4.TemplateLiteralParseExact)(schema.pattern);
-    if (!(0, index_4.IsTemplateLiteralFinite)(expression))
+    if (!(0, index_4.IsTemplateLiteralFinite)(schema))
         throw new ValueCreateTempateLiteralTypeError(schema);
-    const sequence = (0, index_4.TemplateLiteralGenerate)(expression);
-    return sequence.next().value;
+    const generated = (0, index_4.TemplateLiteralGenerate)(schema);
+    return generated[0];
 }
-function TThis(schema, references) {
+function FromThis(schema, references) {
     if (recursiveDepth++ > recursiveMaxDepth)
         throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth);
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
@@ -333,7 +332,7 @@ function TThis(schema, references) {
         return Visit((0, index_3.Deref)(schema, references), references);
     }
 }
-function TTuple(schema, references) {
+function FromTuple(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -344,7 +343,7 @@ function TTuple(schema, references) {
         return Array.from({ length: schema.minItems }).map((_, index) => Visit(schema.items[index], references));
     }
 }
-function TUndefined(schema, references) {
+function FromUndefined(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -352,7 +351,7 @@ function TUndefined(schema, references) {
         return undefined;
     }
 }
-function TUnion(schema, references) {
+function FromUnion(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -363,7 +362,7 @@ function TUnion(schema, references) {
         return Visit(schema.anyOf[0], references);
     }
 }
-function TUint8Array(schema, references) {
+function FromUint8Array(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -374,7 +373,7 @@ function TUint8Array(schema, references) {
         return new Uint8Array(0);
     }
 }
-function TUnknown(schema, references) {
+function FromUnknown(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -382,7 +381,7 @@ function TUnknown(schema, references) {
         return {};
     }
 }
-function TVoid(schema, references) {
+function FromVoid(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -390,7 +389,7 @@ function TVoid(schema, references) {
         return void 0;
     }
 }
-function TKind(schema, references) {
+function FromKind(schema, references) {
     if ((0, index_1.HasPropertyKey)(schema, 'default')) {
         return schema.default;
     }
@@ -403,69 +402,69 @@ function Visit(schema, references) {
     const schema_ = schema;
     switch (schema_[index_7.Kind]) {
         case 'Any':
-            return TAny(schema_, references_);
+            return FromAny(schema_, references_);
         case 'Array':
-            return TArray(schema_, references_);
+            return FromArray(schema_, references_);
         case 'AsyncIterator':
-            return TAsyncIterator(schema_, references_);
+            return FromAsyncIterator(schema_, references_);
         case 'BigInt':
-            return TBigInt(schema_, references_);
+            return FromBigInt(schema_, references_);
         case 'Boolean':
-            return TBoolean(schema_, references_);
+            return FromBoolean(schema_, references_);
         case 'Constructor':
-            return TConstructor(schema_, references_);
+            return FromConstructor(schema_, references_);
         case 'Date':
-            return TDate(schema_, references_);
+            return FromDate(schema_, references_);
         case 'Function':
-            return TFunction(schema_, references_);
+            return FromFunction(schema_, references_);
         case 'Integer':
-            return TInteger(schema_, references_);
+            return FromInteger(schema_, references_);
         case 'Intersect':
-            return TIntersect(schema_, references_);
+            return FromIntersect(schema_, references_);
         case 'Iterator':
-            return TIterator(schema_, references_);
+            return FromIterator(schema_, references_);
         case 'Literal':
-            return TLiteral(schema_, references_);
+            return FromLiteral(schema_, references_);
         case 'Never':
-            return TNever(schema_, references_);
+            return FromNever(schema_, references_);
         case 'Not':
-            return TNot(schema_, references_);
+            return FromNot(schema_, references_);
         case 'Null':
-            return TNull(schema_, references_);
+            return FromNull(schema_, references_);
         case 'Number':
-            return TNumber(schema_, references_);
+            return FromNumber(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 'String':
-            return TString(schema_, references_);
+            return FromString(schema_, references_);
         case 'Symbol':
-            return TSymbol(schema_, references_);
+            return FromSymbol(schema_, references_);
         case 'TemplateLiteral':
-            return TTemplateLiteral(schema_, references_);
+            return FromTemplateLiteral(schema_, references_);
         case 'This':
-            return TThis(schema_, references_);
+            return FromThis(schema_, references_);
         case 'Tuple':
-            return TTuple(schema_, references_);
+            return FromTuple(schema_, references_);
         case 'Undefined':
-            return TUndefined(schema_, references_);
+            return FromUndefined(schema_, references_);
         case 'Union':
-            return TUnion(schema_, references_);
+            return FromUnion(schema_, references_);
         case 'Uint8Array':
-            return TUint8Array(schema_, references_);
+            return FromUint8Array(schema_, references_);
         case 'Unknown':
-            return TUnknown(schema_, references_);
+            return FromUnknown(schema_, references_);
         case 'Void':
-            return TVoid(schema_, references_);
+            return FromVoid(schema_, references_);
         default:
             if (!index_6.TypeRegistry.Has(schema_[index_7.Kind]))
                 throw new ValueCreateUnknownTypeError(schema_);
-            return TKind(schema_, references_);
+            return FromKind(schema_, references_);
     }
 }
 // ------------------------------------------------------------------

package/build/require/value/default/default.js

@@ -36,7 +36,7 @@ function IsDefaultSchema(value) {
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     if (!(0, index_4.IsArray)(defaulted))
         return defaulted;
@@ -45,14 +45,14 @@ function TArray(schema, references, value) {
     }
     return defaulted;
 }
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     return schema.allOf.reduce((acc, schema) => {
         const next = Visit(schema, references, defaulted);
         return (0, index_4.IsObject)(next) ? { ...acc, ...next } : next;
     }, {});
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     if (!(0, index_4.IsObject)(defaulted))
         return defaulted;
@@ -75,7 +75,7 @@ function TObject(schema, references, value) {
     }
     return defaulted;
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     if (!(0, index_4.IsObject)(defaulted))
         return defaulted;
@@ -99,13 +99,13 @@ function TRecord(schema, references, value) {
     }
     return defaulted;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit((0, index_2.Deref)(schema, references), references, ValueOrDefault(schema, 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) {
     const defaulted = ValueOrDefault(schema, value);
     if (!(0, index_4.IsArray)(defaulted) || (0, index_4.IsUndefined)(schema.items))
         return defaulted;
@@ -116,7 +116,7 @@ function TTuple(schema, references, value) {
     }
     return defaulted;
 }
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     for (const inner of schema.anyOf) {
         const result = Visit(inner, references, defaulted);
@@ -131,21 +131,21 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema_[index_3.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 ValueOrDefault(schema_, value);
     }