reselect createSelector memoized selectors: working versions (tested 2026-10-16)

{
  "name": "reselect-create-selector",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node --import tsx --test test/*.test.ts"
  },
  "dependencies": {
    "reselect": "5.3.0"
  },
  "devDependencies": {
    "@types/node": "26.6.5",
    "tsx": "4.23.15"
  }
}

import { createSelector, weakMapMemoize } from "reselect";

export type Todo = {
  id: string;
  text: string;
  done: boolean;
};

export type Filter = "all" | "active" | "completed";

export type User = { id: string; name: string };

export type RootState = {
  todos: {
    items: Todo[];
    filter: Filter;
  };
  users: {
    byId: Record<string, User>;
  };
};

export const selectTodoItems = (state: RootState) => state.todos.items;
export const selectTodoFilter = (state: RootState) => state.todos.filter;
export const selectUsersById = (state: RootState) => state.users.byId;

export const selectVisibleTodos = createSelector(
  [selectTodoItems, selectTodoFilter],
  (items, filter) => {
    switch (filter) {
      case "active":
        return items.filter((todo) => !todo.done);
      case "completed":
        return items.filter((todo) => todo.done);
      default:
        return items;
    }
  }
);

export const selectTodoStats = createSelector(
  [selectTodoItems],
  (items) => ({
    total: items.length,
    done: items.filter((todo) => todo.done).length,
  }),
  { memoize: weakMapMemoize }
);

export const makeSelectTodoById = () =>
  createSelector(
    [
      (state: RootState) => state.todos.items,
      (_state: RootState, id: string) => id,
    ],
    (items, id) => items.find((todo) => todo.id === id) ?? null
  );

export const selectUserById = createSelector(
  [selectUsersById, (_state: RootState, id: string) => id],
  (byId, id) => byId[id] ?? null
);

import { test } from "node:test";
import assert from "node:assert/strict";
import { createSelector } from "reselect";
import {
  makeSelectTodoById,
  selectTodoStats,
  selectUserById,
  selectVisibleTodos,
  type RootState,
} from "../src/selectors.ts";

const state: RootState = {
  todos: {
    items: [
      { id: "1", text: "write tests", done: true },
      { id: "2", text: "ship recipe", done: false },
    ],
    filter: "active",
  },
  users: { byId: { u1: { id: "u1", name: "Ada" } } },
};

test("combines multiple input selectors", () => {
  assert.deepEqual(
    selectVisibleTodos(state).map((todo) => todo.id),
    ["2"]
  );
});

test("runs the combiner once for identical inputs", () => {
  let calls = 0;
  const selectCount = createSelector(
    [(s: RootState) => s.todos.items],
    (items) => {
      calls++;
      return items.length;
    }
  );

  assert.equal(selectCount(state), 2);
  assert.equal(selectCount(state), 2);
  assert.equal(calls, 1);
});

test("recomputes the combiner when inputs change", () => {
  let calls = 0;
  const selectCount = createSelector(
    [(s: RootState) => s.todos.items],
    (items) => {
      calls++;
      return items.length;
    }
  );

  selectCount(state);
  selectCount({
    ...state,
    todos: { ...state.todos, items: state.todos.items.slice(0, 1) },
  });
  assert.equal(calls, 2);
});

test("weakMapMemoize returns a stable reference for stable inputs", () => {
  const first = selectTodoStats(state);
  const second = selectTodoStats(state);
  assert.equal(first, second);
  assert.deepEqual(first, { total: 2, done: 1 });
});

test("parameterized selector resolves per-argument results", () => {
  const selectTodoById = makeSelectTodoById();
  assert.equal(selectTodoById(state, "1")?.text, "write tests");
  assert.equal(selectTodoById(state, "2")?.text, "ship recipe");
  assert.equal(selectTodoById(state, "missing"), null);
});

test("parameterized selector memoizes repeated arguments", () => {
  const first = selectUserById(state, "u1");
  const second = selectUserById(state, "u1");
  assert.equal(first, second);
  assert.equal(first?.name, "Ada");
});