@sinclair/typebox 0.34.2 → 0.34.4

package/build/cjs/type/module/compute.d.ts

@@ -6,6 +6,7 @@ import { type TAsyncIterator } from '../async-iterator/index';
 import { TComputed } from '../computed/index';
 import { type TConstructor } from '../constructor/index';
 import { type TIndex } from '../indexed/index';
+import { TEnum, TEnumRecord } from '../enum/index';
 import { type TFunction } from '../function/index';
 import { type TIntersect, type TIntersectEvaluated } from '../intersect/index';
 import { type TIterator } from '../iterator/index';
@@ -43,7 +44,7 @@ type TFromArray<ModuleProperties extends TProperties, Type extends TSchema> = (E
 type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TAsyncIterator<TFromType<ModuleProperties, Type>>);
 type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TIterator<TFromType<ModuleProperties, Type>>);
 type TFromRest<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
-export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TComputed<infer T extends string, infer S extends TSchema[]> ? TFromComputed<ModuleProperties, T, S> : Type extends TObject<infer S extends TProperties> ? TFromObject<ModuleProperties, S> : Type extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TFromConstructor<ModuleProperties, S, R> : Type extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFromFunction<ModuleProperties, S, R> : Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<ModuleProperties, S> : Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<ModuleProperties, S> : Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<ModuleProperties, S> : Type extends TArray<infer S extends TSchema> ? TFromArray<ModuleProperties, S> : Type extends TAsyncIterator<infer S extends TSchema> ? TFromAsyncIterator<ModuleProperties, S> : Type extends TIterator<infer S extends TSchema> ? TFromIterator<ModuleProperties, S> : Type);
+export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<ModuleProperties, Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Type : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<ModuleProperties, Types> : Type);
 export declare function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type>;
 export type TComputeType<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TFromType<ModuleProperties, ModuleProperties[Key]> : TNever);
 export declare function ComputeType<ModuleProperties extends TProperties, Key extends PropertyKey>(moduleProperties: ModuleProperties, key: Key): TComputeType<ModuleProperties, Key>;

package/build/cjs/type/module/compute.js

@@ -124,20 +124,19 @@ function FromRest(moduleProperties, types) {
 }
 // prettier-ignore
 function FromType(moduleProperties, type) {
-    return (
-    // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
-    // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
-    // be a priority as there is a potential for the current inference to break on TS compiler changes.
-    KindGuard.IsComputed(type) ? (0, index_1.CreateType)(FromComputed(moduleProperties, type.target, type.parameters)) :
-        KindGuard.IsObject(type) ? (0, index_1.CreateType)(FromObject(moduleProperties, type.properties), type) :
-            KindGuard.IsConstructor(type) ? (0, index_1.CreateType)(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
-                KindGuard.IsFunction(type) ? (0, index_1.CreateType)(FromFunction(moduleProperties, type.parameters, type.returns), type) :
-                    KindGuard.IsTuple(type) ? (0, index_1.CreateType)(FromTuple(moduleProperties, type.items || []), type) :
+    return (KindGuard.IsArray(type) ? (0, index_1.CreateType)(FromArray(moduleProperties, type.items), type) :
+        KindGuard.IsAsyncIterator(type) ? (0, index_1.CreateType)(FromAsyncIterator(moduleProperties, type.items), type) :
+            // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
+            // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
+            // be a priority as there is a potential for the current inference to break on TS compiler changes.
+            KindGuard.IsComputed(type) ? (0, index_1.CreateType)(FromComputed(moduleProperties, type.target, type.parameters)) :
+                KindGuard.IsConstructor(type) ? (0, index_1.CreateType)(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
+                    KindGuard.IsFunction(type) ? (0, index_1.CreateType)(FromFunction(moduleProperties, type.parameters, type.returns), type) :
                         KindGuard.IsIntersect(type) ? (0, index_1.CreateType)(FromIntersect(moduleProperties, type.allOf), type) :
-                            KindGuard.IsUnion(type) ? (0, index_1.CreateType)(FromUnion(moduleProperties, type.anyOf), type) :
-                                KindGuard.IsArray(type) ? (0, index_1.CreateType)(FromArray(moduleProperties, type.items), type) :
-                                    KindGuard.IsAsyncIterator(type) ? (0, index_1.CreateType)(FromAsyncIterator(moduleProperties, type.items), type) :
-                                        KindGuard.IsIterator(type) ? (0, index_1.CreateType)(FromIterator(moduleProperties, type.items), type) :
+                            KindGuard.IsIterator(type) ? (0, index_1.CreateType)(FromIterator(moduleProperties, type.items), type) :
+                                KindGuard.IsObject(type) ? (0, index_1.CreateType)(FromObject(moduleProperties, type.properties), type) :
+                                    KindGuard.IsTuple(type) ? (0, index_1.CreateType)(FromTuple(moduleProperties, type.items || []), type) :
+                                        KindGuard.IsUnion(type) ? (0, index_1.CreateType)(FromUnion(moduleProperties, type.anyOf), type) :
                                             type);
 }
 // prettier-ignore

package/build/cjs/type/module/infer.d.ts

@@ -3,6 +3,7 @@ import { TSchema } from '../schema/index';
 import { TArray } from '../array/index';
 import { TAsyncIterator } from '../async-iterator/index';
 import { TConstructor } from '../constructor/index';
+import { TEnum, TEnumRecord } from '../enum/index';
 import { TFunction } from '../function/index';
 import { TIntersect } from '../intersect/index';
 import { TIterator } from '../iterator/index';
@@ -37,7 +38,7 @@ type TInferObject<ModuleProperties extends TProperties, Properties extends TProp
 type TInferTuple<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferTuple<ModuleProperties, R, [...Result, TInfer<ModuleProperties, L>]> : Result);
 type TInferRef<ModuleProperties extends TProperties, Ref extends string> = (Ref extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Ref]> : unknown);
 type TInferUnion<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = never> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferUnion<ModuleProperties, R, Result | TInfer<ModuleProperties, L>> : Result);
