synstate 6.1.0 → 6.2.1

package/src/utils/create-reducer.mts

@@ -1,6 +1,7 @@
-import { replaceEqualDeep, type ReplaceEqualDeepOptions } from 'ts-data-forge';
+import type { ReplaceEqualDeepOptions } from 'ts-data-forge';
 import type { Reducer } from 'ts-type-forge';
-import { source, type InitializedObservable } from '../core/index.mjs';
+import type { InitializedObservable } from '../core/index.mjs';
+import { createStateSource } from './state-source.mjs';
 
 /**
  * Creates a reducer-based state management container following the Redux pattern.
@@ -91,33 +92,17 @@ export const createReducer = <S, A>(
     initialState: S;
   }>,
 ] => {
-  const state = source<S>(initialState);
-
-  const equals = options?.equals ?? Object.is;
-
-  const keepEqualParts = options?.keepEqualParts ?? false;
-
-  const keepOptions =
-    typeof keepEqualParts === 'boolean' ? undefined : keepEqualParts;
+  const { state, getSnapshot, commit } = createStateSource(
+    initialState,
+    options,
+  );
 
   const dispatch = (action: A): S => {
-    const currentState = state.getSnapshot().value;
+    const currentState = getSnapshot();
 
-    const reduced = reducer(currentState, action);
-
-    const nextState =
-      keepEqualParts === false
-        ? reduced
-        : replaceEqualDeep(currentState, reduced, keepOptions);
-
-    // Once completed, `next` keeps the state held and returns it.
-    return equals(currentState, nextState)
-      ? currentState
-      : state.next(nextState);
+    return commit(currentState, reducer(currentState, action));
   };
 
-  const getSnapshot = (): S => state.getSnapshot().value;
-
   return [state, dispatch, { getSnapshot, initialState }] as const;
 };
 
@@ -126,18 +111,18 @@ export const createReducer = <S, A>(
  */
 export type StateOptions<S> = Readonly<{
   /**
-   * Whether the next state is the same as the current one. When it says so,
-   * the update is not passed on — no subscriber, and nothing derived from
-   * the state, is told of it — and the current state is kept, along with its
-   * identity: `setState` and the like return the current state rather than
-   * the next.
+   * Whether the next state is the same as the current one. When it says so, the
+   * update is not passed on — no subscriber, and nothing derived from the
+   * state, is told of it — and the current state is kept, along with its
+   * identity: `setState` and the like return the current state rather than the
+   * next.
    *
    * Decide here, where the state is held, rather than downstream with
-   * `skipIfNoChange`: an update passed on here reaches whatever reads the
-   * state directly before any operator can thin it out.
+   * `skipIfNoChange`: an update passed on here reaches whatever reads the state
+   * directly before any operator can thin it out.
    *
-   * Defaults to `Object.is`, so writing the value already held passes
-   * nothing on. Pass `() => false` to pass on every update, equal or not.
+   * Defaults to `Object.is`, so writing the value already held passes nothing
+   * on. Pass `() => false` to pass on every update, equal or not.
    *
    * @param current - The state held now
    * @param next - The state the update would set
@@ -147,8 +132,8 @@ export type StateOptions<S> = Readonly<{
   /**
    * Whether an update keeps the parts of the state it did not change. With
    * `true`, the next state is compared with the current one before it is
-   * written, and every part of it deeply equal to the same part of the
-   * current state is replaced by that part (`replaceEqualDeep` of
+   * written, and every part of it deeply equal to the same part of the current
+   * state is replaced by that part (`replaceEqualDeep` of
    * ts-data-forge): a reader of an unchanged part keeps the object it has, so
    * `map`, comparing with `Object.is`, stops there. When the whole next state is
    * deeply equal, the current state is kept and nothing is passed on, so
@@ -161,14 +146,14 @@ export type StateOptions<S> = Readonly<{
    * arrays are walked into; a `Map`, a `Set`, a `Date` or a class instance is
    * compared and kept whole.
    *
-   * Prefer this over `keepEqualParts()` downstream: keeping the parts where
-   * the state is written means no update with nothing in it is passed on at
-   * all, and nothing downstream has anything to undo.
+   * Prefer this over `keepEqualParts()` downstream: keeping the parts where the
+   * state is written means no update with nothing in it is passed on at all,
+   * and nothing downstream has anything to undo.
    *
-   * Defaults to `false`: the next state is written as given. With it on,
-   * each update compares deeply every part of the next state that is not
-   * the very object of the current one; a state whose updates already keep
-   * what they do not change, as `{ ...prev, x }` does, gains nothing from it.
+   * Defaults to `false`: the next state is written as given. With it on, each
+   * update compares deeply every part of the next state that is not the very
+   * object of the current one; a state whose updates already keep what they do
+   * not change, as `{ ...prev, x }` does, gains nothing from it.
    */
   keepEqualParts?: boolean | ReplaceEqualDeepOptions;
 }>;

package/src/utils/create-state.mts

@@ -1,26 +1,6 @@
 import type { InitializedObservable } from '../core/index.mjs';
