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.zipInstalls 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.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
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:
- Props/state mutations break React's immutability model - React expects props and state to be treated as read-only
- 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.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| js-tosorted-immutable (this skill) | 1 | 6mo | No flags | Beginner |
| code-standards | 2 | 5mo | Review | Beginner |
| writing-react-effects | 1 | 3mo | No flags | Intermediate |
| rerender-functional-setstate | 1 | 6mo | No flags | Beginner |
Try saying
Example prompts that trigger this skill in your AI assistant.
More by TheOrcDev
View all by TheOrcDev →You might also like
code-standards
redpanda-data
TypeScript, React, and JavaScript best practices enforced by Ultracite/Biome.
writing-react-effects
dust-tt
Writes React components without unnecessary useEffect. Use when creating/reviewing React components, refactoring effects, or when code uses useEffect to transform data or handle events.
rerender-functional-setstate
TheOrcDev
Use functional setState updates to prevent stale closures and unnecessary callback recreations. Apply when updating state based on the current state value in React components.
tsh-writing-hooks
TheSoftwareHouse
Custom hook and composable patterns — naming, composition, stable return shapes, lifecycle cleanup, and testing strategies. Use when writing reusable logic units (React hooks, Vue composables), refactoring logic into hooks, debugging hook behavior, or reviewing hook implementations.
accessibility-compliance
wshobson
Implement WCAG 2.2 compliant interfaces with mobile accessibility, inclusive design patterns, and assistive technology support. Use when auditing accessibility, implementing ARIA patterns, building for screen readers, or ensuring inclusive user experiences.
react-modernization
wshobson
Upgrade React applications to latest versions, migrate from class components to hooks, and adopt concurrent features. Use when modernizing React codebases, migrating to React Hooks, or upgrading to latest React versions.