Essential TypeScript Utility Packages for 2026

TypeScript's type system is powerful, but some tasks need libraries to be practical. These utility packages fill the gaps — from runtime validation to type manipulation to developer ergonomics.

Every package here is actively maintained, well-typed, and used in production by thousands of projects. Download data from PkgPulse.

Schema Validation

Zod

The TypeScript-first schema validation library. Define a schema once, get both runtime validation and static types.

• Downloads: 14M/week
• Size: 13KB (gzip)
• Use case: Form validation, API input/output, config parsing

import { z } from 'zod';

const UserSchema = z.object({
  name: z.string().min(2),
  email: z.string().email(),
  age: z.number().int().positive().optional(),
});

type User = z.infer<typeof UserSchema>; // TypeScript type auto-generated

const result = UserSchema.safeParse(input);
if (result.success) {
  console.log(result.data); // Fully typed
}

Why it dominates: One schema definition gives you both TypeScript types and runtime validation. No more writing types AND validation rules separately.

Valibot

The lightweight alternative to Zod. Modular, tree-shakeable, 98% smaller in many cases.

• Downloads: 400K/week
• Size: 0.5-5KB (depending on features used)
• Use case: Same as Zod, but when bundle size is critical

import * as v from 'valibot';

const UserSchema = v.object({
  name: v.pipe(v.string(), v.minLength(2)),
  email: v.pipe(v.string(), v.email()),
  age: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),
});

type User = v.InferOutput<typeof UserSchema>;

When to choose over Zod: Client-side validation where bundle size matters. Valibot's tree-shaking means you only ship the validators you use.

Type Utilities

ts-reset

Fixes TypeScript's built-in types to be more useful. A single import that makes .filter(Boolean), .json(), and JSON.parse() return better types.

• Downloads: 700K/week
• Size: 0KB (types only, no runtime)

// Before ts-reset
const filtered = [1, undefined, 2].filter(Boolean);
// Type: (number | undefined)[] — still includes undefined!

// After ts-reset
const filtered = [1, undefined, 2].filter(Boolean);
// Type: number[] — correct!

// Before ts-reset
const data = JSON.parse(input);
// Type: any

// After ts-reset
const data = JSON.parse(input);
// Type: unknown — forces you to validate

Install it on every TypeScript project. Zero runtime cost, immediate type safety improvements.

type-fest

A curated collection of essential TypeScript utility types. If you've ever needed PartialDeep, SetRequired, CamelCase, or Simplify — it's here.

• Downloads: 30M/week
• Size: 0KB (types only)

import type { PartialDeep, CamelCase, SetRequired } from 'type-fest';

// Make all nested properties optional
type DeepPartialUser = PartialDeep<User>;

// Convert string to camelCase type
type Key = CamelCase<'user-profile-settings'>; // 'userProfileSettings'

// Make specific optional fields required
type UserWithEmail = SetRequired<User, 'email'>;

ts-pattern

Exhaustive pattern matching for TypeScript. Like a supercharged switch statement that the compiler verifies is complete.

• Downloads: 1M/week
• Size: 3KB (gzip)

import { match, P } from 'ts-pattern';

type Shape =
  | { type: 'circle'; radius: number }
  | { type: 'rect'; width: number; height: number };

const area = match(shape)
  .with({ type: 'circle' }, ({ radius }) => Math.PI * radius ** 2)
  .with({ type: 'rect' }, ({ width, height }) => width * height)
  .exhaustive(); // Compile error if a case is missing

Date & Time

date-fns

Modular date utility library. Import only the functions you need — tree-shaking keeps your bundle small.

• Downloads: 18M/week
• Size: 2-10KB (per function, gzipped)

import { format, addDays, differenceInDays } from 'date-fns';

format(new Date(), 'yyyy-MM-dd'); // '2026-03-04'
addDays(new Date(), 7); // Next week
differenceInDays(endDate, startDate); // Days between

Day.js

