@nice-code/state 0.7.0 → 0.9.0

package/build/index.js

@@ -1,244 +1,2 @@
-// src/core/Store.ts
-import { deepEqual } from "fast-equals";
-import {
-  applyPatches,
-  enablePatches,
-  produce,
-  produceWithPatches
-} from "immer";
-enablePatches();
-function makeSubscriptionFunction(store, watch, listener) {
-  let lastWatchState = watch(store.getRawState());
-  return () => {
-    const currentState = store.getRawState();
-    const nextWatchState = watch(currentState);
-    if (nextWatchState === lastWatchState) {
-      return;
-    }
-    if (deepEqual(nextWatchState, lastWatchState)) {
-      lastWatchState = nextWatchState;
-      return;
-    }
-    const previousWatched = lastWatchState;
-    lastWatchState = nextWatchState;
-    listener(nextWatchState, currentState, previousWatched);
-  };
-}
-function makeReactionFunctionCreator(watch, reaction) {
-  return (store) => {
-    let lastWatchState = watch(store.getRawState());
-    return (forceRun = false) => {
-      const currentState = store.getRawState();
-      const nextWatchState = watch(currentState);
-      if (!forceRun) {
-        if (nextWatchState === lastWatchState) {
-          return;
-        }
-        if (deepEqual(nextWatchState, lastWatchState)) {
-          lastWatchState = nextWatchState;
-          return;
-        }
-      }
-      const previousWatched = lastWatchState;
-      lastWatchState = nextWatchState;
-      if (store._hasPatchListeners()) {
-        const [nextState, patches, inversePatches] = produceWithPatches(currentState, (draft) => {
-          reaction(nextWatchState, draft, currentState, previousWatched);
-        });
-        store._updateStateWithoutReaction(nextState);
-        if (patches.length > 0) {
-          store._emitPatches(patches, inversePatches);
-        }
-      } else {
-        const nextState = produce(currentState, (draft) => {
-          reaction(nextWatchState, draft, currentState, previousWatched);
-        });
-        store._updateStateWithoutReaction(nextState);
-      }
-    };
-  };
-}
-
-class Store {
-  currentState;
-  createInitialState;
-  ssr = false;
-  listeners = new Set;
-  reactionCreators = [];
-  reactions = [];
-  clientSubscriptions = [];
-  _patchListeners = [];
-  constructor(initialState) {
-    if (initialState instanceof Function) {
-      this.createInitialState = initialState;
-      this.currentState = initialState();
-    } else {
-      this.createInitialState = () => initialState;
-      this.currentState = initialState;
-    }
-  }
-  get state() {
-    return Object.freeze(this.currentState);
-  }
-  _setInternalOptions({ ssr, reactionCreators = [] }) {
-    this.ssr = ssr;
-    this.reactionCreators = reactionCreators;
-    this.reactions = reactionCreators.map((rc) => rc(this));
-  }
-  _getReactionCreators() {
-    return this.reactionCreators;
-  }
-  _instantiateReactions() {
-    this.reactions = this.reactionCreators.map((rc) => rc(this));
-  }
-  _getInitialState() {
-    return this.createInitialState();
-  }
-  _hasPatchListeners() {
-    return this._patchListeners.length > 0;
-  }
-  _emitPatches(patches, inversePatches) {
-    for (const listener of this._patchListeners) {
-      listener(patches, inversePatches);
-    }
-  }
-  _updateStateWithoutReaction(nextState) {
-    this.currentState = nextState;
-  }
-  _updateState(nextState) {
-    this.currentState = nextState;
-    for (const runReaction of this.reactions) {
-      runReaction();
-    }
-    if (this.ssr) {
-      return;
-    }
-    for (const runSubscription of this.clientSubscriptions) {
-      runSubscription();
-    }
-    for (const listener of this.listeners) {
-      listener();
-    }
-  }
-  getRawState() {
-    return this.currentState;
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  watch(watch, listener) {
-    if (this.ssr) {
-      return () => {
-        console.warn(`@nice-code/state: Subscriptions made on the server side are not registered, so this unsubscribe call does nothing.`);
-      };
-    }
-    const run = makeSubscriptionFunction(this, watch, listener);
-    this.clientSubscriptions.push(run);
-    return () => {
-      this.clientSubscriptions = this.clientSubscriptions.filter((f) => f !== run);
-    };
-  }
-  createReaction(watch, reaction, { runNow = false, runNowWithSideEffects = false } = {}) {
-    const creator = makeReactionFunctionCreator(watch, reaction);
-    this.reactionCreators.push(creator);
-    const run = creator(this);
-    this.reactions.push(run);
-    if (runNow || runNowWithSideEffects) {
-      run(true);
-      if (runNowWithSideEffects && !this.ssr) {
-        this._updateState(this.currentState);
-      }
-    }
-    return () => {
-      this.reactions = this.reactions.filter((f) => f !== run);
-      this.reactionCreators = this.reactionCreators.filter((f) => f !== creator);
-    };
-  }
-  listenToPatches(patchListener) {
-    this._patchListeners.push(patchListener);
-    return () => {
-      this._patchListeners = this._patchListeners.filter((f) => f !== patchListener);
-    };
-  }
-  update(updater, patchesCallback) {
-    update(this, updater, patchesCallback);
-  }
-  replace(newState) {
-    if (newState !== this.currentState) {
-      this._updateState(newState);
-    }
-  }
-  replaceFromCurrent(replacer) {
-    const nextState = replacer(this.currentState);
-    if (nextState !== this.currentState) {
-      this._updateState(nextState);
-    }
-  }
-  applyPatches(patches) {
-    applyPatchesToStore(this, patches);
-  }
-}
-function applyPatchesToStore(store, patches) {
-  const currentState = store.getRawState();
-  const nextState = applyPatches(currentState, patches);
-  if (nextState !== currentState) {
-    store._updateState(nextState);
-  }
-}
-function applyUpdaterWithPatches(currentState, updater) {
-  if (typeof updater === "function") {
-    const [next, patches2, inversePatches2] = produceWithPatches(currentState, (draft) => {
-      updater(draft, currentState);
-    });
-    return [next, patches2, inversePatches2];
-  }
-  let state = currentState;
-  const patches = [];
-  const inversePatches = [];
-  for (const single of updater) {
-    const [next, p, ip] = produceWithPatches(state, (draft) => {
-      single(draft, state);
-    });
-    state = next;
-    patches.push(...p);
-    inversePatches.push(...ip);
-  }
-  return [state, patches, inversePatches];
-}
-function applyUpdater(currentState, updater) {
-  if (typeof updater === "function") {
-    return produce(currentState, (draft) => {
-      updater(draft, currentState);
-    });
-  }
-  return updater.reduce((previousState, single) => produce(previousState, (draft) => {
-    single(draft, previousState);
-  }), currentState);
-}
-function update(store, updater, patchesCallback) {
-  const currentState = store.getRawState();
-  let nextState;
-  if (store._hasPatchListeners() || patchesCallback != null) {
-    const [next, patches, inversePatches] = applyUpdaterWithPatches(currentState, updater);
-    if (patches.length > 0) {
-      if (patchesCallback != null) {
-        patchesCallback(patches, inversePatches);
-      }
-      store._emitPatches(patches, inversePatches);
-    }
-    nextState = next;
-  } else {
-    nextState = applyUpdater(currentState, updater);
-  }
-  if (nextState !== currentState) {
-    store._updateState(nextState);
-  }
-}
-export {
-  update,
-  applyPatchesToStore,
-  Store
-};
+import { n as applyPatchesToStore, r as update, t as Store } from "./Store-PjfFkZ2I.js";
+export { Store, applyPatchesToStore, update };

package/build/react/index.d.ts

@@ -0,0 +1,58 @@
+import { r as Store } from "../Store-B65MojT2.js";
+import { ReactElement } from "react";
+
+//#region src/react/useStoreState.d.ts
+/**
+ * Compares the previously selected value against the next one. Returning `true`
+ * tells the hook the value is unchanged, so React is handed the *same*
+ * reference and no re-render is scheduled.
+ */
+type TEqualityFn<SS> = (a: SS, b: SS) => boolean;
+/**
+ * Subscribe a React component to a store, optionally narrowing to a derived
+ * slice.
+ *
+ * Built on `useSyncExternalStore`, so it is tear-free under React 18+
+ * concurrent rendering with no manual `useState`/`useEffect` subscription loop.
+ *
+ * A `useRef` cache holds the last selected value. On every store emission the
+ * selector is re-evaluated and the result is run through a strict-reference
+ * fast-path first; only if the reference differs is `equalityFn` consulted. A
+ * new reference is handed back to React exclusively when a genuine change is
+ * detected, so equal-but-new selector results never trigger a render.
+ */
+declare function useStoreState<S extends object>(store: Store<S>): S;
+declare function useStoreState<S extends object, SS>(store: Store<S>, getSubState: (state: S) => SS, equalityFn?: TEqualityFn<SS>): SS;
+//#endregion
+//#region src/react/InjectStoreState.d.ts
+interface IPropsInjectStoreState<S extends object, SS> {
+  store: Store<S>;
+  on?: (state: S) => SS;
+  /**
+   * Optional equality function for the selected slice. Defaults to a strict
+   * reference check; pass `deepEqual` from `fast-equals` for inline objects.
+   */
+  equalityFn?: TEqualityFn<SS>;
+  children: (output: SS) => ReactElement;
+}
+/**
+ * Render-prop binding: subscribes to `store` (optionally narrowed by `on`) and
+ * renders `children` with the selected slice.
+ */
+declare function InjectStoreState<S extends object, SS = S>({
+  store,
+  on,
+  equalityFn,
+  children
+}: IPropsInjectStoreState<S, SS>): ReactElement;
+//#endregion
+//#region src/react/useLocalStore.d.ts
+/**
+ * Create a component-local {@link Store} that persists across renders. Passing a
+ * `deps` array re-creates the store (with a fresh initial state) whenever the
+ * dependencies change by shallow comparison.
+ */
+declare function useLocalStore<S extends object>(initialState: (() => S) | S, deps?: ReadonlyArray<unknown>): Store<S>;
+//#endregion
+export { type IPropsInjectStoreState, InjectStoreState, type TEqualityFn, useLocalStore, useStoreState };
+//# sourceMappingURL=index.d.ts.map

package/build/react/index.js

@@ -1,318 +1,69 @@
-// src/react/useStoreState.ts
+import { t as Store } from "../Store-PjfFkZ2I.js";
 import { useCallback, useRef, useSyncExternalStore } from "react";
+//#region src/react/useStoreState.ts
 function strictEqual(a, b) {
-  return a === b;
+	return a === b;
 }
 function useStoreState(store, getSubState, equalityFn = strictEqual) {
-  const selectorRef = useRef(getSubState);
-  const equalityRef = useRef(equalityFn);
-  selectorRef.current = getSubState;
-  equalityRef.current = equalityFn;
-  const cacheRef = useRef(null);
-  const getSnapshot = useCallback(() => {
-    const rawState = store.getRawState();
-    const selector = selectorRef.current;
-    const nextValue = selector ? selector(rawState) : rawState;
-    const cache = cacheRef.current;
-    if (cache === null) {
-      cacheRef.current = { value: nextValue };
-      return nextValue;
-    }
-    const lastValue = cache.value;
-    if (nextValue === lastValue) {
-      return lastValue;
-    }
-    if (equalityRef.current(lastValue, nextValue)) {
-      return lastValue;
-    }
-    cache.value = nextValue;
-    return nextValue;
-  }, [store]);
-  const subscribe = useCallback((onStoreChange) => store.subscribe(onStoreChange), [store]);
-  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+	const selectorRef = useRef(getSubState);
+	const equalityRef = useRef(equalityFn);
+	selectorRef.current = getSubState;
+	equalityRef.current = equalityFn;
+	const cacheRef = useRef(null);
+	const getSnapshot = useCallback(() => {
+		const rawState = store.getRawState();
+		const selector = selectorRef.current;
+		const nextValue = selector ? selector(rawState) : rawState;
+		const cache = cacheRef.current;
+		if (cache === null) {
+			cacheRef.current = { value: nextValue };
+			return nextValue;
+		}
+		const lastValue = cache.value;
+		if (nextValue === lastValue) return lastValue;
+		if (equalityRef.current(lastValue, nextValue)) return lastValue;
+		cache.value = nextValue;
+		return nextValue;
+	}, [store]);
+	return useSyncExternalStore(useCallback((onStoreChange) => store.subscribe(onStoreChange), [store]), getSnapshot, getSnapshot);
 }
-
-// src/react/InjectStoreState.ts
-function InjectStoreState({
-  store,
-  on,
-  equalityFn,
-  children
-}) {
-  const state = useStoreState(store, on ?? ((s) => s), equalityFn);
-  return children(state);
-}
-// src/react/useLocalStore.ts
-import { useRef as useRef2 } from "react";
-
-// src/core/Store.ts
-import { deepEqual } from "fast-equals";
-import {
-  applyPatches,
-  enablePatches,
-  produce,
-  produceWithPatches
-} from "immer";
-enablePatches();
-function makeSubscriptionFunction(store, watch, listener) {
-  let lastWatchState = watch(store.getRawState());
-  return () => {
-    const currentState = store.getRawState();
-    const nextWatchState = watch(currentState);
-    if (nextWatchState === lastWatchState) {
-      return;
-    }
-    if (deepEqual(nextWatchState, lastWatchState)) {
-      lastWatchState = nextWatchState;
-      return;
-    }
-    const previousWatched = lastWatchState;
-    lastWatchState = nextWatchState;
-    listener(nextWatchState, currentState, previousWatched);
-  };
-}
-function makeReactionFunctionCreator(watch, reaction) {
-  return (store) => {
-    let lastWatchState = watch(store.getRawState());
-    return (forceRun = false) => {
-      const currentState = store.getRawState();
-      const nextWatchState = watch(currentState);
-      if (!forceRun) {
-        if (nextWatchState === lastWatchState) {
-          return;
-        }
-        if (deepEqual(nextWatchState, lastWatchState)) {
-          lastWatchState = nextWatchState;
-          return;
-        }
-      }
-      const previousWatched = lastWatchState;
-      lastWatchState = nextWatchState;
-      if (store._hasPatchListeners()) {
-        const [nextState, patches, inversePatches] = produceWithPatches(currentState, (draft) => {
-          reaction(nextWatchState, draft, currentState, previousWatched);
-        });
-        store._updateStateWithoutReaction(nextState);
-        if (patches.length > 0) {
-          store._emitPatches(patches, inversePatches);
-        }
-      } else {
-        const nextState = produce(currentState, (draft) => {
-          reaction(nextWatchState, draft, currentState, previousWatched);
-        });
-        store._updateStateWithoutReaction(nextState);
-      }
-    };
-  };
-}
-
-class Store {
-  currentState;
-  createInitialState;
-  ssr = false;
-  listeners = new Set;
-  reactionCreators = [];
-  reactions = [];
-  clientSubscriptions = [];
-  _patchListeners = [];
-  constructor(initialState) {
-    if (initialState instanceof Function) {
-      this.createInitialState = initialState;
-      this.currentState = initialState();
-    } else {
-      this.createInitialState = () => initialState;
-      this.currentState = initialState;
-    }
-  }
-  get state() {
-    return Object.freeze(this.currentState);
-  }
-  _setInternalOptions({ ssr, reactionCreators = [] }) {
-    this.ssr = ssr;
-    this.reactionCreators = reactionCreators;
-    this.reactions = reactionCreators.map((rc) => rc(this));
-  }
-  _getReactionCreators() {
-    return this.reactionCreators;
-  }
-  _instantiateReactions() {
-    this.reactions = this.reactionCreators.map((rc) => rc(this));
-  }
-  _getInitialState() {
-    return this.createInitialState();
-  }
-  _hasPatchListeners() {
-    return this._patchListeners.length > 0;
-  }
-  _emitPatches(patches, inversePatches) {
-    for (const listener of this._patchListeners) {
-      listener(patches, inversePatches);
-    }
-  }
-  _updateStateWithoutReaction(nextState) {
-    this.currentState = nextState;
-  }
-  _updateState(nextState) {
-    this.currentState = nextState;
-    for (const runReaction of this.reactions) {
-      runReaction();
-    }
-    if (this.ssr) {
-      return;
-    }
-    for (const runSubscription of this.clientSubscriptions) {
-      runSubscription();
-    }
-    for (const listener of this.listeners) {
-      listener();
-    }
-  }
-  getRawState() {
-    return this.currentState;
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  watch(watch, listener) {
-    if (this.ssr) {
-      return () => {
-        console.warn(`@nice-code/state: Subscriptions made on the server side are not registered, so this unsubscribe call does nothing.`);
-      };
-    }
-    const run = makeSubscriptionFunction(this, watch, listener);
-    this.clientSubscriptions.push(run);
-    return () => {
-      this.clientSubscriptions = this.clientSubscriptions.filter((f) => f !== run);
-    };
-  }
-  createReaction(watch, reaction, { runNow = false, runNowWithSideEffects = false } = {}) {
-    const creator = makeReactionFunctionCreator(watch, reaction);
-    this.reactionCreators.push(creator);
-    const run = creator(this);
-    this.reactions.push(run);
-    if (runNow || runNowWithSideEffects) {
-      run(true);
-      if (runNowWithSideEffects && !this.ssr) {
-        this._updateState(this.currentState);
-      }
-    }
-    return () => {
-      this.reactions = this.reactions.filter((f) => f !== run);
-      this.reactionCreators = this.reactionCreators.filter((f) => f !== creator);
-    };
-  }
-  listenToPatches(patchListener) {
-    this._patchListeners.push(patchListener);
-    return () => {
-      this._patchListeners = this._patchListeners.filter((f) => f !== patchListener);
-    };
-  }
-  update(updater, patchesCallback) {
-    update(this, updater, patchesCallback);
-  }
-  replace(newState) {
-    if (newState !== this.currentState) {
-      this._updateState(newState);
-    }
-  }
-  replaceFromCurrent(replacer) {
-    const nextState = replacer(this.currentState);
-    if (nextState !== this.currentState) {
-      this._updateState(nextState);
-    }
-  }
-  applyPatches(patches) {
-    applyPatchesToStore(this, patches);
-  }
+//#endregion
+//#region src/react/InjectStoreState.ts
+/**
+* Render-prop binding: subscribes to `store` (optionally narrowed by `on`) and
+* renders `children` with the selected slice.
+*/
+function InjectStoreState({ store, on, equalityFn, children }) {
+	return children(useStoreState(store, on ?? ((s) => s), equalityFn));
 }
-function applyPatchesToStore(store, patches) {
-  const currentState = store.getRawState();
-  const nextState = applyPatches(currentState, patches);
-  if (nextState !== currentState) {
-    store._updateState(nextState);
-  }
-}
-function applyUpdaterWithPatches(currentState, updater) {
-  if (typeof updater === "function") {
-    const [next, patches2, inversePatches2] = produceWithPatches(currentState, (draft) => {
-      updater(draft, currentState);
-    });
-    return [next, patches2, inversePatches2];
-  }
-  let state = currentState;
-  const patches = [];
-  const inversePatches = [];
-  for (const single of updater) {
-    const [next, p, ip] = produceWithPatches(state, (draft) => {
-      single(draft, state);
-    });
-    state = next;
-    patches.push(...p);
-    inversePatches.push(...ip);
-  }
-  return [state, patches, inversePatches];
-}
-function applyUpdater(currentState, updater) {
-  if (typeof updater === "function") {
-    return produce(currentState, (draft) => {
-      updater(draft, currentState);
-    });
-  }
-  return updater.reduce((previousState, single) => produce(previousState, (draft) => {
-    single(draft, previousState);
-  }), currentState);
-}
-function update(store, updater, patchesCallback) {
-  const currentState = store.getRawState();
-  let nextState;
-  if (store._hasPatchListeners() || patchesCallback != null) {
-    const [next, patches, inversePatches] = applyUpdaterWithPatches(currentState, updater);
-    if (patches.length > 0) {
-      if (patchesCallback != null) {
-        patchesCallback(patches, inversePatches);
-      }
-      store._emitPatches(patches, inversePatches);
-    }
-    nextState = next;
-  } else {
-    nextState = applyUpdater(currentState, updater);
-  }
-  if (nextState !== currentState) {
-    store._updateState(nextState);
-  }
-}
-
-// src/react/useLocalStore.ts
+//#endregion
+//#region src/react/useLocalStore.ts
+/**
+* Standard shallow comparison of dependency arrays — the same semantics React
+* uses for its own hook dependency lists. No deep traversal.
+*/
 function shallowEqualDeps(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (a == null || b == null || a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0;i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-  return true;
+	if (a === b) return true;
+	if (a == null || b == null || a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
 }
+/**
+* Create a component-local {@link Store} that persists across renders. Passing a
+* `deps` array re-creates the store (with a fresh initial state) whenever the
+* dependencies change by shallow comparison.
+*/
 function useLocalStore(initialState, deps) {
-  const storeRef = useRef2(null);
-  const depsRef = useRef2(deps);
-  if (storeRef.current === null) {
-    storeRef.current = new Store(initialState);
-  } else if (deps !== undefined && !shallowEqualDeps(depsRef.current, deps)) {
-    storeRef.current = new Store(initialState);
-    depsRef.current = deps;
-  }
-  return storeRef.current;
+	const storeRef = useRef(null);
+	const depsRef = useRef(deps);
+	if (storeRef.current === null) storeRef.current = new Store(initialState);
+	else if (deps !== void 0 && !shallowEqualDeps(depsRef.current, deps)) {
+		storeRef.current = new Store(initialState);
+		depsRef.current = deps;
+	}
+	return storeRef.current;
 }
-export {
-  useStoreState,
-  useLocalStore,
-  InjectStoreState
-};
+//#endregion
+export { InjectStoreState, useLocalStore, useStoreState };
+
+//# sourceMappingURL=index.js.map