JS

js-tosorted-immutable

Ensures array immutability by using toSorted() instead of sort().

Install

mkdir -p .claude/skills/js-tosorted-immutable && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/3043" && unzip -o skill.zip -d .claude/skills/js-tosorted-immutable && rm skill.zip

Installs to .claude/skills/js-tosorted-immutable

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Use toSorted() instead of sort() to avoid mutating arrays. Apply when sorting arrays that are React props, state, or otherwise shared/referenced elsewhere.
155 chars✓ has a “when” trigger
Beginner

Key capabilities

  • Sort arrays immutably
  • Prevent array mutation bugs
  • Refactor mutable sort calls
  • Maintain React immutability model

How it works

It replaces the mutating .sort() method with .toSorted() to ensure the original array remains unchanged, preventing React state/prop bugs.

Inputs & outputs

You give it
Mutable array
You get back
New sorted array

When to use js-tosorted-immutable

  • Sorting arrays in React components
  • Refactoring mutable sort calls
  • Preventing stale closure bugs

About this skill

Use toSorted() Instead of sort() for Immutability

.sort() mutates the array in place, which can cause bugs with React Use .toSorted() to create a new sorted array without state and props. mutation.

Incorrect (mutates original array):

function UserList({ users }: { users: User[] }) {
  // Mutates the users prop array!
  const sorted = useMemo(
    () => users.sort((a, b) => a.name.localeCompare(b.name)),
    [users]
  )
  return <div>{sorted.map(renderUser)}</div>
}

Correct (creates new array):

function UserList({ users }: { users: User[] }) {
  // Creates new sorted array, original unchanged
  const sorted = useMemo(
    () => users.toSorted((a, b) => a.name.localeCompare(b.name)),
    [users]
  )
  return <div>{sorted.map(renderUser)}</div>
}

Why this matters in React:

  1. Props/state mutations break React's immutability model - React expects props and state to be treated as read-only
  2. Causes stale closure bugs - Mutating arrays inside closures (callbacks, effects) can lead to unexpected behavior

Browser support (fallback for older browsers):

.toSorted() is available in all modern browsers (Chrome 110+, Safari 16+, Firefox 115+, Node.js 20+). For older environments, use spread operator:

// Fallback for older browsers
const sorted = [...items].sort((a, b) => a.value - b.value)

Other immutable array methods:

  • .toSorted() - immutable sort
  • .toReversed() - immutable reverse
  • .toSpliced() - immutable splice
  • .with() - immutable element replacement

When not to use it

  • When in-place mutation is explicitly required for performance in non-React contexts

Limitations

  • Requires modern browser or Node.js environments for native support

How it compares

It enforces immutability by default, whereas standard sort() modifies the original data structure.

Compared to similar skills

js-tosorted-immutable side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
js-tosorted-immutable (this skill)16moNo flagsBeginner
code-standards25moReviewBeginner
writing-react-effects13moNo flagsIntermediate
rerender-functional-setstate16moNo flagsBeginner

Try saying

Example prompts that trigger this skill in your AI assistant.

Search skills

Search the agent skills registry