Skip to content

@augmentcode/ag-redux-toolkit

Redux + Saga state management for Svelte apps — designed for AI agents. Includes runtime TypeScript source, AI skills, and reference documentation for robust, observable, high-performance state management.

react/migration/writable-stores

sub-skill
93 linesSource

>-

React mutable state migration

Shared mutable React state maps to serializable slice state, action creators, andpure reducers. Keep component-local ephemeral UI state in React.

Svelte writable, readable, and $state examples are not React sourcepatterns. The React equivalents are useState, useReducer, context providerstate, custom hook state, and external mutable stores.

Before: shared React context state

tsx
import * as React from "react";

type CounterContextValue = { count: number; increment(): void; setUsername(name: string): void };
export const CounterContext = React.createContext<CounterContextValue | null>(null);

export function CounterProvider({ children }: { children: React.ReactNode }) {
  const [count, setCount] = React.useState(0);
  const [username, setUsername] = React.useState("");
  const increment = () => setCount((value) => value + 1);
  return <CounterContext.Provider value={{ count, increment, setUsername }}>{children}</CounterContext.Provider>;
}

After: slice state, actions, reducer

ts
import { createAction } from "@augmentcode/ag-redux-toolkit/utils/store/create-action";
import { createReducer } from "@augmentcode/ag-redux-toolkit/utils/store/create-reducer";

type CounterState = { count: number; username: string };
const initialState: CounterState = { count: 0, username: "" };

export const setCount = createAction<[value: number]>("counter/setCount");
export const increment = createAction("counter/increment");
export const setUsername = createAction<[value: string]>("counter/setUsername");

export const counterReducer = createReducer<CounterState>(initialState)
  .with(setCount, (state, { payload: [count] }) => count === state.count ? state : { ...state, count })
  .with(increment, (state) => ({ ...state, count: state.count + 1 }))
  .with(setUsername, (state, { payload: [username] }) => ({ ...state, username }));

Rules

  • Move shared, persisted, async-driven, or business state into slice state.
  • Keep reducers pure: no fetch, localStorage, timers, clocks, random IDs, ormutation.
  • Keep state serializable: no Date, Map, Set, class instances, functions,promises, or DOM objects.
  • Compute new state in reducers; React components dispatch action creators.
  • Preserve reference equality on no-op updates when practical to avoid needlessselector invalidation.

Component-local state remains local

tsx
import * as React from "react";

export function ProductCard() {
  const [isHovered, setHovered] = React.useState(false);
  return <article onMouseEnter={() => setHovered(true)} onMouseLeave={() => setHovered(false)} />;
}

Bad: reducer side effect

ts
// BAD: reducers must not persist or read external systems.
export function badSaveSettings(state: { theme: string }, action: { payload: [string] }) {
  localStorage.setItem("theme", action.payload[0]);
  return { ...state, theme: action.payload[0] };
}

Move the persistence into react/migration/side-effects saga guidance.

Cross-references

  • ../../../core/actions/SKILL.md — action creators.
  • ../../../core/reducers/SKILL.md — reducer patterns.
  • ../../../core/state-serialization/SKILL.md — serializable state rules.