microtype

Super lightweight and simple type system library like zod, but faster, smaller, and with fewer functions.

We doesn't use eval, Function or something like this, because we're staying web-friendly

Install

NPM

npm install @nirelc/microtype

Bun

bun intall @nirelc/microtype

Usage

Imports

Microtype can be imported with wildcard or with only required types

// with only required types import
import { … } from '@nirelc/microtype';

// with a wildcard import
import * as t from '@nirelc/microtype';

Your first type

Microtype simillar with valibot and other type system libs, because of this, you will easily understand our syntax

import { object, string } from "@nirelc/microtype";

// typescript
type UserData = {
  username: string;
  email?: string;
};

// microtype
const PostSchema = object({
  username: string(),
  email: string().optional(),
});

type PostData = typeof PostSchema.static;

const data = PostSchema.parse({
  username: "system",
  should: "strip",
});

We provide some useful features with schema chaining

const PostSchema = object({
  email: string().min(5).max(128).optional(),
  version: number().default(1),
});

API

All types support <type>.default(<value>) syntax.

Now we support these types:

String

// typescript
type Username = string;

// microtype
const UsernameSchema = string();

// extra fields
const UsernameExtraSchema = string().min(1).max(24).default("root");

Numbers

// typescript
type Version = number;

// microtype
// any number and floats
const VersionSchema = number(); // or `float()` as alias

// only integer (float will trigger error)
const VersionIntSchema = integer();

// integer with pre-built validators
// supports: uinteger, u8, u16, u32, i8, i16, i32
const SmallVersionSchema = u8();

// extra fields
// e.g value should equals 1 <= value <= 3 and should parse string as number and drop float support
const VersionExtraSchema = number().min(1).max(3).coerce(true).integer(true);

Literal

// typescript
type Username = "root";

// microtype
const UsernameSchema = literal("root");

Boolean

// typescript
type IsActive = boolean;

// microtype
const IsActiveSchema = boolean();

// coerce string and number to boolean
const IsActiveCoerceSchema = boolean().coerce(true);

Optional

Supported separated type optional(<schema>), also can be chained with <schema>.optional()

// typescript
type Email = string | undefined;

const EmailSchema = string().optional();
// const EmailSchema = optional(string());

Transform

Supported separated type transform(<schema>, <TransformFn>), also can be chained with <schema>.transform(<transformFn>).

const StrBoolSchema = string().transform((value) =>
  ["yes", "true", "1", "on"].includes(value.toLowerCase()),
);
// const StrBoolSchema = transform(string(), (value) =>
//   ["yes", "true", "1", "on"].includes(value.toLowerCase()),
// );

Unions

// typescript
type Username = "root" | "user";

// microtype
const UsernameSchema = union([literal("root"), literal("user")];

// with nested union
const UsernameWithNestedSchema = union([literal("root"), union([literal("user")])])

Arrays

// typescript
type Versions = number[];

// microtype
const VersionsSchema = array(number());

// extra fields
// min 1 item, max 3 items
const VersionsLimitedSchema = array(number()).min(1).max(3);

// array.length should be equal 3
const VersionsWithLengthScheam = array(number()).length(3);

Objects

All unknown fields will be deleted

// typescript
type User = {
  username: string;
  email?: string;
  status: "banned" | "active";
};

// microtype
const VersionsSchema = object({
  username: string(),
  // email: string().optional()
  email: optional(string()),
  status: union([literal("banned"), literal("active")]),
});

Standard Schema

All schemas implement Standard Schema, so they can be passed directly to libraries that accept it (Elysia, tRPC, Hono, TanStack Form, react-hook-form, etc.)

import {
  object,
  string,
  number,
  type Input,
  type Output,
} from "@nirelc/microtype";

const UserSchema = object({
  username: string(),
  version: number().default(1),
});

type UserInput = Input<typeof UserSchema>; // { username: string; version?: number | undefined }
type UserOutput = Output<typeof UserSchema>; // { username: string; version: number }

// or use the Standard Schema interface directly
const result = UserSchema["~standard"].validate({ username: "system" });
// { value: { username: "system", version: 1 } } or { issues: [{ message, path }] }

Benchmarks

You can run benchmarks in bench dir.

Results

In this benchmark, we compare microtype with other popular type system libraries: valibot, arktype, typebox, and zod.

The results below are from the best of 5 runs for Microtype.

Schema creation + parse

Create a new schema and parse 1000 values

| name | median | | --------------- | --------: | | microtype | 595.65 µs | | valibot | 2.30 ms | | typebox | 12.17 ms | | zod | 67.36 ms | | arktype | 94.95 ms |

Global schema

Global schema (parsing with pre-created schema) with parse 1000 values

| name | median | | ---------------------- | --------: | | typebox [compiled]* | 19.20 µs | | arktype* | 37.36 µs | | microtype | 366.14 µs | | zod | 505.66 µs | | valibot | 533.27 µs | | typebox | 7.25 ms |

* - arktype and typebox [compiled] uses precompile, because of this, it has better performance for global schema

Bundle size

We using a micro test case for create a type object schema + parse for all libs

| name | unminified | minified | gzip | | --------------- | ---------: | -------: | -------: | | microtype | 10.75 KB | 5.56 KB | 1.57 KB | | valibot | 13.17 KB | 5.81 KB | 1.96 KB | | typebox | 110.37 KB | 48 KB | 13.69 KB | | zod | 166.69 KB | 86.92 KB | 24.71 KB | | arktype | 284.33 KB | 155.4 KB | 47.22 KB |

Why

Q: Why did you make another type system lib?

• idk, just for fun