-type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TInferArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TInferAsyncIterator<ModuleProperties, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TInferConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TInferFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TInferIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TInferIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> : Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : Static<Type>);
+type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TInferArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TInferAsyncIterator<ModuleProperties, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TInferConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TInferFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TInferIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TInferIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> : Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Static<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : Static<Type>);
 /** Inference Path for Imports. This type is used to compute TImport `static` */
 export type TInferFromModuleKey<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Key]> : never);
 export {};

package/build/cjs/value/default/default.js

@@ -32,6 +32,14 @@ function HasDefaultProperty(schema) {
 // Types
 // ------------------------------------------------------------------
 function FromArray(schema, references, value) {
+    // if the value is an array, we attempt to initialize it's elements
+    if ((0, index_5.IsArray)(value)) {
+        for (let i = 0; i < value.length; i++) {
+            value[i] = Visit(schema.items, references, value[i]);
+        }
+        return value;
+    }
+    // ... otherwise use default initialization
     const defaulted = ValueOrDefault(schema, value);
     if (!(0, index_5.IsArray)(defaulted))
         return defaulted;

package/build/esm/type/module/compute.d.mts

@@ -6,6 +6,7 @@ import { type TAsyncIterator } from '../async-iterator/index.mjs';
 import { TComputed } from '../computed/index.mjs';
 import { type TConstructor } from '../constructor/index.mjs';
 import { type TIndex } from '../indexed/index.mjs';
+import { TEnum, TEnumRecord } from '../enum/index.mjs';
 import { type TFunction } from '../function/index.mjs';
 import { type TIntersect, type TIntersectEvaluated } from '../intersect/index.mjs';
 import { type TIterator } from '../iterator/index.mjs';
@@ -43,7 +44,7 @@ type TFromArray<ModuleProperties extends TProperties, Type extends TSchema> = (E
 type TFromAsyncIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TAsyncIterator<TFromType<ModuleProperties, Type>>);
 type TFromIterator<ModuleProperties extends TProperties, Type extends TSchema> = (TIterator<TFromType<ModuleProperties, Type>>);
 type TFromRest<ModuleProperties extends TProperties, Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromRest<ModuleProperties, Right, [...Result, TFromType<ModuleProperties, Left>]> : Result);
-export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TComputed<infer T extends string, infer S extends TSchema[]> ? TFromComputed<ModuleProperties, T, S> : Type extends TObject<infer S extends TProperties> ? TFromObject<ModuleProperties, S> : Type extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TFromConstructor<ModuleProperties, S, R> : Type extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFromFunction<ModuleProperties, S, R> : Type extends TTuple<infer S extends TSchema[]> ? TFromTuple<ModuleProperties, S> : Type extends TIntersect<infer S extends TSchema[]> ? TFromIntersect<ModuleProperties, S> : Type extends TUnion<infer S extends TSchema[]> ? TFromUnion<ModuleProperties, S> : Type extends TArray<infer S extends TSchema> ? TFromArray<ModuleProperties, S> : Type extends TAsyncIterator<infer S extends TSchema> ? TFromAsyncIterator<ModuleProperties, S> : Type extends TIterator<infer S extends TSchema> ? TFromIterator<ModuleProperties, S> : Type);
+export type TFromType<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TFromArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TFromAsyncIterator<ModuleProperties, Type> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<ModuleProperties, Target, Parameters> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TFromIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<ModuleProperties, Properties> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Type : Type extends TUnion<infer Types extends TSchema[]> ? TFromUnion<ModuleProperties, Types> : Type);
 export declare function FromType<ModuleProperties extends TProperties, Type extends TSchema>(moduleProperties: ModuleProperties, type: Type): TFromType<ModuleProperties, Type>;
 export type TComputeType<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TFromType<ModuleProperties, ModuleProperties[Key]> : TNever);
 export declare function ComputeType<ModuleProperties extends TProperties, Key extends PropertyKey>(moduleProperties: ModuleProperties, key: Key): TComputeType<ModuleProperties, Key>;

