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

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

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

@@ -13,67 +13,67 @@ const type_1 = require("../../type/guard/type");
 // ------------------------------------------------------------------
 const index_3 = require("../guard/index");
 // prettier-ignore
-function TArray(schema, references) {
+function FromArray(schema, references) {
     return (0, type_1.IsTransform)(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
-function TAsyncIterator(schema, references) {
+function FromAsyncIterator(schema, references) {
     return (0, type_1.IsTransform)(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
-function TConstructor(schema, references) {
+function FromConstructor(schema, references) {
     return (0, type_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
-function TFunction(schema, references) {
+function FromFunction(schema, references) {
     return (0, type_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
-function TIntersect(schema, references) {
+function FromIntersect(schema, references) {
     return (0, type_1.IsTransform)(schema) || (0, type_1.IsTransform)(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
-function TIterator(schema, references) {
+function FromIterator(schema, references) {
     return (0, type_1.IsTransform)(schema) || Visit(schema.items, references);
 }
 // prettier-ignore
-function TNot(schema, references) {
+function FromNot(schema, references) {
     return (0, type_1.IsTransform)(schema) || Visit(schema.not, references);
 }
 // prettier-ignore
-function TObject(schema, references) {
+function FromObject(schema, references) {
     return ((0, type_1.IsTransform)(schema) ||
         Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
         ((0, type_1.IsSchema)(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
 }
 // prettier-ignore
-function TPromise(schema, references) {
+function FromPromise(schema, references) {
     return (0, type_1.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 (0, type_1.IsTransform)(schema) || Visit(property, references) || ((0, type_1.IsSchema)(schema.additionalProperties) && (0, type_1.IsTransform)(schema.additionalProperties));
 }
 // prettier-ignore
-function TRef(schema, references) {
+function FromRef(schema, references) {
     if ((0, type_1.IsTransform)(schema))
         return true;
     return Visit((0, index_1.Deref)(schema, references), references);
 }
 // prettier-ignore
-function TThis(schema, references) {
+function FromThis(schema, references) {
     if ((0, type_1.IsTransform)(schema))
         return true;
     return Visit((0, index_1.Deref)(schema, references), references);
 }
 // prettier-ignore
-function TTuple(schema, references) {
+function FromTuple(schema, references) {
     return (0, type_1.IsTransform)(schema) || (!(0, index_3.IsUndefined)(schema.items) && schema.items.some((schema) => Visit(schema, references)));
 }
 // prettier-ignore
-function TUnion(schema, references) {
+function FromUnion(schema, references) {
     return (0, type_1.IsTransform)(schema) || schema.anyOf.some((schema) => Visit(schema, references));
 }
 // prettier-ignore
@@ -86,33 +86,33 @@ function Visit(schema, references) {
         visited.add(schema.$id);
     switch (schema[index_2.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 (0, type_1.IsTransform)(schema);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.0-dev-20",
+  "version": "0.32.0-dev-21",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -51,9 +51,9 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that creates in-memory Json Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard Json Schema validation.
+TypeBox is a runtime type builder that creates in-memory Json Schema objects that infer as TypeScript types. The Json Schema produced by this library is designed to match the static type checking rules of the TypeScript compiler. TypeBox provides a unified type that can be statically checked by the TypeScript compiler and runtime asserted using standard Json Schema validation.
 
-This library enables Json Schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire.
+This library enables Json Schema to be created with the same expressiveness as TypeScript's type system. It can be used either as a simple tool to build up complex schematics or integrated into REST or RPC services to help validate data received over the wire.
 
 License MIT
 
@@ -70,9 +70,9 @@ License MIT
   - [Generics](#types-generics)
   - [References](#types-references)
   - [Recursive](#types-recursive)
+  - [Template Literal](#types-template-literal)
   - [Conditional](#types-conditional)
   - [Mapped](#types-mapped)
-  - [Template Literal](#types-templateliteral)
   - [Indexed](#types-indexed)
   - [Intrinsic](#types-intrinsic)
   - [Transform](#types-transform)
@@ -647,7 +647,7 @@ TypeBox provides an extended type set that can be used to create schematics for
 
 ### Modules
 
-TypeBox supports a modular type system that allows for selective type imports. Using selective imports can be helpful in resource constrained environments as it enables modern bundlers to tree shake unused types, this leading to reduced bundle sizes.
+TypeBox supports a modular type system that allows for selective type imports. Using selective imports can be helpful in resource constrained environments as it enables modern bundlers to tree shake unused types. This can lead to reduced bundle sizes.
 
 ```typescript
 import { Object, Number, String, Boolean, type Static } from '@sinclair/typebox'
@@ -882,6 +882,41 @@ function test(node: Node) {
 }
 ```
 
+<a name='types-template-literal'></a>
+
+### Template Literal Types
+
+TypeBox supports template literals with Type.TemplateLiteral. This type can be created using a syntax similar to the TypeScript template literal syntax or composed from exterior types. TypeBox encodes template literals as regular expression patterns which enables the template to be checked by Json Schema validators. This type also supports regular expression parsing, enabling template patterns to be used for generative types. The following shows both TypeScript and TypeBox usage.
+
+```typescript
+// TypeScript
+
+type K = `prop${'A'|'B'|'C'}`                        // type T = 'propA' | 'propB' | 'propC'
+
+type R = Record<K, string>                           // type R = {
+                                                     //   propA: string
+                                                     //   propB: string
+                                                     //   propC: string
+                                                     // }
+
+// TypeBox
+
+const K = Type.TemplateLiteral('prop${A|B|C}')       // const K: TTemplateLiteral<[
+                                                     //   TLiteral<'prop'>,
+                                                     //   TUnion<[
+                                                     //      TLiteral<'A'>,
+                                                     //      TLiteral<'B'>,
+                                                     //      TLiteral<'C'>,
+                                                     //   ]>
+                                                     // ]>
+
+const R = Type.Record(K, Type.String())              // const R: TObject<{
+                                                     //   hello1: TString,
+                                                     //   hello2: TString,
+                                                     //   hello3: TString,
+                                                     // }>
+```
+
 <a name='types-conditional'></a>
 
 ### Conditional Types
@@ -931,7 +966,7 @@ const T = Type.Exclude(                              // const T: TUnion<[
 
 ### Mapped Types
 
-TypeBox supports Mapped types with Type.Mapped. This type accepts a union of property keys as the first argument, and a type mapping function which accepts a distributive key (`K`) as the second. The following remaps each property of `T` to be optional.
+TypeBox supports Mapped types with Type.Mapped. This type accepts two arguments, the first a union of literal keys and the second a type mapping function which receives a mapping key `K`. The following remaps the type `T` to be `Partial<T>` using type mapping.
 
 ```typescript
 const T = Type.Object({                              // const T: TObject<{
@@ -940,10 +975,10 @@ const T = Type.Object({                              // const T: TObject<{
   z: Type.Boolean()                                  //   z: TBoolean
 })                                                   // }>
 
-const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = {
-  return Type.Optional(Type.Index(T, K))             //   [K in keyof T]?: T[K]
-})                                                   // }
-                                                     //
+const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = { [K in keyof T]?: T[K] }
+  return Type.Optional(Type.Index(T, K))             //
+})                                                   // 
+                                                     
                                                      // ... runtime mapped as
                                                      //
                                                      // const M: TObject<{
@@ -953,41 +988,6 @@ const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = {
                                                      // }>
 ```
 
-<a name='types-templateliteral'></a>
-
-### Template Literal Types
-
-TypeBox supports template literals with Type.TemplateLiteral. This type can be created using a syntax similar to the TypeScript template literal syntax or composed from exterior types. TypeBox encodes template literals as regular expression patterns which enables the template to be checked by Json Schema validators. This type also supports regular expression parsing, enabling template patterns to be used for generative types. The following shows both TypeScript and TypeBox usage.
-
-```typescript
-// TypeScript
-
-type K = `prop${'A'|'B'|'C'}`                        // type T = 'propA' | 'propB' | 'propC'
-
-type R = Record<K, string>                           // type R = {
-                                                     //   propA: string
-                                                     //   propB: string
-                                                     //   propC: string
-                                                     // }
-
-// TypeBox
-
-const K = Type.TemplateLiteral('prop${A|B|C}')       // const K: TTemplateLiteral<[
-                                                     //   TLiteral<'prop'>,
-                                                     //   TUnion<[
-                                                     //      TLiteral<'A'>,
-                                                     //      TLiteral<'B'>,
-                                                     //      TLiteral<'C'>,
-                                                     //   ]>
-                                                     // ]>
-
-const R = Type.Record(K, Type.String())              // const R: TObject<{
-                                                     //   hello1: TString,
-                                                     //   hello2: TString,
-                                                     //   hello3: TString,
-                                                     // }>
-```
-
 <a name='types-indexed'></a>
 
 ### Indexed Access Types
@@ -1157,13 +1157,13 @@ TypeBox types contain various symbol properties that are used for reflection, co
 
 ```typescript
 const T = Type.Object({                              // const T = {
-  name: Type.Optional(Type.String())                 //   [Kind]: 'Object',
+  name: Type.Optional(Type.String())                 //   [Symbol(TypeBox.Kind)]: 'Object',
 })                                                   //   type: 'object',
                                                      //   properties: {
                                                      //     name: {
                                                      //       type: 'string',
-                                                     //       [Kind]: 'String',
-                                                     //       [Optional]: 'Optional'
+                                                     //       [Symbol(TypeBox.Kind)]: 'String',
+                                                     //       [Symbol(TypeBox.Optional)]: 'Optional'
                                                      //     }
                                                      //   }
                                                      // }