@plasius/react-state 1.0.10 → 1.0.12

package/tests/scoped.store.test.tsx

@@ -1,75 +0,0 @@
-import React from "react"; // tests/setup.ts
-import "@testing-library/jest-dom";
-import { render, fireEvent } from "@testing-library/react";
-import { describe, it, expect } from "vitest";
-import { createScopedStoreContext } from "../src";
-
-describe("scoped store", () => {
-  const initialState = { count: 0 };
-  const reducer = (
-    state: typeof initialState,
-    action: { type: string; payload?: number }
-  ) => {
-    switch (action.type) {
-      case "inc":
-        return { count: state.count + 1 };
-      case "dec":
-        return { count: state.count - 1 };
-      case "set":
-        return { count: action.payload ?? state.count };
-      default:
-        return state;
-    }
-  };
-
-  const store = createScopedStoreContext(reducer, initialState);
-
-  const Counter = () => {
-    const state = store.useStore();
-    const dispatch = store.useDispatch();
-
-    return (
-      <div>
-        <button id="counter-inc" onClick={() => dispatch({ type: "inc" })}>
-          +
-        </button>
-        <button id="counter-dec" onClick={() => dispatch({ type: "dec" })}>
-          -
-        </button>
-        <input
-          aria-label="Counter value"
-          title=""
-          id="counter-set"
-          type="number"
-          value={state.count}
-          onChange={(e) =>
-            dispatch({ type: "set", payload: Number(e.target.value) })
-          }
-        />
-      </div>
-    );
-  };
-
-  it("increments, decrements, and sets the counter correctly", () => {
-    const { getByText, getByLabelText } = render(
-      <store.Provider>
-        <Counter />
-      </store.Provider>
-    );
-
-    const incButton = getByText("+");
-    const decButton = getByText("-");
-    const input = getByLabelText("Counter value") as HTMLInputElement;
-
-    expect(input.value).toBe("0");
-
-    fireEvent.click(incButton);
-    expect(input.value).toBe("1");
-
-    fireEvent.click(decButton);
-    expect(input.value).toBe("0");
-
-    fireEvent.change(input, { target: { value: "5" } });
-    expect(input.value).toBe("5");
-  });
-});

package/tests/store.core.test.ts

