radash

Functional utility library - modern, simple, typed, powerful

weekly downloads936K

versionv12.1.1

licenseMIT

categoryutility

Overview

Radash is a functional utility library built specifically for modern JavaScript and TypeScript projects. With over 936,000 weekly downloads, it provides a comprehensive set of helper functions for common operations like array manipulation, object transformation, async handling, and type checking. Unlike legacy alternatives, Radash is designed for contemporary codebases that already leverage ES6+ features, meaning it doesn't reimplement native methods like map or filter.

The library emphasizes three core principles: TypeScript-first design with proper type inference, zero runtime dependencies for minimal bundle size (306KB total), and full tree-shakability for optimal performance. Every function is typed to work seamlessly with TypeScript's type system, providing autocomplete and compile-time safety that plain JavaScript utilities lack. This makes it particularly valuable for teams building type-safe applications.

Radash organizes its utilities into logical categories: Array (range generation, grouping, sampling), Object (key mapping, deep cloning, picking), String (case conversion, templating), Async (try-catch wrappers, retry logic, parallel execution), Typed (runtime type guards), Curry (function composition), Number (rounding, clamping), and Random (UUID generation, shuffling). The API is intentionally minimalist, excluding operations already handled well by native JavaScript while adding genuinely useful abstractions for complex tasks.

Developers choose Radash when they need utility functions without the bloat of older libraries. It's particularly popular in performance-sensitive applications, serverless functions, and frontend projects where bundle size directly impacts load time. The library maintained active development through version 12.1.1, focusing on stability and TypeScript compatibility rather than chasing feature parity with heavyweight alternatives.

Quick Start

typescript

import { try as tryFn, parallel, objectify, group } from 'radash';

interface User {
  id: string;
  name: string;
  role: 'admin' | 'user';
}

async function fetchUsers(ids: string[]): Promise<User[]> {
  // Fetch users in parallel with max 3 concurrent requests
  const results = await parallel(3, ids, async (id) => {
    const [err, user] = await tryFn(async () => {
      const res = await fetch(`/api/users/${id}`);
      if (!res.ok) throw new Error('Failed to fetch');
      return res.json() as Promise<User>;
    })();
    
    // Returns error or user - no exceptions thrown
    return err ? null : user;
  });
  
  // Filter out failed requests
  const users = results.filter((u): u is User => u !== null);
  
  // Group users by role
  const byRole = group(users, u => u.role);
  
  // Create lookup map by ID
  const userMap = objectify(
    users,
    u => u.id,
    u => u
  );
  
  console.log('Admins:', byRole.admin?.length ?? 0);
  console.log('User map keys:', Object.keys(userMap));
  
  return users;
}

fetchUsers(['1', '2', '3']);

Use Cases

Error handling in async functions: Radash's try() wrapper converts promise rejections into error-first tuples, eliminating nested try-catch blocks. Instead of wrapping API calls in verbose error handling, you get clean [error, result] destructuring that's easier to test and reason about.

Generating structured data for testing: The list() function creates arrays with custom mapping logic, perfect for seeding databases or generating mock data. Combined with range(), you can quickly build test fixtures with realistic patterns without manual loops.

Type-safe object transformations: When reshaping API responses or normalizing data structures, functions like objectify() and mapEntries() provide type-safe alternatives to manual reduce operations. TypeScript correctly infers key and value types throughout the transformation.

Retry logic for flaky network requests: The retry() function handles exponential backoff and conditional retries without implementing custom recursion. Particularly useful for third-party API integrations where transient failures are expected.

Parallel async operations with control: Unlike Promise.all which fails fast, Radash's parallel() function allows concurrent execution with configurable limits and error collection, ideal for batch processing or concurrent API requests where you need granular control over concurrency and failure handling.

Pros & Cons

Pros

+Native TypeScript support with excellent type inference and narrowing, unlike Lodash's afterthought typings
+Tiny bundle impact due to tree-shaking and zero dependencies - includes only what you import
+Modern API design that complements ES6+ features rather than duplicating them
+Async utilities like try/retry/parallel simplify promise-heavy codebases significantly
+Active maintenance with focus on stability over feature bloat

Cons

−No method chaining support - requires functional composition instead of fluent API
−Smaller ecosystem and community compared to established alternatives like Lodash
−Documentation is less comprehensive than mature libraries, requiring more source code reading
−Missing some specialized utilities found in Lodash (debounce, throttle require separate packages)
−Breaking changes between major versions can require migration effort for large codebases

Alternatives

lodashv4.17.23

Lodash modular utilities.

utilitymodulesstdlib

100.2M / week

remedav2.33.6

A utility library for JavaScript and Typescript.

utilityalgoalgorithm

3.8M / week

Comparisons

Install

bash

npm install radash

bash

pnpm add radash

bash

bun add radash

Overview

Quick Start

typescript

import { try as tryFn, parallel, objectify, group } from 'radash';

interface User {
  id: string;
  name: string;
  role: 'admin' | 'user';
}

async function fetchUsers(ids: string[]): Promise<User[]> {
  // Fetch users in parallel with max 3 concurrent requests
  const results = await parallel(3, ids, async (id) => {
    const [err, user] = await tryFn(async () => {
      const res = await fetch(`/api/users/${id}`);
      if (!res.ok) throw new Error('Failed to fetch');
      return res.json() as Promise<User>;
    })();
    
    // Returns error or user - no exceptions thrown
    return err ? null : user;
  });
  
  // Filter out failed requests
  const users = results.filter((u): u is User => u !== null);
  
  // Group users by role
  const byRole = group(users, u => u.role);
  
  // Create lookup map by ID
  const userMap = objectify(
    users,
    u => u.id,
    u => u
  );
  
  console.log('Admins:', byRole.admin?.length ?? 0);
  console.log('User map keys:', Object.keys(userMap));
  
  return users;
}

fetchUsers(['1', '2', '3']);

Use Cases

Pros & Cons

Pros

+Native TypeScript support with excellent type inference and narrowing, unlike Lodash's afterthought typings
+Tiny bundle impact due to tree-shaking and zero dependencies - includes only what you import
+Modern API design that complements ES6+ features rather than duplicating them
+Async utilities like try/retry/parallel simplify promise-heavy codebases significantly
+Active maintenance with focus on stability over feature bloat

Cons

−No method chaining support - requires functional composition instead of fluent API
−Smaller ecosystem and community compared to established alternatives like Lodash
−Documentation is less comprehensive than mature libraries, requiring more source code reading
−Missing some specialized utilities found in Lodash (debounce, throttle require separate packages)
−Breaking changes between major versions can require migration effort for large codebases