-import { createReducer, type StateOptions } from './create-reducer.mjs';
-
-type Action<S> = Readonly<
-  | {
-      type: 'set';
-      nextState: S;
-    }
-  | {
-      type: 'update';
-      updateFn: (a: S) => S;
-    }
->;
-
-const reducer = <S,>(state: S, action: Action<S>): S => {
-  switch (action.type) {
-    case 'set':
-      return action.nextState;
-
-    case 'update':
-      return action.updateFn(state);
-  }
-};
+import type { StateOptions } from './create-reducer.mjs';
+import { createStateSource } from './state-source.mjs';
 
 /**
  * Creates a reactive state container with getter and setter methods.
@@ -127,8 +107,8 @@ const reducer = <S,>(state: S, action: Action<S>): S => {
  *
  * assert.strictEqual(report.getSnapshot().value, held);
  *
- * // An edited title: a new report and a new array, while the summary is
- * // the one held, so `summary` is not told of it.
+ * // An edited title: a new report and a new array, while the summary is the
+ * // one held, so `summary` is not told of it.
  * setReport({
  *   summary: { open: 1 },
  *   pulls: [{ number: 1, title: 'one (edited)' }],
@@ -161,19 +141,22 @@ export const createState = <S,>(
     initialState: S;
   }>,
 ] => {
-  const [state, dispatch, { getSnapshot }] = createReducer<S, Action<S>>(
-    reducer,
+  const { state, getSnapshot, commit } = createStateSource(
     initialState,
     options,
   );
 
-  const updateState = (updateFn: (prev: S) => S): S =>
-    dispatch({ type: 'update', updateFn });
+  // Each compares with the state the write started from, as `dispatch` does,
+  // and builds nothing on the way.
+  const updateState = (updateFn: (prev: S) => S): S => {
+    const currentState = getSnapshot();
+
+    return commit(currentState, updateFn(currentState));
+  };
 
-  const setState = (nextState: S): S => dispatch({ type: 'set', nextState });
+  const setState = (nextState: S): S => commit(getSnapshot(), nextState);
 
-  const resetState = (): S =>
-    dispatch({ type: 'set', nextState: initialState });
+  const resetState = (): S => commit(getSnapshot(), initialState);
 
   return [
     state,

package/src/utils/create-state.test.mts

@@ -54,8 +54,8 @@ describe(createState, () => {
   });
 
   // What `equals` is for: whatever reads the state, directly or through
-  // anything derived from it, is told only of a real change, and an equal
-  // value written over the current one leaves the object that is there.
+  // anything derived from it, is told only of a real change, and an equal value
+  // written over the current one leaves the object that is there.
   test('keeps the current object when `equals` finds the next one equal to it', () => {
     const [state, setState, { getSnapshot }] = createState<readonly number[]>(
       [1, 2],
@@ -77,6 +77,24 @@ describe(createState, () => {
     assert.deepStrictEqual(seen, [held]);
   });
 
+  test('updateState compares the result with the state updateFn was given', () => {
+    const [state, setState, { updateState }] = createState(0);
+
+    const seen = record(state);
+
+    // updateFn writes the state itself, then returns what it was given:
+    // equal to that, so nothing more is written and 5 stays.
+    updateState((prev) => {
+      setState(5);
+
+      return prev;
+    });
+
+    assert.deepStrictEqual(seen, [0, 5]);
+
+    assert.strictEqual(state.getSnapshot().value, 5);
+  });
+
   describe('keepEqualParts', () => {
     type Report = Readonly<{
       summary: Readonly<{ open: number }>;

package/src/utils/state-source.mts

@@ -0,0 +1,48 @@
+import { replaceEqualDeep } from 'ts-data-forge';
+import { source, type InitializedSourceObservable } from '../core/index.mjs';
+import type { StateOptions } from './create-reducer.mjs';
+
+/**
+ * What `createState` and `createReducer` are both built on: the source holding
+ * the state, its current value, and `commit`, the one way either writes it.
+ * `commit` writes `reduced` unless `equals` finds it the same as
+ * `currentState`, after keeping the parts of `currentState` it did not change
+ * when `keepEqualParts` asks for that, and returns the state written, or
+ * `currentState` when nothing was.
+ *
+ * Not part of the package's API: `gen:index:src` leaves this file out of the
+ * barrel.
+ */
+export const createStateSource = <S,>(
+  initialState: S,
+  options: StateOptions<S> | undefined,
+): Readonly<{
+  state: InitializedSourceObservable<S>;
+  getSnapshot: () => S;
+  commit: (currentState: S, reduced: S) => S;
+}> => {
+  const state = source<S>(initialState);
+
+  const getSnapshot = (): S => state.getSnapshot().value;
+
+  const equals = options?.equals ?? Object.is;
+
+  const keepEqualParts = options?.keepEqualParts ?? false;
+
+  const keepOptions =
+    typeof keepEqualParts === 'boolean' ? undefined : keepEqualParts;
+
+  const commit = (currentState: S, reduced: S): S => {
+    const nextState =
+      keepEqualParts === false
+        ? reduced
+        : replaceEqualDeep(currentState, reduced, keepOptions);
+
+    // Once completed, `next` keeps the state held and returns it.
+    return equals(currentState, nextState)
+      ? currentState
+      : state.next(nextState);
+  };
+
+  return { state, getSnapshot, commit };
+};