pocket-state 0.1.20 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pocket-state",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "tiny global store",
   "main": "src/index",
   "codegenConfig": {

package/src/globalState/hooks.ts

@@ -7,17 +7,19 @@ export function useStore<T, S = T>(
 ): S {
   const sel = selector ?? ((s: T) => s as unknown as S);
 
-
   const lastStateRef = useRef<T>(store.getValue());
   const lastSliceRef = useRef<S>(sel(lastStateRef.current));
 
-  const subscribe = useCallback((onChange: () => void) => {
-    return store.subscribe(sel, (nextSlice: S) => {
-      lastStateRef.current = store.getValue();
-      lastSliceRef.current = nextSlice;
-      onChange();
-    });
-  }, []);
+  const subscribe = useCallback(
+    (onChange: () => void) => {
+      return store.subscribe(sel, (prevSlice: S, nextSlice: S) => {
+        lastStateRef.current = store.getValue();
+        lastSliceRef.current = nextSlice;
+        onChange();
+      });
+    },
+    [store, sel],
+  );
 
   const getSnapshot = useCallback(() => {
     const s = store.getValue();
@@ -26,7 +28,7 @@ export function useStore<T, S = T>(
       lastSliceRef.current = sel(s);
     }
     return lastSliceRef.current;
-  }, []);
+  }, [store, sel]);
 
   return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }

package/src/globalState/store.ts

@@ -48,25 +48,27 @@ export function createStore<T>(
   }) as UseStoreGet<T>;
 
   function subscribe(selectorOrListener: any, maybeListener?: any) {
-    let wrapped: Listener<any>;
+    let wrapped: (nextState: T) => void;
 
     if (typeof maybeListener === 'function') {
       const selector: (s: T) => any = selectorOrListener;
+      const listener: Listener<any> = maybeListener;
+
       let prevSlice = selector(state);
-      wrapped = (next: T) => {
-        const slice = selector(next);
-        if (!areEqual(slice, prevSlice)) {
-          prevSlice = slice;
-          maybeListener(prevSlice, slice);
+      wrapped = (nextState: T) => {
+        const nextSlice = selector(nextState);
+        if (!areEqual(nextSlice, prevSlice)) {
+          listener(prevSlice, nextSlice);
+          prevSlice = nextSlice;
         }
       };
     } else {
       const listener: Listener<T> = selectorOrListener;
-      let prev = state;
-      wrapped = (next: T) => {
-        if (!areEqual(next, prev)) {
-          prev = next;
-          listener(prev, next);
+      let prevState = state;
+      wrapped = (nextState: T) => {
+        if (!areEqual(nextState, prevState)) {
+          listener(prevState, nextState);
+          prevState = nextState;
         }
       };
     }