Moment.js replacement with the same API but at 2KB. If you want a simple, familiar API:

• Downloads: 16M/week
• Size: 2.9KB (gzip)

import dayjs from 'dayjs';

dayjs().format('YYYY-MM-DD');
dayjs().add(7, 'day');
dayjs(endDate).diff(startDate, 'day');

Environment & Configuration

dotenv

Load environment variables from .env files. Still the standard after all these years.

• Downloads: 35M/week
• Size: 2KB

@t3-oss/env-nextjs

Type-safe environment variables for Next.js. Combines Zod validation with environment variable loading.

• Downloads: 500K/week

import { createEnv } from '@t3-oss/env-nextjs';
import { z } from 'zod';

export const env = createEnv({
  server: {
    DATABASE_URL: z.string().url(),
    STRIPE_SECRET_KEY: z.string().startsWith('sk_'),
  },
  client: {
    NEXT_PUBLIC_APP_URL: z.string().url(),
  },
  runtimeEnv: {
    DATABASE_URL: process.env.DATABASE_URL,
    STRIPE_SECRET_KEY: process.env.STRIPE_SECRET_KEY,
    NEXT_PUBLIC_APP_URL: process.env.NEXT_PUBLIC_APP_URL,
  },
});

// env.DATABASE_URL is guaranteed to be a valid URL string

Unique ID Generation

nanoid

Tiny, secure, URL-friendly unique ID generator. Smaller and faster than UUID.

• Downloads: 22M/week
• Size: 0.5KB (gzip)

import { nanoid } from 'nanoid';

nanoid(); // "V1StGXR8_Z5jdHi6B-myT" (21 chars, URL-safe)
nanoid(10); // "IRFa-VaY2b" (custom length)

cuid2

Collision-resistant IDs optimized for horizontal scaling and security. The successor to cuid.

• Downloads: 800K/week

import { createId } from '@paralleldrive/cuid2';

createId(); // "tz4a98xxat96iws9zmbrgj3a"

HTTP & Data Fetching

ky

Tiny HTTP client built on fetch. Cleaner API than native fetch with retries, JSON shortcuts, and hooks.

• Downloads: 2M/week
• Size: 3KB (gzip)

import ky from 'ky';

const data = await ky.get('https://api.example.com/data').json<User[]>();
// Automatic JSON parsing, typed response

ofetch

Universal fetch library from the UnJS ecosystem. Works in Node.js, Deno, Bun, and browsers.

• Downloads: 8M/week
• Size: 3KB (gzip)

import { ofetch } from 'ofetch';

const data = await ofetch<User[]>('/api/users', {
  retry: 3,
  retryDelay: 1000,
});

String & Data Manipulation

slugify

Convert strings to URL-friendly slugs.

• Downloads: 3M/week
• Size: 1KB

import slugify from 'slugify';
slugify('Hello World!', { lower: true }); // 'hello-world'

superjson

Serialize and deserialize JavaScript values that JSON.stringify can't handle — dates, maps, sets, BigInts, and more.

• Downloads: 3M/week
• Size: 4KB

import superjson from 'superjson';

const data = { date: new Date(), set: new Set([1, 2, 3]) };
const json = superjson.stringify(data);
const parsed = superjson.parse(json); // Dates and Sets restored

Our Curated Stack

If you're starting a new TypeScript project, here's our recommended utility stack:

Need	Package	Size
Validation	Zod (or Valibot for small bundles)	13KB / 0.5KB
Type helpers	type-fest + ts-reset	0KB (types only)
Pattern matching	ts-pattern	3KB
Dates	date-fns	2-10KB
HTTP client	ky or ofetch	3KB
IDs	nanoid	0.5KB
Env validation	@t3-oss/env-nextjs	—

Total runtime impact: ~22KB gzipped. That's a complete utility layer for less than a single React component library.

Browse all these packages on PkgPulse to compare health scores, download trends, and alternatives.