sinclairzx81 · sinclairzx81 · Jan 16, 2025 · Feb 6, 2025 · Feb 6, 2025 · Feb 6, 2025
diff --git a/changelog/0.34.0.md b/changelog/0.34.0.md
@@ -1,4 +1,6 @@
 ### 0.34.0
+- [Revision 0.34.16](https://github.com/sinclairzx81/typebox/pull/1155)
+  - Export the TypeBox Parsing Infrastructure
 - [Revision 0.34.15](https://github.com/sinclairzx81/typebox/pull/1148)
   - [1147](https://github.com/sinclairzx81/typebox/issues/1147) Fix incorrect truncation for integers that exceed 32-bit values in Value.Convert
 - [Revision 0.34.14](https://github.com/sinclairzx81/typebox/pull/1140)

diff --git a/example/index.ts b/example/index.ts
@@ -1,8 +1,8 @@
 import { TypeSystem } from '@sinclair/typebox/system'
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Value, ValuePointer } from '@sinclair/typebox/value'
-import { Parse, StaticParseAsType } from '@sinclair/typebox/syntax'
 import { Type, TypeGuard, Kind, Static, TSchema } from '@sinclair/typebox'
+import { Syntax } from '@sinclair/typebox/syntax'
 
 // -----------------------------------------------------------
 // Create: Type
@@ -22,7 +22,7 @@ console.log(T)
 // Parse: Type
 // -----------------------------------------------------------
 
-const S = Parse({ T }, `{ x: T, y: T, z: T }`)
+const S = Syntax({ T }, `{ x: T, y: T, z: T }`)
 
 type S = Static<typeof S>
 

diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.34.15",
+  "version": "0.34.16",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

diff --git a/readme.md b/readme.md
@@ -77,10 +77,6 @@ License MIT
   - [Transform](#types-transform)
   - [Guard](#types-guard)
   - [Unsafe](#types-unsafe)
-- [Syntax](#syntax)
-  - [Parse](#syntax-parse)
-  - [Static](#syntax-static)
-  - [Limits](#syntax-limits)
 - [Values](#values)
   - [Assert](#values-assert)
   - [Create](#values-create)
@@ -100,6 +96,11 @@ License MIT
   - [Errors](#values-errors)
   - [Mutate](#values-mutate)
   - [Pointer](#values-pointer)
+- [Syntax](#syntax)
+  - [Type](#syntax-type)
+  - [Options](#syntax-options)
+  - [Parameters](#syntax-parameters)
+  - [Generics](#syntax-generics)
 - [TypeRegistry](#typeregistry)
   - [Type](#typeregistry-type)
   - [Format](#typeregistry-format)
@@ -1044,162 +1045,6 @@ if(TypeGuard.IsString(T)) {
 }
 ```
 
-<a name='syntax'></a>
-
-## Syntax Types
-
-TypeBox has support for parsing TypeScript type annotations directly into TypeBox types. This feature supports both runtime and static parsing, with TypeBox implementing TypeScript parsers within the TypeScript type system itself. Syntax Types use the TypeBox Json Schema representations as an AST target for TypeScript types, providing a direct mapping between TypeScript syntax and Json Schema. Syntax Types are offered as a syntactical frontend to the Standard Type Builder API.
-
-This feature is available via optional import.
-
-```typescript
-import { Parse } from '@sinclair/typebox/syntax'
-```
-
-<a name='syntax-parse'></a>
-
-### Parse
-
-Use the Parse function to transform a TypeScript type annotation into a TypeBox type. This function will return the parsed TypeBox type or undefined on error.
-
-```typescript
-const A = Parse('string')                           // const A: TString
-
-const B = Parse('[1, 2, 3]')                        // const B: TTuple<[
-                                                    //   TLiteral<1>,
-                                                    //   TLiteral<2>,
-                                                    //   TLiteral<3>
-                                                    // ]>
-
-const C = Parse(`{ x: number, y: number }`)         // const C: TObject<{
-                                                    //   x: TNumber
-                                                    //   y: TNumber
-                                                    // }>
-```
-
-Syntax Types can compose with Standard Types created via the Type Builder API
-
-```typescript
-const T = Type.Object({                             // const T: TObject<{
-  x: Parse('number'),                               //   x: TNumber,
-  y: Parse('string'),                               //   y: TString,
-  z: Parse('boolean')                               //   z: TBoolean
-})                                                  // }>
-```
-
-Standard Types can also be passed to and referenced within Syntax Types.
-
-```typescript
-const X = Type.Number()
-const Y = Type.String()
-const Z = Type.Boolean()
-
-const T = Parse({ X, Y, Z }, `{ 
-  x: X, 
-  y: Y, 
-  z: Z 
-}`)
-```
-
-Syntax Types also support Module parsing.
-
-```typescript
-const Foo = Parse(`module Foo {
-
-  export type PartialUser = Pick<User, 'id'> & Partial<Omit<User, 'id'>>
-
-  export interface User {
-    id: string
-    name: string
-    email: string
-  }
-
-}`)
-
-const PartialUser = Foo.Import('PartialUser')       // TImport<{...}, 'PartialUser'>
-
-type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
-                                                    //   id: string,
-                                                    // } & {
-                                                    //   name?: string,
-                                                    //   email?: string,
-                                                    // }
-```
-
-<a name='syntax-static'></a>
-
-### Static
-
-Syntax Types provide two Static types specific to inferring TypeBox and TypeScript types from strings.
-
-```typescript
-import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
-
-// Will infer as a TSchema
-
-type S = StaticParseAsSchema<{}, '{ x: number }'>   // type S: TObject<{
-                                                    //   x: TNumber
-                                                    // }>
-
-// Will infer as a type
-
-type T = StaticParseAsType<{}, '{ x: number }'>     // type T = {
-                                                    //   x: number
-                                                    // }                      
-```
-
-
-<a name='syntax-limits'></a>
-
-### Limitations
-
-TypeBox parses TypeScript types directly within the TypeScript type system. This process does come with an inference cost, which scales with the size and complexity of the types being parsed. Although TypeBox strives to optimize Syntax Types, users should be aware of the following structures:
-
-```typescript
-// Excessively wide structures will result in instantiation limits exceeding
-const A = Parse(`[
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-  0, 1, 2, 3, 4, 5, 6, 7,
-]`)
-
-// Excessively nested structures will result in instantiation limits exceeding
-const B = Parse(`{
-  x: {
-    y: {
-      z: {
-        w: 1 <-- Type instantiation is excessively deep and possibly infinite.
-      } 
-    }
-  }  
-}`)
-```
-
-If Syntax Types exceed TypeScript's instantiation limits, users are advised to fall back to the Standard Type Builder API. Alternatively, TypeBox offers a `ParseOnly` function that parses the TypeScript syntax at runtime without statically inferring the schema.
-
-```typescript
-import { ParseOnly } from '@sinclair/typebox/syntax'
-
-// const A: TSchema | undefined 
-
-const A = ParseOnly(`{
-  x: {
-    y: {
-      z: {
-        w: 1
-      } 
-    }
-  }  
-}`)
-```
-
-For more information on static parsing, refer to the [ParseBox](https://github.com/sinclairzx81/parsebox) project.
-
 <a name='values'></a>
 
 ## Values
@@ -1490,6 +1335,87 @@ ValuePointer.Set(A, '/y', 1)                         // A' = { x: 1, y: 1, z: 0
 ValuePointer.Set(A, '/z', 1)                         // A' = { x: 1, y: 1, z: 1 }
 ```
 
+
+
+<a name='syntax'></a>
+
+## Syntax Types
+
+TypeBox provides optional support for runtime and type level parsing from TypeScript syntax.
+
+```typescript
+import { Syntax } from '@sinclair/typebox/syntax'
+```
+
+<a name='syntax-type'></a>
+
+### Type
+
+Use the Syntax function to create TypeBox type from TypeScript syntax.
+
+```typescript
+const T = Syntax(`{ x: number, y: number }`)        // const T: TObject<{
+                                                    //   x: TNumber
+                                                    //   y: TNumber
+                                                    // }>
+```
+
+<a name='syntax-options'></a>
+
+### Options
+
+Options can be passed to types on the last parameter
+
+```typescript
+const T = Syntax(`number`, {                      // const T = {
+  minimum: 0,                                     //   type: 'number',
+  maximum: 10                                     //   minimum: 0,
+})                                                //   maximum: 10
+                                                  // }
+```
+
+<a name="syntax-parameters"></a>
+
+### Parameters
+
+Syntax types can be parameterized to accept exterior types.
+
+```typescript
+const T = Syntax('number')
+
+const S = Syntax({ T }, `{ x: T, y: T, z: T }`)     // const S: TObject<{
+                                                    //   x: TNumber,
+                                                    //   y: TNumber,
+                                                    //   z: TNumber
+                                                    // }>
+```
+
+<a name="syntax-generics"></a>
+
+### Generics
+
+Generic syntax types can be created using parameterized types.
+
+```typescript
+// Generic Syntax Type
+
+const Vector = <T extends string>(T: T) => Syntax({ T: Syntax(T) }, `{
+  x: T,
+  y: T,
+  z: T
+}`)
+
+
+// Instanced Generic Syntax Type
+
+const NumberVector = Vector('number')                 // const NumberVector: TObject<{
+                                                      //   x: TNumber,
+                                                      //   y: TNumber,
+                                                      //   z: TNumber
+                                                      // }>
+```
+
+
 <a name='typeregistry'></a>
 
 ## TypeRegistry

diff --git a/src/syntax/parsebox/index.ts → src/parser/index.ts b/src/syntax/parsebox/index.ts → src/parser/index.ts
diff --git a/src/syntax/parsebox/runtime/guard.ts → src/parser/runtime/guard.ts b/src/syntax/parsebox/runtime/guard.ts → src/parser/runtime/guard.ts
diff --git a/src/syntax/parsebox/runtime/index.ts → src/parser/runtime/index.ts b/src/syntax/parsebox/runtime/index.ts → src/parser/runtime/index.ts
diff --git a/src/syntax/parsebox/runtime/module.ts → src/parser/runtime/module.ts b/src/syntax/parsebox/runtime/module.ts → src/parser/runtime/module.ts
diff --git a/src/syntax/parsebox/runtime/parse.ts → src/parser/runtime/parse.ts b/src/syntax/parsebox/runtime/parse.ts → src/parser/runtime/parse.ts
diff --git a/src/syntax/parsebox/runtime/token.ts → src/parser/runtime/token.ts b/src/syntax/parsebox/runtime/token.ts → src/parser/runtime/token.ts
diff --git a/src/syntax/parsebox/runtime/types.ts → src/parser/runtime/types.ts b/src/syntax/parsebox/runtime/types.ts → src/parser/runtime/types.ts
diff --git a/src/syntax/parsebox/static/index.ts → src/parser/static/index.ts b/src/syntax/parsebox/static/index.ts → src/parser/static/index.ts
diff --git a/src/syntax/parsebox/static/parse.ts → src/parser/static/parse.ts b/src/syntax/parsebox/static/parse.ts → src/parser/static/parse.ts
diff --git a/src/syntax/parsebox/static/token.ts → src/parser/static/token.ts b/src/syntax/parsebox/static/token.ts → src/parser/static/token.ts
diff --git a/src/syntax/parsebox/static/types.ts → src/parser/static/types.ts b/src/syntax/parsebox/static/types.ts → src/parser/static/types.ts
diff --git a/src/syntax/index.ts b/src/syntax/index.ts
@@ -26,4 +26,4 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './parse'
+export * from './syntax'
Original file line number	Diff line number	Diff line change
Expand Up		@@ -26,4 +26,4 @@ THE SOFTWARE.

		---------------------------------------------------------------------------*/

		export * from './parse'
		export * from './syntax'