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

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

package/build/import/value/create/create.mjs

@@ -1,7 +1,7 @@
 import { HasPropertyKey, IsString } from '../guard/index.mjs';
 import { Check } from '../check/index.mjs';
 import { Deref } from '../deref/index.mjs';
-import { TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGenerate } from '../../type/template-literal/index.mjs';
+import { TemplateLiteralGenerate, IsTemplateLiteralFinite } from '../../type/template-literal/index.mjs';
 import { PatternStringExact, PatternNumberExact } from '../../type/patterns/index.mjs';
 import { TypeRegistry } from '../../type/registry/index.mjs';
 import { Kind } from '../../type/symbols/index.mjs';
@@ -55,7 +55,7 @@ export class ValueCreateRecursiveInstantiationError extends Error {
 // ------------------------------------------------------------------
 // Create
 // ------------------------------------------------------------------
-function TAny(schema, references) {
+function FromAny(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -63,7 +63,7 @@ function TAny(schema, references) {
         return {};
     }
 }
-function TArray(schema, references) {
+function FromArray(schema, references) {
     if (schema.uniqueItems === true && !HasPropertyKey(schema, 'default')) {
         throw new Error('ValueCreate.Array: Array with the uniqueItems constraint requires a default value');
     }
@@ -82,7 +82,7 @@ function TArray(schema, references) {
         return [];
     }
 }
-function TAsyncIterator(schema, references) {
+function FromAsyncIterator(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -90,7 +90,7 @@ function TAsyncIterator(schema, references) {
         return (async function* () { })();
     }
 }
-function TBigInt(schema, references) {
+function FromBigInt(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -98,7 +98,7 @@ function TBigInt(schema, references) {
         return BigInt(0);
     }
 }
-function TBoolean(schema, references) {
+function FromBoolean(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -106,7 +106,7 @@ function TBoolean(schema, references) {
         return false;
     }
 }
-function TConstructor(schema, references) {
+function FromConstructor(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -128,7 +128,7 @@ function TConstructor(schema, references) {
         }
     }
 }
-function TDate(schema, references) {
+function FromDate(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -139,7 +139,7 @@ function TDate(schema, references) {
         return new Date();
     }
 }
-function TFunction(schema, references) {
+function FromFunction(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -147,7 +147,7 @@ function TFunction(schema, references) {
         return () => Visit(schema.returns, references);
     }
 }
-function TInteger(schema, references) {
+function FromInteger(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -158,7 +158,7 @@ function TInteger(schema, references) {
         return 0;
     }
 }
-function TIntersect(schema, references) {
+function FromIntersect(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -179,7 +179,7 @@ function TIntersect(schema, references) {
         return value;
     }
 }
-function TIterator(schema, references) {
+function FromIterator(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -187,7 +187,7 @@ function TIterator(schema, references) {
         return (function* () { })();
     }
 }
-function TLiteral(schema, references) {
+function FromLiteral(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -195,10 +195,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 (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -206,7 +206,7 @@ function TNot(schema, references) {
         throw new ValueCreateNotTypeError(schema);
     }
 }
-function TNull(schema, references) {
+function FromNull(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -214,7 +214,7 @@ function TNull(schema, references) {
         return null;
     }
 }
-function TNumber(schema, references) {
+function FromNumber(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -225,7 +225,7 @@ function TNumber(schema, references) {
         return 0;
     }
 }
-function TObject(schema, references) {
+function FromObject(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -237,7 +237,7 @@ function TObject(schema, references) {
             }, {}));
     }
 }
-function TPromise(schema, references) {
+function FromPromise(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -245,7 +245,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 (HasPropertyKey(schema, 'default')) {
         return schema.default;
@@ -260,7 +260,7 @@ function TRecord(schema, references) {
         return {};
     }
 }
-function TRef(schema, references) {
+function FromRef(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -268,7 +268,7 @@ function TRef(schema, references) {
         return Visit(Deref(schema, references), references);
     }
 }
-function TString(schema, references) {
+function FromString(schema, references) {
     if (schema.pattern !== undefined) {
         if (!HasPropertyKey(schema, 'default')) {
             throw new Error('ValueCreate.String: String types with patterns must specify a default value');
@@ -299,7 +299,7 @@ function TString(schema, references) {
         }
     }
 }
-function TSymbol(schema, references) {
+function FromSymbol(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -310,17 +310,16 @@ function TSymbol(schema, references) {
         return Symbol();
     }
 }
-function TTemplateLiteral(schema, references) {
+function FromTemplateLiteral(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
-    const expression = TemplateLiteralParseExact(schema.pattern);
-    if (!IsTemplateLiteralFinite(expression))
+    if (!IsTemplateLiteralFinite(schema))
         throw new ValueCreateTempateLiteralTypeError(schema);
-    const sequence = TemplateLiteralGenerate(expression);
-    return sequence.next().value;
+    const generated = TemplateLiteralGenerate(schema);
+    return generated[0];
 }
-function TThis(schema, references) {
+function FromThis(schema, references) {
     if (recursiveDepth++ > recursiveMaxDepth)
         throw new ValueCreateRecursiveInstantiationError(schema, recursiveMaxDepth);
     if (HasPropertyKey(schema, 'default')) {
@@ -330,7 +329,7 @@ function TThis(schema, references) {
         return Visit(Deref(schema, references), references);
     }
 }
-function TTuple(schema, references) {
+function FromTuple(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -341,7 +340,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 (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -349,7 +348,7 @@ function TUndefined(schema, references) {
         return undefined;
     }
 }
-function TUnion(schema, references) {
+function FromUnion(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -360,7 +359,7 @@ function TUnion(schema, references) {
         return Visit(schema.anyOf[0], references);
     }
 }
-function TUint8Array(schema, references) {
+function FromUint8Array(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -371,7 +370,7 @@ function TUint8Array(schema, references) {
         return new Uint8Array(0);
     }
 }
-function TUnknown(schema, references) {
+function FromUnknown(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -379,7 +378,7 @@ function TUnknown(schema, references) {
         return {};
     }
 }
-function TVoid(schema, references) {
+function FromVoid(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -387,7 +386,7 @@ function TVoid(schema, references) {
         return void 0;
     }
 }
-function TKind(schema, references) {
+function FromKind(schema, references) {
     if (HasPropertyKey(schema, 'default')) {
         return schema.default;
     }
@@ -400,69 +399,69 @@ function Visit(schema, references) {
     const schema_ = schema;
     switch (schema_[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 (!TypeRegistry.Has(schema_[Kind]))
                 throw new ValueCreateUnknownTypeError(schema_);
-            return TKind(schema_, references_);
+            return FromKind(schema_, references_);
     }
 }
 // ------------------------------------------------------------------

package/build/import/value/default/default.mjs

@@ -32,7 +32,7 @@ function IsDefaultSchema(value) {
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
-function TArray(schema, references, value) {
+function FromArray(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     if (!IsArray(defaulted))
         return defaulted;
@@ -41,14 +41,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 IsObject(next) ? { ...acc, ...next } : next;
     }, {});
 }
-function TObject(schema, references, value) {
+function FromObject(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     if (!IsObject(defaulted))
         return defaulted;
@@ -71,7 +71,7 @@ function TObject(schema, references, value) {
     }
     return defaulted;
 }
-function TRecord(schema, references, value) {
+function FromRecord(schema, references, value) {
     const defaulted = ValueOrDefault(schema, value);
     if (!IsObject(defaulted))
         return defaulted;
@@ -95,13 +95,13 @@ function TRecord(schema, references, value) {
     }
     return defaulted;
 }
-function TRef(schema, references, value) {
+function FromRef(schema, references, value) {
     return Visit(Deref(schema, references), references, ValueOrDefault(schema, 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) {
     const defaulted = ValueOrDefault(schema, value);
     if (!IsArray(defaulted) || IsUndefined(schema.items))
         return defaulted;
@@ -112,7 +112,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);
@@ -127,21 +127,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 ValueOrDefault(schema_, value);
     }