$ npm install @sinclair/typemap --saveParse and Compile Types from TypeScript syntax (Example)
import { Compile } from '@sinclair/typemap'
const result = Compile('string | null').Parse('Hello World')
// │ │ │
// │ └── parse syntax └─── parse value
// │
// └── const result: string | null = 'Hello World'TypeMap is an syntax frontend and compiler backend for the TypeBox, Valibot and Zod type libraries. It provides a common TypeScript syntax for type construction across libraries, a runtime compiler for high-performance validation and provides type translation from one library to another.
TypeMap is written to be an advanced adapter and type translation system for the TypeBox project. It is designed specifically to integrate and accelerate remote type libraries on Json Schema compatible infrastructure as well as to enable TypeBox schematics to be remapped to remote type library infrastructure. This project also provides high-performance validation for frameworks that orientate around the Standard Schema TypeScript interface.
License: MIT
Use a TypeScript syntax to create types for TypeBox, Valibot and Zod (Example)
import { TypeBox, Valibot, Zod } from '@sinclair/typemap'
// Parse Syntax | Parse Value
const R = Zod('string | number').parse('...') // const R: string | number
// TypeScript Syntax
const S = `{
x: number,
y: number,
z: number
}`
const T = TypeBox(S) // const T: TObject<{
// x: TNumber,
// y: TNumber,
// z: TNumber
// }>
const V = Valibot(S) // const V: ObjectSchema<{
// x: NumberSchema<...>,
// y: NumberSchema<...>,
// z: NumberSchema<...>
// }, ...>
const Z = Zod(S) // const Z: ZodObject<{
// x: ZodNumber,
// y: ZodNumber,
// z: ZodNumber
// }, ...>Translate TypeBox, Valibot and Zod types (Example)
import { TypeBox, Valibot, Zod } from '@sinclair/typemap'
// Syntax -> Zod -> Valibot -> TypeBox
const T = TypeBox(Valibot(Zod(`{
x: number,
y: number,
z: number
}`)))Compile Valibot and Zod types on TypeBox validation infrastructure. (Example)
import { Compile } from '@sinclair/typemap'
import z from 'zod'
// Zod Type
const Z = z.object({ // const Z: ZodObject<{
x: z.number(), // x: ZodNumber,
y: z.number(), // y: ZodNumber,
z: z.number(), // z: ZodNumber
}) // }>
// Remap and Compile
const C = Compile(Z) // const C: Validator<TObject<{
// x: TNumber,
// y: TNumber,
// z: TNumber
// }>>
// High Throughout Validation
const R = C.Check({ // Iterations: 10_000_000
x: 1, //
y: 2, // Zod : 4000ms (approx)
z: 3 // TypeMap : 40ms (approx)
})TypeMap is primarily a mapping system used for type translation. It provides a mapping function per library which is used to translate remote types into types specific to that library. If no translation is possible, these functions return a never representation specific to the library being mapped.
Use the TypeBox function to translate types and syntax into TypeBox types.
import { TypeBox } from '@sinclair/typemap'
const S = TypeBox('string[]') // const S: TArray<TString> (Syntax)
const T = TypeBox(t.Number()) // const T: TNumber (TypeBox)
const V = TypeBox(v.string()) // const V: TString (Valibot)
const Z = TypeBox(z.boolean()) // const Z: TBoolean (Zod)Use the Valibot function to translate types and syntax into Valibot types.
import { Valibot } from '@sinclair/typemap'
const S = Valibot('string[]') // const S: v.ArraySchema<...> (Syntax)
const T = Valibot(t.Number()) // const T: v.NumberSchema (TypeBox)
const V = Valibot(v.string()) // const V: v.StringSchema (Valibot)
const Z = Valibot(z.boolean()) // const Z: v.BooleanSchema (Zod)Use the Zod function to translate types and syntax into Zod types.
import { Zod } from '@sinclair/typemap'
const S = Zod('string[]') // const S: z.ZodArray<...> (Syntax)
const T = Zod(t.Number()) // const T: z.ZodNumber (TypeBox)
const V = Zod(v.string()) // const V: z.ZodString (Valibot)
const Z = Zod(z.boolean()) // const Z: z.ZodBoolean (Zod)TypeMap provides a TypeScript syntax parser that can be used to create library types. TypeScript parsing is implemented at runtime as well as in the TypeScript type system. It is provided as a convenient means of creating and composing library types under a common syntax. Be mindful, syntax parsing in the type system can reduce inference performance.
Syntax types can be created by passing a string parameter to any library mapping function. TypeMap supports most TypeScript annotation syntax. If the string contains a syntax error, the function will return a never type. (Example)
import { TypeBox } from '@sinclair/typemap'
const T = TypeBox('{ x: 1 }') // const T: TObject<{
// x: TLiteral<1>
// }>
const S = TypeBox('!!!') // const S: TNeverOptions can be passed on the last parameter of a type. TypeMap will translate known Json Schema keywords into appropriate runtime representations if possible. (Example)
import { TypeBox, Zod } from '@sinclair/typemap'
const T = TypeBox('string', { // const T: TString = {
format: 'email' // type: 'string',
}) // format: 'email'
// }
const S = Zod('{ x: number }', { // const S = z.object({
additionalProperties: false // x: z.number()
}) // }).strict()Types can be parameterized to accept exterior types. (Example)
import { Valibot, Zod } from '@sinclair/typemap'
const T = Valibot('number') // const T: NumberSchema
// Parameter T auto remapped to target library
const S = Zod({ T }, `{ x: T }`) // const S: ZodObject<{
// x: ZodNumber
// }, { ... }>Use parameterized types with functions to create generic types (Example)
import { TypeBox, Valibot, Zod } from '@sinclair/typemap'
// Generic Type
const Vector = <T extends object>(T: T) => TypeBox({ T }, `{
x: T,
y: T,
z: T
}`)
// Instanced Types
const T = Vector(Valibot('number')) // const T: TObject<{
// x: TNumber,
// y: TNumber,
// z: TNumber,
// }>
const S = Vector(Zod('string')) // const S: TObject<{
// x: TString,
// y: TString,
// z: TString,
// }>Use Static to infer for library and syntax types
import { type Static } from '@sinclair/typemap'
const T = t.Number() // TypeBox
const V = v.string() // Valibot
const Z = z.boolean() // Zod
const S = 'string[]' // Syntax
type T = Static<typeof T> // number
type V = Static<typeof V> // string
type Z = Static<typeof Z> // boolean
type S = Static<typeof S> // string[]Use the Compile function to compile Zod and Valibot on TypeBox validation infrastructure. (Example)
import { Compile, Zod } from '@sinclair/typemap'
// Compile Validator From Zod
const validator = Compile(Zod(`{
x: number,
y: number,
z: number
}`))
const R1 = validator.Check({ x: 1, y: 2, z: 3 })
// Standard Schema
//
// ... which should have been named 'Standard Validator'
const R2 = validator['~standard'].validate({ x: 1, y: 2, z: 3 })This project manages a small benchmark that compares validation performance using Zod, Valibot, and TypeBox validators. For more comprehensive community benchmarks, refer to the runtime-type-benchmarks project.
Benchmarks are run for the following type.
type T = { x: number, y: string, z: boolean }Results show the approximate elapsed time to complete the given iterations
┌─────────┬────────────────┬────────────────────┬────────────┬────────────┐
│ (index) │ library │ using │ iterations │ elapsed │
├─────────┼────────────────┼────────────────────┼────────────┼────────────┤
│ 0 │ 'valibot ' │ 'valibot ' │ 10000000 │ '1534 ms ' │
│ 1 │ 'valibot ' │ 'typebox:value ' │ 10000000 │ '1377 ms ' │
│ 2 │ 'valibot ' │ 'typebox:compile ' │ 10000000 │ '46 ms ' │
└─────────┴────────────────┴────────────────────┴────────────┴────────────┘
┌─────────┬────────────────┬────────────────────┬────────────┬────────────┐
│ (index) │ library │ using │ iterations │ elapsed │
├─────────┼────────────────┼────────────────────┼────────────┼────────────┤
│ 0 │ 'zod ' │ 'zod ' │ 10000000 │ '4669 ms ' │
│ 1 │ 'zod ' │ 'typebox:value ' │ 10000000 │ '1359 ms ' │
│ 2 │ 'zod ' │ 'typebox:compile ' │ 10000000 │ '47 ms ' │
└─────────┴────────────────┴────────────────────┴────────────┴────────────┘This project is open to community contributions. Please ensure you submit an open issue before creating a pull request. TypeBox and associated projects preference open community discussion before accepting new features.