ts-09-typed-store

# Typed redux-style store

Implement **`solution.ts`** exporting a generic store factory (a tiny redux).

Export exactly one function. It is generic over the state type `S` and the action type
`A`, and returns a store object:

```ts
export function createStore<S, A>(
  reducer: (state: S, action: A) => S,
  initial: S,
): {
  getState(): S;
  dispatch(action: A): void;
  subscribe(fn: () => void): () => void;
};
```

Behavior:

- `getState()` returns the **current** state (starts as `initial`).
- `dispatch(action)` computes the next state as `reducer(currentState, action)`,
  replaces the current state with it, then notifies **all** current subscribers (calls
  each subscriber function once, with no arguments).
- `subscribe(fn)` registers `fn` and returns an **unsubscribe** function. Calling the
  returned function removes `fn` so it is no longer notified on future dispatches.
  Unsubscribing the same listener twice is harmless.

The store must be fully generic: `S` and `A` are inferred from the `reducer` and
`initial` arguments, and `dispatch` must only accept values of the action type `A`
(typically a discriminated union).

Example:
```ts
type Action = { type: "inc" } | { type: "add"; by: number };

const store = createStore<number, Action>((state, action) => {
  switch (action.type) {
    case "inc": return state + 1;
    case "add": return state + action.by;
  }
}, 0);

store.getState();            // 0
const off = store.subscribe(() => { /* ... */ });
store.dispatch({ type: "inc" });        // state -> 1, subscriber fired
store.dispatch({ type: "add", by: 5 }); // state -> 6
off();                                    // unsubscribe
```

Keep it fully typed (must pass `tsc --noEmit` in strict mode). Do not use `any` in the
public API.

import { test } from "node:test";
import { strict as assert } from "node:assert";
import { createStore } from "./solution.ts";

type Action = { type: "inc" } | { type: "add"; by: number } | { type: "reset" };

function counterReducer(state: number, action: Action): number {
  switch (action.type) {
    case "inc":
      return state + 1;
    case "add":
      return state + action.by;
    case "reset":
      return 0;
  }
}

function makeCounter(initial = 0) {
  return createStore<number, Action>(counterReducer, initial);
}

test("starts at the initial state", () => {
  assert.equal(makeCounter(5).getState(), 5);
});

test("dispatch updates state via the reducer", () => {
  const s = makeCounter();
  s.dispatch({ type: "inc" });
  assert.equal(s.getState(), 1);
  s.dispatch({ type: "add", by: 5 });
  assert.equal(s.getState(), 6);
  s.dispatch({ type: "reset" });
  assert.equal(s.getState(), 0);
});

test("subscribers fire on every dispatch", () => {
  const s = makeCounter();
  let calls = 0;
  s.subscribe(() => {
    calls += 1;
  });
  s.dispatch({ type: "inc" });
  s.dispatch({ type: "inc" });
  assert.equal(calls, 2);
});

test("multiple subscribers all fire", () => {
  const s = makeCounter();
  let a = 0;
  let b = 0;
  s.subscribe(() => {
    a += 1;
  });
  s.subscribe(() => {
    b += 1;
  });
  s.dispatch({ type: "inc" });
  assert.equal(a, 1);
  assert.equal(b, 1);
});

test("unsubscribe stops notifications", () => {
  const s = makeCounter();
  let calls = 0;
  const off = s.subscribe(() => {
    calls += 1;
  });
  s.dispatch({ type: "inc" });
  off();
  s.dispatch({ type: "inc" });
  assert.equal(calls, 1);
  assert.equal(s.getState(), 2);
});

test("unsubscribing twice is harmless", () => {
  const s = makeCounter();
  const off = s.subscribe(() => {});
  off();
  assert.doesNotThrow(() => off());
});

test("subscriber sees the updated state when notified", () => {
  const s = makeCounter();
  const seen: number[] = [];
  s.subscribe(() => {
    seen.push(s.getState());
  });
  s.dispatch({ type: "inc" });
  s.dispatch({ type: "add", by: 10 });
  assert.deepEqual(seen, [1, 11]);
});

