Radash Utility Library

Common errors

• TypeError: _.someFunction is not a function

  cause Attempting to use a Radash function that is not part of the `_` namespace or is not a named export when using `import * as _ from 'radash'` or `import { someFunction } from 'radash'` respectively. It could also mean the function name is incorrect or it's a function from a different library (e.g., Lodash) that Radash does not provide.
  fix Verify the function name against the Radash documentation. If using `import * as _ from 'radash'`, ensure the function is accessed via `_.functionName`. If using named imports, ensure `functionName` is directly exported. For CommonJS, `const { functionName } = require('radash')` is typical.

• TS2307: Cannot find module 'radash' or its corresponding type declarations.

  cause TypeScript cannot locate the module or its type definitions. This typically occurs due to incorrect installation, misconfigured `tsconfig.json` paths, or using an outdated TypeScript version that doesn't properly resolve modern `package.json` 'exports' maps.
  fix Ensure `radash` is correctly installed (`npm install radash` or `yarn add radash`). Verify your `tsconfig.json` includes appropriate `moduleResolution` (e.g., 'NodeNext' or 'Bundler') and `module` (e.g., 'ESNext') settings for modern package resolution. Ensure TypeScript is up-to-date.

Warnings

• breaking The `sum` function received a 'type safer implementation' in v12.0.0. While intended to improve type inference and correctness, this change could lead to TypeScript errors if previous usage was less strictly typed or relied on implicit coercions.
  Fix: Review calls to `_.sum` (or `sum` if individually imported) and ensure that the values being summed are explicitly numbers or safely convertible. Adjust types or provide explicit type assertions if necessary.
• gotcha Radash intentionally avoids polymorphic behavior in some functions (e.g., `_.map` expecting only arrays, not objects) unlike older libraries like Lodash. This design choice promotes stronger type safety and deterministic behavior but means a direct drop-in replacement for highly polymorphic Lodash functions might require code adaptation.
  Fix: Familiarize yourself with Radash's API for specific data structures. Use dedicated object utilities (e.g., `mapValues`, `mapKeys`) or array utilities (`map`) as appropriate, rather than relying on a single function to handle multiple input types.
• gotcha When migrating from older utility libraries, be aware that Radash omits many functions that have become obsolete due to modern JavaScript features (e.g., optional chaining, null coalescing, native `Array.prototype` methods). Attempting to use these non-existent functions will result in runtime errors.
  Fix: Consult the Radash documentation for available functions. Where a native JavaScript solution exists, prefer it. For example, instead of a `_.get` with string paths from Lodash, consider optional chaining or `_.get` with a type-safe accessor function as demonstrated in Radash.
• deprecated Prior to v10.6.0, Radash was licensed under BSD 3-Clause. As of v10.6.0, the license changed to MIT. While not a breaking functional change, developers relying on the specific terms of the BSD license should be aware of this update.
  Fix: No code fix required. Ensure your project's license compatibility policies are updated if you upgrade from versions prior to 10.6.0.

Install

• npm install radash npm
• yarn add radash yarn
• pnpm add radash pnpm

Imports

• * as _

  import * as _ from 'radash'

  This imports all Radash functions under the '_' namespace, suitable for quick access or familiar usage patterns similar to Lodash.
• { max, sum }
  wrong:

  import { max, sum } from 'radash/dist/esm'

  correct:

  import { max, sum } from 'radash'

  For tree-shaking and explicit named imports, individual functions should be imported directly from the 'radash' package. Explicit subpath imports like 'radash/array' or 'radash/curry' are also supported for more granular control.
• CommonJS require
  wrong:

  const _ = require('radash')

  correct:

  const { get } = require('radash')

  While primarily targeting ESM, Radash supports CommonJS `require()` syntax. For individual functions, destructuring `require('radash')` is the correct approach. Importing the entire namespace with `const _ = require('radash')` is generally discouraged for modern Node.js applications due to tree-shaking limitations, but may technically work.

Quickstart

This quickstart demonstrates core Radash functionalities including array manipulation (`max`, `sum`), object transformation (`objectify`, `pick`), and robust asynchronous error handling (`tryit`).

import * as _ from 'radash'

const gods = [{
  name: 'Ra',
  power: 'sun',
  rank: 100,
  culture: 'egypt'
}, {
  name: 'Loki',
  power: 'tricks',
  rank: 72,
  culture: 'norse'
}, {
  name: 'Zeus',
  power: 'lightning',
  rank: 96,
  culture: 'greek'
}]

// Basic array operations
console.log('Max rank god:', _.max(gods, g => g.rank));
console.log('Total rank sum:', _.sum(gods, g => g.rank));

// Object manipulation
const godObject = _.objectify(
  gods, 
  g => g.name.toLowerCase(), 
  g => _.pick(g, ['power', 'rank', 'culture'])
);
console.log('Gods as object:', godObject);

// Asynchronous operations with error handling
const mockApi = {
  gods: {
    findByName: async (name) => {
      if (name === 'loki') throw new Error('Loki is elusive');
      return gods.find(g => g.name.toLowerCase() === name);
    }
  }
};

async function fetchAndLogGod(name) {
  const [err, god] = await _.try(mockApi.gods.findByName)(name);
  if (err) {
    console.error(`Failed to fetch ${name}:`, err.message);
  } else {
    console.log(`Fetched ${name}:`, god);
  }
}

fetchAndLogGod('ra');
fetchAndLogGod('loki');