package/build/esm/type/module/compute.mjs

@@ -118,20 +118,19 @@ function FromRest(moduleProperties, types) {
 }
 // prettier-ignore
 export function FromType(moduleProperties, type) {
-    return (
-    // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
-    // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
-    // be a priority as there is a potential for the current inference to break on TS compiler changes.
-    KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) :
-        KindGuard.IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) :
-            KindGuard.IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
-                KindGuard.IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) :
-                    KindGuard.IsTuple(type) ? CreateType(FromTuple(moduleProperties, type.items || []), type) :
+    return (KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
+        KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
+            // Note: The 'as never' is required due to excessive resolution of TIndex. In fact TIndex, TPick, TOmit and
+            // all need re-implementation to remove the PropertyKey[] selector. Reimplementation of these types should
+            // be a priority as there is a potential for the current inference to break on TS compiler changes.
+            KindGuard.IsComputed(type) ? CreateType(FromComputed(moduleProperties, type.target, type.parameters)) :
+                KindGuard.IsConstructor(type) ? CreateType(FromConstructor(moduleProperties, type.parameters, type.returns), type) :
+                    KindGuard.IsFunction(type) ? CreateType(FromFunction(moduleProperties, type.parameters, type.returns), type) :
                         KindGuard.IsIntersect(type) ? CreateType(FromIntersect(moduleProperties, type.allOf), type) :
-                            KindGuard.IsUnion(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) :
-                                KindGuard.IsArray(type) ? CreateType(FromArray(moduleProperties, type.items), type) :
-                                    KindGuard.IsAsyncIterator(type) ? CreateType(FromAsyncIterator(moduleProperties, type.items), type) :
-                                        KindGuard.IsIterator(type) ? CreateType(FromIterator(moduleProperties, type.items), type) :
+                            KindGuard.IsIterator(type) ? CreateType(FromIterator(moduleProperties, type.items), type) :
+                                KindGuard.IsObject(type) ? CreateType(FromObject(moduleProperties, type.properties), type) :
+                                    KindGuard.IsTuple(type) ? CreateType(FromTuple(moduleProperties, type.items || []), type) :
+                                        KindGuard.IsUnion(type) ? CreateType(FromUnion(moduleProperties, type.anyOf), type) :
                                             type);
 }
 // prettier-ignore

package/build/esm/type/module/infer.d.mts

@@ -3,6 +3,7 @@ import { TSchema } from '../schema/index.mjs';
 import { TArray } from '../array/index.mjs';
 import { TAsyncIterator } from '../async-iterator/index.mjs';
 import { TConstructor } from '../constructor/index.mjs';