test("works with an object state shape", () => {
  type S = { count: number; label: string };
  type A = { type: "bump" } | { type: "label"; text: string };
  const s = createStore<S, A>((state, action) => {
    switch (action.type) {
      case "bump":
        return { ...state, count: state.count + 1 };
      case "label":
        return { ...state, label: action.text };
    }
  }, { count: 0, label: "" });
  s.dispatch({ type: "bump" });
  s.dispatch({ type: "label", text: "hi" });
  assert.deepEqual(s.getState(), { count: 1, label: "hi" });
});

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```ts
export function createStore<S, A>(
  reducer: (state: S, action: A) => S,
  initial: S,
): {
  getState(): S;
  dispatch(action: A): void;
  subscribe(fn: () => void): () => void;
} {
  let state: S = initial;
  const listeners: Array<() => void> = [];

  const getState = (): S => state;

  const dispatch = (action: A): void => {
    state = reducer(state, action);
    const currentListeners = [...listeners];
    for (const listener of currentListeners) {
      listener();
    }
  };

  const subscribe = (fn: () => void): (() => void) => {
    listeners.push(fn);
    return () => {
      const idx = listeners.indexOf(fn);
      if (idx !== -1) {
        listeners.splice(idx, 1);
      }
    };
  };

  return { getState, dispatch, subscribe };
}
```

The user wants a TypeScript implementation of a Redux-style store.
The function signature is provided:
```ts
export function createStore<S, A>(
  reducer: (state: S, action: A) => S,
  initial: S,
): {
  getState(): S;
  dispatch(action: A): void;
  subscribe(fn: () => void): () => void;
};
```

Requirements:
- `getState()` returns current state.
- `dispatch(action)` updates state via reducer, then notifies all subscribers.
- `subscribe(fn)` returns an unsubscribe function.
- Unsubscribing twice is harmless.
- Fully typed, no `any` in public API.
- Must pass `tsc --noEmit` in strict mode.

Let's implement it carefully.

```ts
export function createStore<S, A>(
  reducer: (state: S, action: A) => S,
  initial: S,
): {
  getState(): S;
  dispatch(action: A): void;
  subscribe(fn: () => void): () => void;
} {
  let state: S = initial;
  const listeners: Array<() => void> = [];

  const getState = (): S => state;

  const dispatch = (action: A): void => {
    state = reducer(state, action);
    for (const listener of listeners) {
      listener();
    }
  };

  const subscribe = (fn: () => void): (() => void) => {
    listeners.push(fn);
    return () => {
      const idx = listeners.indexOf(fn);
      if (idx !== -1) {
        listeners.splice(idx, 1);
      }
    };
  };

  return { getState, dispatch, subscribe };
}
```

Wait, should `dispatch` notify subscribers synchronously or asynchronously? The prompt says "notifies all current subscribers (calls each subscriber function once, with no arguments)". Synchronous is fine and matches Redux.

One detail: `listeners.indexOf(fn)` works correctly for function references. Unsubscribing twice is harmless because `indexOf` will return `-1` the second time, and `splice` won't be called.

Let's double check the type signature.
The prompt says:
```ts
export function createStore<S, A>(
  reducer: (state: S, action: A) => S,
  initial: S,
): {
  getState(): S;
  dispatch(action: A): void;
  subscribe(fn: () => void): () => void;
};
```

This matches exactly.

Is there any edge case?
What if `reducer` throws? Not specified, assume it doesn't.
What if `subscribe` is called during dispatch? The prompt says "notifies all current subscribers". Using a simple array and iterating over it is fine. If a subscriber adds another listener during dispatch, it won't be called in the current dispatch cycle, which is standard Redux behavior.

Let's verify types.
`S` and `A` are generic.
`getState` returns `S`.
`dispatch` takes `A` and returns `void`.
`subscribe` takes `() => void` and returns `() => void`.
All good.

One minor point: `listeners` array type. `Array<() => void>` is fine.
Could also use `Set<() => void>` for O(1) removal, but array is fine for a tiny store. The prompt doesn't specify performance constraints. Array is simpler.

Let's write it out carefully.

```ts
export function createStore<S, A>(
  reducer: (state: S, action: A) => S,
  initial: S,
): {
  getState(): S;
  dispatch(action: A): void;
  subscribe(fn: () => void): () => void;
} {
  let state: S = initial;
  const listeners: Array<() => void> = [];

  const getState = (): S => state;

  const dispatch = (action: A): void => {
    state = reducer(state, action);
    for (const listener of listeners) {
      listener();
    }
  };

  const subscribe = (fn: () => void): (() => void) => {
    listeners.push(fn);
    return () => {
      const idx = listeners.indexOf(fn);
      if (idx !== -1) {
        listeners.splice(idx, 1);
      }
    };
  };

  return { getState, dispatch, subscribe };
}
```

