Migrate

If a specific function or lodash code is given

1. Identify lodash functions from input

Extract which lodash functions are used and how they're imported.

2. Verify availability in source code

For each function, search both APIs:

• src/{category}/{fn}.ts — strict API
• src/compat/{category}/{fn}.ts — compat API

Read the implementation to understand the exact signature and any behavioral differences.

3. Determine the right migration path

If the function only exists in compat (like get, set, has), explain why — es-toolkit doesn't implement functions replaceable by modern JS (optional chaining ?., Object.hasOwn(), etc.).

4. Generate before/after migration

For each function, provide:

• Availability: es-toolkit and/or es-toolkit/compat
• Doc link: https://es-toolkit.dev/reference/{category}/{fn} (strict) or https://es-toolkit.dev/reference/compat/{category}/{fn} (compat)
• Before (lodash) and After (es-toolkit) code examples
• Any behavioral differences found in source code
• Feature comparison table: Compare API capabilities side-by-side (e.g., cancel support, flush, maxWait, return values, AbortSignal, callback arguments). Read both implementations to identify all supported options and present them in a table like:

• "When to use which": Based on the feature comparison, provide scenario-based guidance — e.g., "Use es-toolkit if you only need basic debounce; use compat if you rely on cancel/flush; keep lodash if you need X."

For migrations involving many functions, use a summary table instead of repeating the full template for each one.

5. Provide consolidated import rewrite

Show the final import transformation as a single block.

5a. Suggest automation patterns for large-scale migrations

When migrating many files, mention practical automation approaches:

• Bundler alias: Configure resolve.alias in webpack or Vite to redirect lodash imports at build time without changing source files:

  // vite.config.js or webpack.config.js
  resolve: { alias: { 'lodash': 'es-toolkit/compat' } }
  

• ESLint rule: Use no-restricted-imports to warn or error on remaining lodash imports after migration.
• Codemod: For systematic AST-based transforms, mention tools like jscodeshift if the migration pattern is complex.

6. Note bundle size impact

es-toolkit is up to 97% smaller than lodash and 2-3x faster. Bundle size numbers come from benchmarks/bundle-size/ and runtime performance numbers from benchmarks/performance/ and docs/performance.md — reference them for specific function comparisons if the user asks.

If no specific function (migration strategy overview)

Provide a strategic overview with three migration options:

• Option A: Direct to es-toolkit — new/small projects
• Option B: Gradual via compat — large codebases (recommended for legacy)
• Option C: Mixed — pragmatic approach

For each option, include a trade-off matrix:

Compat-exclusive functions: Search src/compat/ for functions that don't exist in src/ (strict). List representative examples so users know what can only come from compat (e.g., get, set, has).

For concrete behavioral differences, read a few representative function pairs from source (e.g., chunk, debounce) to give real examples rather than abstract descriptions.

Search local docs for discovery

If you need to check whether a lodash function has an es-toolkit equivalent:

• By name: Read docs/reference/{category}/{functionName}.md directly
• By keyword: Grep for the function name across docs/reference/**/*.md
• Compat-only functions: Glob docs/reference/compat/{category}/*.md — then check if the same file exists in docs/reference/{category}/
• Available categories: array, compat, error, function, map, math, object, predicate, promise, set, string, util