+import { TEnum, TEnumRecord } from '../enum/index.mjs';
 import { TFunction } from '../function/index.mjs';
 import { TIntersect } from '../intersect/index.mjs';
 import { TIterator } from '../iterator/index.mjs';
@@ -37,7 +38,7 @@ type TInferObject<ModuleProperties extends TProperties, Properties extends TProp
 type TInferTuple<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferTuple<ModuleProperties, R, [...Result, TInfer<ModuleProperties, L>]> : Result);
 type TInferRef<ModuleProperties extends TProperties, Ref extends string> = (Ref extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Ref]> : unknown);
 type TInferUnion<ModuleProperties extends TProperties, Types extends TSchema[], Result extends unknown = never> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TInferUnion<ModuleProperties, R, Result | TInfer<ModuleProperties, L>> : Result);
-type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TInferArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TInferAsyncIterator<ModuleProperties, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TInferConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TInferFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TInferIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TInferIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> : Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : Static<Type>);
+type TInfer<ModuleProperties extends TProperties, Type extends TSchema> = (Type extends TArray<infer Type extends TSchema> ? TInferArray<ModuleProperties, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? TInferAsyncIterator<ModuleProperties, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TInferConstructor<ModuleProperties, Parameters, InstanceType> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TInferFunction<ModuleProperties, Parameters, ReturnType> : Type extends TIntersect<infer Types extends TSchema[]> ? TInferIntersect<ModuleProperties, Types> : Type extends TIterator<infer Type extends TSchema> ? TInferIterator<ModuleProperties, Type> : Type extends TObject<infer Properties extends TProperties> ? TInferObject<ModuleProperties, Properties> : Type extends TRef<infer Ref extends string> ? TInferRef<ModuleProperties, Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TInferTuple<ModuleProperties, Types> : Type extends TEnum<infer _ extends TEnumRecord> ? Static<Type> : Type extends TUnion<infer Types extends TSchema[]> ? TInferUnion<ModuleProperties, Types> : Static<Type>);
 /** Inference Path for Imports. This type is used to compute TImport `static` */
 export type TInferFromModuleKey<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TInfer<ModuleProperties, ModuleProperties[Key]> : never);
 export {};

package/build/esm/value/default/default.mjs