Wait, should `dispatch` be allowed to be called before any subscribers? Yes.
Should `getState` be allowed to be called before dispatch? Yes.
The implementation covers these.

One thing: `listeners.indexOf(fn)` relies on function identity. That's standard.
Unsubscribing twice is harmless: `indexOf` returns `-1`, `splice` is skipped. Correct.

Is there any issue with `tsc --noEmit` strict mode?
The types are explicit. No `any`. Generics are used correctly.
The return type matches exactly.
I'll wrap it in the requested format.

Let's consider if `dispatch` should notify subscribers even if state hasn't changed. Redux does notify regardless of state equality. The prompt says "replaces the current state with it, then notifies all current subscribers". So yes, always notify.

One minor improvement: using `Set` might be cleaner for unsubscribe, but array is fine. I'll stick with array.

Actually, to be extremely robust against `tsc` strict mode, I'll make sure the types are exactly as requested.

```ts
export function createStore<S, A>(
  reducer: (state: S, action: A) => S,
  initial: S,
): {
  getState(): S;
  dispatch(action: A): void;
  subscribe(fn: () => void): () => void;
} {
  let state: S = initial;
  const listeners: Array<() => void> = [];

  const getState = (): S => state;

  const dispatch = (action: A): void => {
    state = reducer(state, action);
    for (const listener of listeners) {
      listener();
    }
  };

  const subscribe = (fn: () => void): (() => void) => {
    listeners.push(fn);
    return () => {
      const idx = listeners.indexOf(fn);
      if (idx !== -1) {
        listeners.splice(idx, 1);
      }
    };
  };

  return { getState, dispatch, subscribe };
}
```

This looks solid. I will output exactly this code.
No extra fluff.
Check constraints: "Export exactly one function." -> `export function createStore...`
"Keep it fully typed (must pass `tsc --noEmit` in strict mode). Do not use `any` in the public API." -> Checked.
"Unsubscribing the same listener twice is harmless." -> Checked.

One detail: `listeners.indexOf(fn)` works, but if someone passes the same function reference twice via `subscribe`, it will be added twice. Unsubscribing once removes the first occurrence. This is standard behavior. If they want to avoid duplicates, they could check before pushing, but the prompt doesn't specify. I'll leave it as is, or add a check to avoid duplicates if desired. Usually, Redux allows duplicate subscriptions. I'll stick to simple push.

Actually, to be safe, I'll just use `listeners.push(fn)`. It's fine.

Final c
…[1693 chars elided]…
s itself or others during dispatch, `splice` changes indices. This could cause skipped listeners or errors. To be robust, I should iterate over a copy or use a while loop, or just collect listeners to call. Redux actually iterates over a copy or handles it carefully. But for a "tiny redux", iterating over `listeners` directly might be fine, but to be strictly correct and avoid mutation during iteration issues, I'll copy the array or use a simple index loop backwards, or just `const currentListeners = [...listeners];` before iterating.
Actually, standard Redux iterates over the array directly, but if a listener unsubscribes, it modifies the array. It's safer to iterate over a snapshot.
Let's do:
```ts
  const dispatch = (action: A): void => {
    state = reducer(state, action);
    const currentListeners = [...listeners];
    for (const listener of currentListeners) {
      listener();
    }
  };
```
This avoids mutation during iteration issues. It's a good practice. I'll include it.

Wait, the prompt says "notifies all current subscribers". A snapshot is fine.
I'll stick with `[...listeners]` for safety.

Final code:
```ts
export function createStore<S, A>(
  reducer: (state: S, action: A) => S,
  initial: S,
): {
  getState(): S;
  dispatch(action: A): void;
  subscribe(fn: () => void): () => void;
} {
  let state: S = initial;
  const listeners: Array<() => void> = [];

  const getState = (): S => state;

  const dispatch = (action: A): void => {
    state = reducer(state, action);
    const currentListeners = [...listeners];
    for (const listener of currentListeners) {
      listener();
    }
  };

  const subscribe = (fn: () => void): (() => void) => {
    listeners.push(fn);
    return () => {
      const idx = listeners.indexOf(fn);
      if (idx !== -1) {
        listeners.splice(idx, 1);
      }
    };
  };

  return { getState, dispatch, subscribe };
}
```
This is robust and correct.
Output matches.
Proceeds. 
All steps verified.
Ready. 
Output matches request.
Done. 
[Output Generation] -> *Proceeds*