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

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-19",
+  "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 has a modular type system that supports selective type imports. Using selective imports can be useful in resource constrained environments as the technique enables modern bundlers to tree shake unused code leading to reduced bundle sizes. The following selectively imports a few types.
+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 each key (`K`) as the second. This type can be used with Conditional and Indexed Access types to allow for generalized property remapping irrespective of property type. The following example remaps each property of `T` to be `T[K] | null`.
+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,51 +975,16 @@ const T = Type.Object({                              // const T: TObject<{
   z: Type.Boolean()                                  //   z: TBoolean
 })                                                   // }>
 
-const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = {
-  return Type.Union([                                //   [K in keyof T]: T[K] | null
-    Type.Index(T, K),                                // }
-    Type.Null()                                      //
-  ])                                                 // ... runtime mapped as
-})                                                   //
+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<{
-                                                     //   x: TUnion<[TNumber, TNull]>,
-                                                     //   y: TUnion<[TString, TNull]>,
-                                                     //   z: TUnion<[TBoolean, TNull]>
-                                                     // }>
-```
-
-<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,
+                                                     //   x: TOptional<TNumber>,
+                                                     //   y: TOptional<TString>,
+                                                     //   z: TOptional<TBoolean>
                                                      // }>
 ```
 
@@ -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'
                                                      //     }
                                                      //   }
                                                      // }