@@ -28,6 +28,14 @@ function HasDefaultProperty(schema) {
 // Types
 // ------------------------------------------------------------------
 function FromArray(schema, references, value) {
+    // if the value is an array, we attempt to initialize it's elements
+    if (IsArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            value[i] = Visit(schema.items, references, value[i]);
+        }
+        return value;
+    }
+    // ... otherwise use default initialization
     const defaulted = ValueOrDefault(schema, value);
     if (!IsArray(defaulted))
         return defaulted;

package/package.json

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

package/readme.md

@@ -774,39 +774,47 @@ type T = Static<typeof T>                            // type T = string | null
 
 ### Module Types
 
-TypeBox Modules are containers for related types. They function as namespaces and enable internal types to reference each other via string references. Modules support both singular and mutually recursive types. They provide a mechanism to create circular types irrespective of the order in which types are defined.
+TypeBox Modules are containers for related types. They provide a referential namespace, enabling types to reference one another via string identifiers. Modules support both singular and mutually recursive referencing within the context of a module, as well as referential computed types (such as Partial + Ref). All Module types must be imported before use. TypeBox represents an imported type with the `$defs` Json Schema keyword. 
 
-```typescript
+#### Usage
+
+The following creates a Module with User and PartialUser types. Note that the PartialUser type is specified as a Partial + Ref to the User type. It is not possible to perform a Partial operation directly on a reference, so TypeBox will return a TComputed type that defers the Partial operation until all types are resolved. The TComputed type is evaluated when calling Import on the Module.
 
-// The following creates a Module of circular recursive Types.
+```typescript
+// Module with PartialUser and User types
 
 const Module = Type.Module({
-  A: Type.Object({ 
-    b: Type.Ref('B') // Ref B:
-  }),
-  B: Type.Object({
-    c: Type.Ref('C') // Ref C:
-  }),
-  C: Type.Object({
-    a: Type.Ref('A') // Ref A:
-  }),
+
+  PartialUser: Type.Partial(Type.Ref('User')),  // TComputed<'Partial', [TRef<'User'>]>
+
+  User: Type.Object({                           // TObject<{
+    id: Type.String(),                          //   user: TString,
+    name: Type.String(),                        //   name: TString,
+    email: Type.String()                        //   email: TString
+  }),                                           // }>
+  
 })
 
-// Module Types must be imported before use.
+// Types must be imported before use.
 
-const A = Module.Import('A')                     // const A: TImport<{...}, 'A'>
+const User = Module.Import('User')               // const User: TImport<{...}, 'User'>
 
-type A = Static<typeof A>                        // type A = { 
-                                                 //   b: {
-                                                 //     c: {
-                                                 //       a: {
-                                                 //         b: ...
-                                                 //       }
-                                                 //     }
-                                                 //   }
+type User = Static<typeof User>                  // type User = { 
+                                                 //   id: string,
+                                                 //   name: string,
+                                                 //   email: string
+                                                 // }
+
+const PartialUser = Module.Import('PartialUser') // const PartialUser: TImport<{...}, 'PartialUser'>
+
+type PartialUser = Static<typeof PartialUser>    // type PartialUser = { 
+                                                 //   id?: string,
+                                                 //   name?: string,
+                                                 //   email?: string
                                                  // }
 ```
 
+
 <a name='types-template-literal'></a>
 
 ### Template Literal Types
@@ -1025,7 +1033,7 @@ if(TypeGuard.IsString(T)) {
 
 ## Syntax Types
 
-TypeBox provides support for Syntax Types, enabling it to parse TypeScript syntax directly into TypeBox types. Syntax Types serve as a DSL frontend for TypeBox's type builder and are useful for converting existing TypeScript type definitions into Json Schema schematics.
+TypeBox provides support for parsing TypeScript syntax directly into TypeBox Json Schema schematics. Syntax Types offer a string based DSL frontend to TypeBox's Type Builder system and can be useful for converting existing TypeScript type definitions into Json Schema schematics without reimplementation via the Type Builder.
 
 Syntax Types are provided via optional import.
 
@@ -1106,14 +1114,14 @@ type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
 
 ### Context
 
-The Parse function accepts an initial Context argument, allowing external types to be passed into the parser.
+The Parse function takes an optional leading Context object that contains external types. This Context allows the syntax to reference these external types using the property identifiers provided by the Context. The following passes the external type `T` to Parse.
 
 ```typescript
-const T = Type.Object({                             // could be written as: Parse(`{
-  x: Type.Number(),                                 //   x: number,
-  y: Type.Number(),                                 //   y: number,
-  z: Type.Number()                                  //   z: number
-})                                                  // }`)
+const T = Type.Object({                             // const T: TObject<{
+  x: Type.Number(),                                 //   x: TNumber,
+  y: Type.Number(),                                 //   y: TNumber,
+  z: Type.Number()                                  //   z: TNumber
+})                                                  // }>
 
 const A = Parse({ T }, 'Partial<T>')                // const A: TObject<{
                                                     //   x: TOptional<TNumber>,
@@ -1140,7 +1148,7 @@ const C = Parse({ T }, 'T & { w: number }')         // const C: TIntersect<[TObj
 
 ### Static
 
-Syntax Types provide two Static types for inferring TypeScript syntax from strings.
+Syntax Types provide two Static types for inferring TypeScript types and TypeBox schematics from strings.
 
 ```typescript
 import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
@@ -1190,7 +1198,7 @@ const B = Parse(`{
 }`)
 ```
 
-In cases where Syntax Types busts through TypeScript instantiation limits, TypeBox offers a fallback ParseOnly function which will Parse the types at runtime, but not infer the type. This function can also be used for parsing non-constant strings.
+In cases where Syntax Types exceed TypeScript's instantiation limits, TypeBox offers a fallback ParseOnly function, which will only parse but not infer. This function can also be used to parse types where the syntax is statically unknown to TypeScript (for example, when loading types from disk).
 
 ```typescript
 import { ParseOnly } from '@sinclair/typebox/syntax'