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

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

package/build/require/value/transform/decode.js

@@ -49,13 +49,13 @@ function Default(schema, value) {
     }
 }
 // prettier-ignore
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     return ((0, index_6.IsArray)(value))
         ? Default(schema, value.map((value) => Visit(schema.items, references, value)))
         : Default(schema, value);
 }
 // prettier-ignore
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     if (!(0, index_6.IsPlainObject)(value) || (0, index_6.IsValueType)(value))
         return Default(schema, value);
     const knownKeys = (0, index_2.KeyOfPropertyKeys)(schema);
@@ -76,11 +76,11 @@ function TIntersect(schema, references, value) {
     }, knownProperties);
     return Default(schema, unknownProperties);
 }
-function TNot(schema, references, value) {
+function FromNot(schema, references, value) {
     return Default(schema, Visit(schema.not, references, value));
 }
 // prettier-ignore
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     if (!(0, index_6.IsPlainObject)(value))
         return Default(schema, value);
     const knownKeys = (0, index_2.KeyOfPropertyKeys)(schema);
@@ -102,7 +102,7 @@ function TObject(schema, references, value) {
     return Default(schema, unknownProperties);
 }
 // prettier-ignore
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     if (!(0, index_6.IsPlainObject)(value))
         return Default(schema, value);
     const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
@@ -125,23 +125,23 @@ function TRecord(schema, references, value) {
     return Default(schema, unknownProperties);
 }
 // prettier-ignore
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     const target = (0, index_4.Deref)(schema, references);
     return Default(schema, Visit(target, references, value));
 }
 // prettier-ignore
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     const target = (0, index_4.Deref)(schema, references);
     return Default(schema, Visit(target, references, value));
 }
 // prettier-ignore
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     return ((0, index_6.IsArray)(value) && (0, index_6.IsArray)(schema.items))
         ? Default(schema, schema.items.map((schema, index) => Visit(schema, references, value[index])))
         : Default(schema, value);
 }
 // prettier-ignore
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     for (const subschema of schema.anyOf) {
         if (!(0, index_5.Check)(subschema, references, value))
             continue;
@@ -157,25 +157,25 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema[index_1.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 'Not':
-            return TNot(schema_, references_, value);
+            return FromNot(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 'Symbol':
             return Default(schema_, 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 Default(schema_, value);
     }

package/build/require/value/transform/encode.js

@@ -48,14 +48,14 @@ function Default(schema, value) {
     }
 }
 // prettier-ignore
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     const defaulted = Default(schema, value);
     return (0, index_6.IsArray)(defaulted)
         ? defaulted.map((value) => Visit(schema.items, references, value))
         : defaulted;
 }
 // prettier-ignore
-function TIntersect(schema, references, value) {
+function FromIntersect(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_6.IsPlainObject)(value) || (0, index_6.IsValueType)(value))
         return defaulted;
@@ -77,11 +77,11 @@ function TIntersect(schema, references, value) {
     }, knownProperties);
 }
 // prettier-ignore
-function TNot(schema, references, value) {
+function FromNot(schema, references, value) {
     return Default(schema.not, Default(schema, value));
 }
 // prettier-ignore
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_6.IsPlainObject)(value))
         return defaulted;
@@ -103,7 +103,7 @@ function TObject(schema, references, value) {
     }, knownProperties);
 }
 // prettier-ignore
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     const defaulted = Default(schema, value);
     if (!(0, index_6.IsPlainObject)(value))
         return defaulted;
@@ -126,24 +126,24 @@ function TRecord(schema, references, value) {
     }, knownProperties);
 }
 // prettier-ignore
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     const target = (0, index_4.Deref)(schema, references);
     const resolved = Visit(target, references, value);
     return Default(schema, resolved);
 }
 // prettier-ignore
-function TThis(schema, references, value) {
+function FromThis(schema, references, value) {
     const target = (0, index_4.Deref)(schema, references);
     const resolved = Visit(target, references, value);
     return Default(schema, resolved);
 }
 // prettier-ignore
-function TTuple(schema, references, value) {
+function FromTuple(schema, references, value) {
     const value1 = Default(schema, value);
     return (0, index_6.IsArray)(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, value1[index])) : [];
 }
 // prettier-ignore
-function TUnion(schema, references, value) {
+function FromUnion(schema, references, value) {
     // test value against union variants
     for (const subschema of schema.anyOf) {
         if (!(0, index_5.Check)(subschema, references, value))
@@ -166,23 +166,23 @@ function Visit(schema, references, value) {
     const schema_ = schema;
     switch (schema[index_1.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 'Not':
-            return TNot(schema_, references_, value);
+            return FromNot(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 Default(schema_, value);
     }