@@ -1,295 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import {
-  createStore,
-  type Store,
-  type IState,
-  type IAction,
-} from "../src/store";
-
-type S = { count: number; meta?: { tag: string } };
-type A =
-  | { type: "inc" }
-  | { type: "set"; value: number }
-  | { type: "setMeta"; tag: string }
-  | { type: "noop" };
-
-const reducer = (s: S, a: A): S => {
-  switch (a.type) {
-    case "inc":
-      return { ...s, count: s.count + 1 };
-    case "set":
-      return { ...s, count: a.value };
-    case "setMeta":
-      return { ...s, meta: { tag: a.tag } };
-    case "noop":
-      return s; // return same reference to simulate no-change dispatch
-    default:
-      return s;
-  }
-};
-
-const initial: S = { count: 0, meta: { tag: "a" } };
-
-describe("createStore – basics", () => {
-  it("getState returns initial; dispatch updates", () => {
-    const store = createStore<S, A>(reducer, initial);
-    expect(store.getState()).toEqual(initial);
-    store.dispatch({ type: "inc" });
-    expect(store.getState().count).toBe(1);
-  });
-});
-
-describe("subscribe (global)", () => {
-  it("fires only when state reference changes (distinct-until-changed)", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const cb = vi.fn();
-    const un = store.subscribe(cb);
-
-    store.dispatch({ type: "noop" }); // same reference → no notify
-    store.dispatch({ type: "inc" });  // changed       → notify once
-
-    expect(cb).toHaveBeenCalledTimes(1);
-    un();
-    store.dispatch({ type: "inc" });
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("subscribeToKey (per-key)", () => {
-  it("notifies only when that key changes", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const cb = vi.fn();
-    const un = store.subscribeToKey("count", cb);
-
-    store.dispatch({ type: "setMeta", tag: "b" }); // different key
-    expect(cb).not.toHaveBeenCalled();
-
-    store.dispatch({ type: "inc" });
-    expect(cb).toHaveBeenCalledTimes(1);
-    expect(cb).toHaveBeenLastCalledWith(1);
-
-    un();
-    store.dispatch({ type: "inc" });
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-
-  it("removes empty key sets when last listener unsubscribes", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const cb1 = vi.fn();
-    const cb2 = vi.fn();
-
-    const un1 = store.subscribeToKey("count", cb1);
-    const un2 = store.subscribeToKey("count", cb2);
-
-    un1();
-    un2();
-    // We can't directly inspect keyListeners map, but we can assert no leaks by re-subscribing and ensuring it still works.
-    const cb3 = vi.fn();
-    const un3 = store.subscribeToKey("count", cb3);
-    store.dispatch({ type: "inc" });
-    expect(cb3).toHaveBeenCalledTimes(1);
-    un3();
-  });
-});
-
-describe("subscribeWithSelector (derived changes)", () => {
-  it("does not call immediately; calls when selected value changes", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const sel = (s: S) => s.count;
-    const cb = vi.fn();
-
-    const un = store.subscribeWithSelector(sel, cb);
-    expect(cb).not.toHaveBeenCalled();
-
-    store.dispatch({ type: "inc" });
-    expect(cb).toHaveBeenCalledTimes(1);
-    expect(cb).toHaveBeenLastCalledWith(1);
-
-    un();
-  });
-
-  it("does not call if selector result is referentially equal", () => {
-    const store = createStore<S, A>(reducer, { count: 0, meta: { tag: "x" } });
-    const sel = (s: S) => s.meta?.tag; // primitive equality
-    const cb = vi.fn();
-
-    const un = store.subscribeWithSelector(sel, cb);
-    store.dispatch({ type: "setMeta", tag: "x" }); // new object, same tag
-    expect(cb).not.toHaveBeenCalled();
-
-    store.dispatch({ type: "setMeta", tag: "y" });
-    expect(cb).toHaveBeenCalledTimes(1);
-    expect(cb).toHaveBeenLastCalledWith("y");
-    un();
-  });
-});
-
-describe("notification order", () => {
-  it("global → key → selector", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const calls: string[] = [];
-
-    const unG = store.subscribe(() => calls.push("global"));
-    const unK = store.subscribeToKey("count", () => calls.push("key"));
-    const unS = store.subscribeWithSelector(
-      (s) => s.count,
-      () => calls.push("selector")
-    );
-
-    store.dispatch({ type: "inc" });
-
-    expect(calls).toEqual(["global", "key", "selector"]);
-    unG();
-    unK();
-    unS();
-  });
-});
-
-describe("mutation during iteration (edge case)", () => {
-  it("unsubscribing within a global listener may skip the next listener (document current behavior)", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const log: string[] = [];
-
-    let un1: () => void = () => {};
-    const l1 = () => {
-      log.push("l1");
-      un1();
-    }; // removes itself during dispatch
-    const l2 = () => {
-      log.push("l2");
-    };
-
-    un1 = store.subscribe(l1);
-    store.subscribe(l2);
-
-    store.dispatch({ type: "inc" });
-
-    // Depending on Array#forEach semantics with splice, l2 might be skipped.
-    // Document current behavior so a future change (copy-before-iterate) can flip this expectation.
-    expect(log.length === 1 || log.length === 2).toBe(true);
-  });
-});
-
-describe("no-change dispatch side-effects", () => {
-  it("global does not fire; key/selector do not", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const g = vi.fn();
-    const k = vi.fn();
-    const s = vi.fn();
-
-    store.subscribe(g);
-    store.subscribeToKey("count", k);
-    store.subscribeWithSelector((st) => st.count, s);
-
-    store.dispatch({ type: "noop" }); // same reference returned → no notifications
-
-    expect(g).toHaveBeenCalledTimes(0);
-    expect(k).not.toHaveBeenCalled();
-    expect(s).not.toHaveBeenCalled();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Additional coverage for core store semantics
-
-describe("state identity & no-op behavior", () => {
-  it("returns the same state reference after a no-op and a new reference after a change", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const s1 = store.getState();
-    store.dispatch({ type: "noop" });
-    const s2 = store.getState();
-    expect(s2).toBe(s1); // identity equal on no-op
-
-    store.dispatch({ type: "inc" });
-    const s3 = store.getState();
-    expect(s3).not.toBe(s2); // new object on change
-  });
-});
-
-describe("unsubscribe semantics", () => {
-  it("global unsubscribe stops further notifications", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const cb = vi.fn();
-    const un = store.subscribe(cb);
-
-    store.dispatch({ type: "inc" });
-    expect(cb).toHaveBeenCalledTimes(1);
-    un();
-    store.dispatch({ type: "inc" });
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-
-  it("per-key unsubscribe stops further notifications", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const cb = vi.fn();
-    const un = store.subscribeToKey("count", cb);
-
-    store.dispatch({ type: "inc" });
-    expect(cb).toHaveBeenCalledTimes(1);
-    un();
-    store.dispatch({ type: "inc" });
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-
-  it("selector unsubscribe stops further notifications", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const cb = vi.fn();
-    const un = store.subscribeWithSelector((s) => s.count, cb);
-
-    store.dispatch({ type: "inc" });
-    expect(cb).toHaveBeenCalledTimes(1);
-    un();
-    store.dispatch({ type: "inc" });
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("multiple subscribers", () => {
-  it("notifies all global subscribers once per change", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const a = vi.fn();
-    const b = vi.fn();
-    store.subscribe(a);
-    store.subscribe(b);
-
-    store.dispatch({ type: "inc" });
-
-    expect(a).toHaveBeenCalledTimes(1);
-    expect(b).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("mutation during iteration – per-key/selector", () => {
-  it("unsubscribing within a per-key listener may skip the next listener (document current behavior)", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const log: string[] = [];
-
-    let un1: () => void = () => {};
-    const l1 = () => { log.push("k1"); un1(); };
-    const l2 = () => { log.push("k2"); };
-
-    un1 = store.subscribeToKey("count", l1);
-    store.subscribeToKey("count", l2);
-
-    store.dispatch({ type: "inc" });
-
-    // Depending on iteration strategy, l2 may be skipped when l1 unsubscribes.
-    expect(log.length === 1 || log.length === 2).toBe(true);
-  });
-
-  it("unsubscribing within a selector listener may skip the next listener (document current behavior)", () => {
-    const store = createStore<S, A>(reducer, initial);
-    const log: string[] = [];
-
-    let un1: () => void = () => {};
-    const l1 = () => { log.push("s1"); un1(); };
-    const l2 = () => { log.push("s2"); };
-
-    un1 = store.subscribeWithSelector((s) => s.count, l1);
-    store.subscribeWithSelector((s) => s.count, l2);
-
-    store.dispatch({ type: "inc" });
-
-    expect(log.length === 1 || log.length === 2).toBe(true);
-  });
-});

package/tsconfig.build.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "NodeNext",
-    "lib": ["ESNext", "DOM"],
-    "moduleResolution": "NodeNext",
-    "jsx": "react-jsx",
-    "types": ["node", "vitest"],
-    "declaration": true,
-    "sourceMap": true,
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "noFallthroughCasesInSwitch": true,
-    "resolveJsonModule": true,
-    "outDir": "dist",
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src"]
-}

package/tsconfig.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.build.json",
-  "compilerOptions": {
-    "noEmit": true
-  },
-  "include": ["src", "test"]
-}

package/tsup.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  entry: ["src/index.ts"],
-  dts: true,
-  sourcemap: true,
-  clean: true,
-  format: ["esm", "cjs"],
-  target: "es2022",
-});

package/vitest.config.js

@@ -1,20 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "jsdom",
-    globals: true,
-    include: ["tests/**/*.test.{ts,tsx}"],
-    coverage: {
-      provider: "v8",
-      reporter: ["text", "lcov"],
-      reportsDirectory: "./coverage",
-      exclude: [
-        "tests/**",
-        "dist/**",
-        "**/*.config.{js,ts}",
-        "**/.eslintrc.{js,cjs}",
-      ],
-    },
-  },
-});