@jorvel/state

getSimpleStore<T>(key: string, initial: T): SimpleStore<T>;

class SimpleStore<T> {
  constructor(initial: T, opts?: { equalityFn?: (a: T, b: T) => boolean });
  get(): T;
  set(next: T): void;                              // notifies if !eq(prev, next)
  subscribe(listener: (v: T) => void): () => void;
  readonly listenerCount: number;
}

import { getSimpleStore } from '@jorvel/state';

const theme = getSimpleStore<'light' | 'dark'>('theme', 'light');

theme.subscribe((next) => document.documentElement.dataset.theme = next);

theme.set('dark');           // notifies
theme.set('dark');           // skipped — value didn't change

type Reducer<S, A> = (state: S, action: A) => S;

createStore<S, A>(initialState: S, reducer: Reducer<S, A>): Store<S, A>;
getStore<S, A>(key: string, initialState: S, reducer: Reducer<S, A>): Store<S, A>;

interface Store<S, A> {
  getState(): S;
  dispatch(action: A): void;                       // throws if called inside the reducer
  subscribe(listener: (s: S) => void): () => void;
  replaceReducer(next: Reducer<S, A>): void;
  replaceState(next: S): void;                     // throws inside a reducer
  readonly listenerCount: number;
}

import { getStore } from '@jorvel/state';

interface Cart { items: { sku: string; qty: number }[] }
type Action =
  | { type: 'add'; sku: string }
  | { type: 'remove'; sku: string }
  | { type: 'clear' };

const cart = getStore<Cart, Action>('cart', { items: [] }, (state, action) => {
  switch (action.type) {
    case 'add':    return { items: [...state.items, { sku: action.sku, qty: 1 }] };
    case 'remove': return { items: state.items.filter((i) => i.sku !== action.sku) };
    case 'clear':  return { items: [] };
    default:       return state;
  }
});

cart.dispatch({ type: 'add', sku: 'BOOK-42' });
cart.getState().items;       // [{ sku: 'BOOK-42', qty: 1 }]

createStoreWithMiddleware<S, A>(
  initialState: S,
  reducer: Reducer<S, A>,
  middlewares: Middleware<S, A>[],
): Store<S, A>;

applyMiddleware<S, A>(store: Store<S, A>, ...middlewares: Middleware<S, A>[]): Store<S, A>;

thunkMiddleware<S, A>(): Middleware<S, A | ThunkAction<S, A>>;
loggerMiddleware<S, A>(opts?: LoggerOptions): Middleware<S, A>;
persistenceMiddleware<S, A>(opts: PersistenceMiddlewareOptions<S>): Middleware<S, A>;

type Middleware<S, A> =
  (api: MiddlewareApi<S, A>) => (next: (action: A) => void) => (action: A) => void;

interface MiddlewareApi<S, A> {
  getState(): S;
  dispatch(action: A): void;
}

import { createStoreWithMiddleware, thunkMiddleware } from '@jorvel/state';

const cart = createStoreWithMiddleware<Cart, Action>(initial, reducer, [thunkMiddleware()]);

const fetchCart = (): ThunkAction<Cart, Action> => async (dispatch) => {
  const res = await fetch('/api/cart');
  const items = await res.json();
  dispatch({ type: 'replace', items });
};

cart.dispatch(fetchCart());

import { persistenceMiddleware } from '@jorvel/state';

const persisted = persistenceMiddleware<Cart, Action>({
  key: 'jorvel:cart',
  storage: typeof localStorage !== 'undefined' ? localStorage : undefined,
  serialize: JSON.stringify,
  deserialize: JSON.parse,
  throttleMs: 100,
  filter: (state) => ({ items: state.items }),     // omit derived fields
});

atom<T>(initial: T): WritableAtom<T>;          // { get(); set(next | (prev)=>next); subscribe(cb) }
derivedAtom<Deps, T>(deps: Deps, compute: (values) => T): ReadableAtom<T>;
isWritableAtom<T>(a: ReadableAtom<T>): a is WritableAtom<T>;

// @jorvel/state/react
useAtom<T>(atom: WritableAtom<T>): [T, (next: T | ((prev: T) => T)) => void];
useAtomValue<T>(atom: ReadableAtom<T>): T;       // subscribes
useSetAtom<T>(atom: WritableAtom<T>): (next) => void;  // setter only, no subscription

type Selector<S, R> = (state: S) => R;
type EqualityFn<R> = (a: R, b: R) => boolean;

shallowEqual<T extends object>(a: T, b: T): boolean;

createSelector<S, A, R>(...inputs: Selector<S, A>[], result: (...inputs: A[]) => R): Selector<S, R>;

createSelectorWith<S, R>(
  opts: { equalityFn: EqualityFn<R> },
  ...inputs: Selector<S, any>[],
  result: (...inputs: any[]) => R,
): Selector<S, R>;

createStructuredSelector<S, M extends Record<string, Selector<S, any>>>(
  map: M,
): Selector<S, { [K in keyof M]: ReturnType<M[K]> }>;

import { createSelector, createStructuredSelector } from '@jorvel/state';

const items = (s: Cart) => s.items;
const total = createSelector(items, (xs) => xs.reduce((n, i) => n + i.qty, 0));
const view  = createStructuredSelector({
  count: total,
  items,
});

view(cart.getState());       // { count: 3, items: [...] }

connectDevtools<S, A>(store: Store<S, A>, opts?: DevtoolsOptions): () => void;

interface DevtoolsOptions {
  name?: string;             // shown in the dropdown
  trace?: boolean;           // capture action stack traces
  maxAge?: number;           // history depth
}

if (process.env.NODE_ENV !== 'production') {
  connectDevtools(cart, { name: 'cart' });
}

const store = getStore('cart', initial, reducer);
const state = store.getState();
template = template.replace('</head>', `<script id="__CART__">window.__CART__=${safeJsonForScript(state)}</script></head>`);

const initial = (window as any).__CART__ ?? defaultInitial;
const store = getStore('cart', initial, reducer);   // first call wins — server state takes effect

// @internal — useful in test setup
_resetStore(key?: string): void;
_resetSimpleStore(key?: string): void;

import { _resetStore } from '@jorvel/state';

beforeEach(() => { _resetStore(); });