dev-react-microstore 2.0.0 → 3.0.0

package/dist/index.d.mts

@@ -1,5 +1,10 @@
 type StoreListener = () => void;
-declare function createStoreState<T extends object>(initialState: T): {
+type StoreOptions<T extends object> = {
+    asyncUpdate?: boolean;
+    debounceDelay?: number;
+    perKeyDebounce?: Partial<Record<keyof T, boolean>>;
+};
+declare function createStoreState<T extends object>(initialState: T, options?: StoreOptions<T>): {
     get: () => T;
     set: (next: Partial<T>) => void;
     subscribe: (keys: (keyof T)[], listener: StoreListener) => (() => void);

package/dist/index.d.ts

@@ -1,5 +1,10 @@
 type StoreListener = () => void;
-declare function createStoreState<T extends object>(initialState: T): {
+type StoreOptions<T extends object> = {
+    asyncUpdate?: boolean;
+    debounceDelay?: number;
+    perKeyDebounce?: Partial<Record<keyof T, boolean>>;
+};
+declare function createStoreState<T extends object>(initialState: T, options?: StoreOptions<T>): {
     get: () => T;
     set: (next: Partial<T>) => void;
     subscribe: (keys: (keyof T)[], listener: StoreListener) => (() => void);

package/dist/index.js

@@ -1 +1 @@
-"use strict";var K=Object.defineProperty;var P=Object.getOwnPropertyDescriptor;var v=Object.getOwnPropertyNames;var j=Object.prototype.hasOwnProperty;var I=(o,e)=>{for(var t in e)K(o,t,{get:e[t],enumerable:!0})},R=(o,e,t,c)=>{if(e&&typeof e=="object"||typeof e=="function")for(let d of v(e))!j.call(o,d)&&d!==t&&K(o,d,{get:()=>e[d],enumerable:!(c=P(e,d))||c.enumerable});return o};var C=o=>R(K({},"__esModule",{value:!0}),o);var w={};I(w,{createStoreState:()=>F,useStoreSelector:()=>E});module.exports=C(w);var T=require("react");function V(o,e){let t;return function(...c){t!==void 0&&clearTimeout(t),t=setTimeout(()=>o.apply(this,c),e)}}function F(o){let e=o,t=new Map,c=new Map;return{get:()=>e,set:l=>{if(!l)return;let a=[];for(let n in l){let u=n,m=e[u],r=l[u];m!==r&&(Object.is(m,r)||(e[u]=r,a.push(u)))}if(a.length!==0)for(let n of a)c.has(n)||c.set(n,V(()=>{var u;(u=t.get(n))==null||u.forEach(m=>m())},5)),c.get(n)()},subscribe:(l,a)=>{for(let n of l)t.has(n)||t.set(n,new Set),t.get(n).add(a);return()=>{var n;for(let u of l)(n=t.get(u))==null||n.delete(a)}},select:l=>{let a={},n=e;for(let u of l)a[u]=n[u];return a}}}function z(o,e){return o.length===e.length&&o.every((t,c)=>t===e[c])}function E(o,e){let t=(0,T.useRef)({}),c=(0,T.useRef)(null),d=(0,T.useRef)(null),x=(0,T.useRef)(null),h=(0,T.useRef)(!0),b=(0,T.useRef)({}),l=(0,T.useRef)(null);if(!c.current||!z(c.current,e)){let r=[],p=[];for(let k of e)if(typeof k=="string"){let y=k;r.push({key:y}),p.push(y)}else{let y=k;for(let s in y){let f=y[s],i=s;r.push({key:i,compare:f}),p.push(i)}}d.current=r,x.current=p,c.current=e}let a=d.current,n=x.current,u=()=>{let r=o.get();if(h.current){h.current=!1;let s={};for(let{key:f}of a){let i=r[f];b.current[f]=i,s[f]=i}return t.current=s,s}if(!(()=>{var s;for(let{key:f,compare:i}of a){let S=b.current[f],g=r[f];if(S===void 0||((s=i==null?void 0:i(S,g))!=null?s:!Object.is(S,g)))return!0}return!1})())return t.current;let y={};for(let{key:s,compare:f}of a){let i=b.current[s],S=r[s];i===void 0||(f?!f(i,S):!Object.is(i,S))?(b.current[s]=S,y[s]=S):y[s]=i}return t.current=y,y},m=(0,T.useMemo)(()=>{let r=o.get(),p={};for(let k of n)p[k]=r[k];return p},[n]);if(!l.current||x.current!==n){let r=n;l.current=p=>o.subscribe(r,p)}return(0,T.useSyncExternalStore)(l.current,u,()=>m)}0&&(module.exports={createStoreState,useStoreSelector});
+"use strict";var g=Object.defineProperty;var P=Object.getOwnPropertyDescriptor;var v=Object.getOwnPropertyNames;var j=Object.prototype.hasOwnProperty;var R=(a,r)=>{for(var c in r)g(a,c,{get:r[c],enumerable:!0})},I=(a,r,c,l)=>{if(r&&typeof r=="object"||typeof r=="function")for(let y of v(r))!j.call(a,y)&&y!==c&&g(a,y,{get:()=>r[y],enumerable:!(l=P(r,y))||l.enumerable});return a};var C=a=>I(g({},"__esModule",{value:!0}),a);var D={};R(D,{createStoreState:()=>F,useStoreSelector:()=>z});module.exports=C(D);var f=require("react");function V(a,r){let c;return function(...l){c!==void 0&&clearTimeout(c),c=setTimeout(()=>a.apply(this,l),r)}}function F(a,r={}){let c=a,{asyncUpdate:l=!0,debounceDelay:y=0,perKeyDebounce:k={}}=r,T=new Map,p=new Map;return{get:()=>c,set:d=>{var o,i;if(!d)return;let t=[];for(let n in d){let e=n,u=c[e],s=d[e];u!==s&&(Object.is(u,s)||(c[e]=s,t.push(e)))}if(t.length!==0)if(l)for(let n of t)k[n]!==!1?(p.has(n)||p.set(n,V(()=>{var u;(u=T.get(n))==null||u.forEach(s=>s())},y)),p.get(n)()):(o=T.get(n))==null||o.forEach(u=>u());else for(let n of t)(i=T.get(n))==null||i.forEach(e=>e())},subscribe:(d,t)=>{for(let o of d)T.has(o)||T.set(o,new Set),T.get(o).add(t);return()=>{var o;for(let i of d)(o=T.get(i))==null||o.delete(t)}},select:d=>{let t={},o=c;for(let i of d)t[i]=o[i];return t}}}function E(a,r){return a.length===r.length&&a.every((c,l)=>c===r[l])}function z(a,r){let c=(0,f.useRef)({}),l=(0,f.useRef)(null),y=(0,f.useRef)(null),k=(0,f.useRef)(null),T=(0,f.useRef)(!0),p=(0,f.useRef)({}),b=(0,f.useRef)(null);if(!l.current||!E(l.current,r)){let t=[],o=[];for(let i of r)if(typeof i=="string"){let n=i;t.push({key:n}),o.push(n)}else{let n=i;for(let e in n){let u=n[e],s=e;t.push({key:s,compare:u}),o.push(s)}}y.current=t,k.current=o,l.current=r}let h=y.current,m=k.current,K=()=>{let t=a.get();if(T.current){T.current=!1;let e={};for(let{key:u}of h){let s=t[u];p.current[u]=s,e[u]=s}return c.current=e,e}if(!(()=>{var e;for(let{key:u,compare:s}of h){let S=p.current[u],x=t[u];if(S===void 0||((e=s==null?void 0:s(S,x))!=null?e:!Object.is(S,x)))return!0}return!1})())return c.current;let n={};for(let{key:e,compare:u}of h){let s=p.current[e],S=t[e];s===void 0||(u?!u(s,S):!Object.is(s,S))?(p.current[e]=S,n[e]=S):n[e]=s}return c.current=n,n},d=(0,f.useMemo)(()=>{let t=a.get(),o={};for(let i of m)o[i]=t[i];return o},[m]);if(!b.current||k.current!==m){let t=m;b.current=o=>a.subscribe(t,o)}return(0,f.useSyncExternalStore)(b.current,K,()=>d)}0&&(module.exports={createStoreState,useStoreSelector});

package/dist/index.mjs

@@ -1 +1 @@
-import{useMemo as K,useRef as S,useSyncExternalStore as P}from"react";function v(T,c){let t;return function(...a){t!==void 0&&clearTimeout(t),t=setTimeout(()=>T.apply(this,a),c)}}function C(T){let c=T,t=new Map,a=new Map;return{get:()=>c,set:i=>{if(!i)return;let u=[];for(let e in i){let r=e,k=c[r],n=i[r];k!==n&&(Object.is(k,n)||(c[r]=n,u.push(r)))}if(u.length!==0)for(let e of u)a.has(e)||a.set(e,v(()=>{var r;(r=t.get(e))==null||r.forEach(k=>k())},5)),a.get(e)()},subscribe:(i,u)=>{for(let e of i)t.has(e)||t.set(e,new Set),t.get(e).add(u);return()=>{var e;for(let r of i)(e=t.get(r))==null||e.delete(u)}},select:i=>{let u={},e=c;for(let r of i)u[r]=e[r];return u}}}function j(T,c){return T.length===c.length&&T.every((t,a)=>t===c[a])}function V(T,c){let t=S({}),a=S(null),x=S(null),b=S(null),h=S(!0),m=S({}),i=S(null);if(!a.current||!j(a.current,c)){let n=[],y=[];for(let p of c)if(typeof p=="string"){let f=p;n.push({key:f}),y.push(f)}else{let f=p;for(let o in f){let l=f[o],s=o;n.push({key:s,compare:l}),y.push(s)}}x.current=n,b.current=y,a.current=c}let u=x.current,e=b.current,r=()=>{let n=T.get();if(h.current){h.current=!1;let o={};for(let{key:l}of u){let s=n[l];m.current[l]=s,o[l]=s}return t.current=o,o}if(!(()=>{var o;for(let{key:l,compare:s}of u){let d=m.current[l],g=n[l];if(d===void 0||((o=s==null?void 0:s(d,g))!=null?o:!Object.is(d,g)))return!0}return!1})())return t.current;let f={};for(let{key:o,compare:l}of u){let s=m.current[o],d=n[o];s===void 0||(l?!l(s,d):!Object.is(s,d))?(m.current[o]=d,f[o]=d):f[o]=s}return t.current=f,f},k=K(()=>{let n=T.get(),y={};for(let p of e)y[p]=n[p];return y},[e]);if(!i.current||b.current!==e){let n=e;i.current=y=>T.subscribe(n,y)}return P(i.current,r,()=>k)}export{C as createStoreState,V as useStoreSelector};
+import{useMemo as K,useRef as p,useSyncExternalStore as P}from"react";function v(a,i){let u;return function(...y){u!==void 0&&clearTimeout(u),u=setTimeout(()=>a.apply(this,y),i)}}function C(a,i={}){let u=a,{asyncUpdate:y=!0,debounceDelay:m=0,perKeyDebounce:S={}}=i,l=new Map,T=new Map;return{get:()=>u,set:f=>{var o,c;if(!f)return;let t=[];for(let n in f){let e=n,s=u[e],r=f[e];s!==r&&(Object.is(s,r)||(u[e]=r,t.push(e)))}if(t.length!==0)if(y)for(let n of t)S[n]!==!1?(T.has(n)||T.set(n,v(()=>{var s;(s=l.get(n))==null||s.forEach(r=>r())},m)),T.get(n)()):(o=l.get(n))==null||o.forEach(s=>s());else for(let n of t)(c=l.get(n))==null||c.forEach(e=>e())},subscribe:(f,t)=>{for(let o of f)l.has(o)||l.set(o,new Set),l.get(o).add(t);return()=>{var o;for(let c of f)(o=l.get(c))==null||o.delete(t)}},select:f=>{let t={},o=u;for(let c of f)t[c]=o[c];return t}}}function j(a,i){return a.length===i.length&&a.every((u,y)=>u===i[y])}function V(a,i){let u=p({}),y=p(null),m=p(null),S=p(null),l=p(!0),T=p({}),b=p(null);if(!y.current||!j(y.current,i)){let t=[],o=[];for(let c of i)if(typeof c=="string"){let n=c;t.push({key:n}),o.push(n)}else{let n=c;for(let e in n){let s=n[e],r=e;t.push({key:r,compare:s}),o.push(r)}}m.current=t,S.current=o,y.current=i}let h=m.current,k=S.current,g=()=>{let t=a.get();if(l.current){l.current=!1;let e={};for(let{key:s}of h){let r=t[s];T.current[s]=r,e[s]=r}return u.current=e,e}if(!(()=>{var e;for(let{key:s,compare:r}of h){let d=T.current[s],x=t[s];if(d===void 0||((e=r==null?void 0:r(d,x))!=null?e:!Object.is(d,x)))return!0}return!1})())return u.current;let n={};for(let{key:e,compare:s}of h){let r=T.current[e],d=t[e];r===void 0||(s?!s(r,d):!Object.is(r,d))?(T.current[e]=d,n[e]=d):n[e]=r}return u.current=n,n},f=K(()=>{let t=a.get(),o={};for(let c of k)o[c]=t[c];return o},[k]);if(!b.current||S.current!==k){let t=k;b.current=o=>a.subscribe(t,o)}return P(b.current,g,()=>f)}export{C as createStoreState,V as useStoreSelector};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dev-react-microstore",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "A minimal global state manager for React with fine-grained subscriptions.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -3,77 +3,102 @@ import { useMemo, useRef, useSyncExternalStore } from 'react'
 type StoreListener = () => void;
 
 function debounce<T extends (...args: any[]) => void>(fn: T, delay: number): T {
-    let timeoutId: ReturnType<typeof setTimeout> | undefined;
-    return function (this: ThisParameterType<T>, ...args: Parameters<T>) {
-        if (timeoutId !== undefined) {
-            clearTimeout(timeoutId);
-        }
-        timeoutId = setTimeout(() => fn.apply(this, args), delay);
-    } as T;
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  return function (this: ThisParameterType<T>, ...args: Parameters<T>) {
+    if (timeoutId !== undefined) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => fn.apply(this, args), delay);
+  } as T;
 }
 
-export function createStoreState<T extends object>(initialState: T) {
-    let state = initialState;
-
-    const keyListeners = new Map<keyof T, Set<StoreListener>>();
-    const debouncedNotifiers = new Map<keyof T, () => void>();
-
-    const get = () => state;
-
-    const set = (next: Partial<T>) => {
-        if (!next) return;
-
-        const updatedKeys: (keyof T)[] = [];
-        for (const key in next) {
-            const typedKey = key as keyof T;
-            const currentValue = state[typedKey];
-            const nextValue = next[typedKey];
-
-            if (currentValue === nextValue) continue;
-
-            if (!Object.is(currentValue, nextValue)) {
-                state[typedKey] = nextValue!;
-                updatedKeys.push(typedKey);
-            }
-        }
-
-        if (updatedKeys.length === 0) return;
+type StoreOptions<T extends object> = {
+  asyncUpdate?: boolean;
+  debounceDelay?: number;
+  perKeyDebounce?: Partial<Record<keyof T, boolean>>;
+};
 
-        for (const key of updatedKeys) {
-            if (!debouncedNotifiers.has(key)) {
-                debouncedNotifiers.set(key, debounce(() => {
-                    keyListeners.get(key)?.forEach(listener => listener());
-                }, 5));
-            }
-            debouncedNotifiers.get(key)!();
-        }
-    };
+export function createStoreState<T extends object>(
+  initialState: T, 
+  options: StoreOptions<T> = {}
+) {
+  let state = initialState;
+  const { 
+    asyncUpdate = true, 
+    debounceDelay = 0, 
+    perKeyDebounce = {} as Partial<Record<keyof T, boolean>>
+  } = options;
+  const keyListeners = new Map<keyof T, Set<StoreListener>>();
+  const debouncedNotifiers = new Map<keyof T, () => void>();
+
+  const get = () => state;
+
+  const set = (next: Partial<T>) => {
+    if (!next) return;
+
+    const updatedKeys: (keyof T)[] = [];
+    for (const key in next) {
+      const typedKey = key as keyof T;
+      const currentValue = state[typedKey];
+      const nextValue = next[typedKey];
+
+      if (currentValue === nextValue) continue;
+
+      if (!Object.is(currentValue, nextValue)) {
+        state[typedKey] = nextValue!;
+        updatedKeys.push(typedKey);
+      }
+    }
 
-    const subscribe = (keys: (keyof T)[], listener: StoreListener): (() => void) => {
-        for (const key of keys) {
-            if (!keyListeners.has(key)) {
-                keyListeners.set(key, new Set());
-            }
-            keyListeners.get(key)!.add(listener);
+    if (updatedKeys.length === 0) return;
+
+    if (asyncUpdate) {
+      for (const key of updatedKeys) {
+        const shouldDebounce = perKeyDebounce[key] !== false;
+        
+        if (shouldDebounce) {
+          if (!debouncedNotifiers.has(key)) {
+            debouncedNotifiers.set(key, debounce(() => {
+              keyListeners.get(key)?.forEach(listener => listener());
+            }, debounceDelay));
+          }
+          debouncedNotifiers.get(key)!();
+        } else {
+          keyListeners.get(key)?.forEach(listener => listener());
         }
+      }
+    } else {
+      for (const key of updatedKeys) {
+        keyListeners.get(key)?.forEach(listener => listener());
+      }
+    }
+  };
+
+  const subscribe = (keys: (keyof T)[], listener: StoreListener): (() => void) => {
+    for (const key of keys) {
+      if (!keyListeners.has(key)) {
+        keyListeners.set(key, new Set());
+      }
+      keyListeners.get(key)!.add(listener);
+    }
 
-        return () => {
-            for (const key of keys) {
-                keyListeners.get(key)?.delete(listener);
-            }
-        };
+    return () => {
+      for (const key of keys) {
+        keyListeners.get(key)?.delete(listener);
+      }
     };
+  };
 
-    const select = <K extends keyof T>(keys: K[]): Pick<T, K> => {
-        const result = {} as Pick<T, K>;
-        const currentState = state;
-        for (const key of keys) {
-            result[key] = currentState[key];
-        }
-        return result;
-    };
+  const select = <K extends keyof T>(keys: K[]): Pick<T, K> => {
+    const result = {} as Pick<T, K>;
+    const currentState = state;
+    for (const key of keys) {
+      result[key] = currentState[key];
+    }
+    return result;
+  };
 
-    return { get, set, subscribe, select };
+  return { get, set, subscribe, select };
 }
 
 type StoreType<T extends object> = ReturnType<typeof createStoreState<T>>;
@@ -85,136 +110,133 @@ type CustomSelector<T extends object> = { [K in keyof T]?: CompareFn<T[K]> };
 type SelectorInput<T extends object> = ReadonlyArray<KeySelector<T> | CustomSelector<T>>;
 
 type ExtractSelectorKeys<T extends object, S extends SelectorInput<T>> = {
-    [K in S[number] extends infer Item
-    ? Item extends keyof T
-    ? Item
-    : keyof Item
-    : never]: T[K];
+  [K in S[number] extends infer Item
+  ? Item extends keyof T
+  ? Item
+  : keyof Item
+  : never]: T[K];
 };
 
 type Picked<T extends object, S extends SelectorInput<T>> = ExtractSelectorKeys<T, S>;
 
 type NormalizedSelector<T extends object> = {
-    key: keyof T;
-    compare?: CompareFn<T[keyof T]>;
+  key: keyof T;
+  compare?: CompareFn<T[keyof T]>;
 };
 
 function shallowEqualSelector<T extends object>(
-    a: SelectorInput<T>,
-    b: SelectorInput<T>
+  a: SelectorInput<T>,
+  b: SelectorInput<T>
 ): boolean {
-    return a.length === b.length && a.every((item, i) => item === b[i]);
+  return a.length === b.length && a.every((item, i) => item === b[i]);
 }
 
 export function useStoreSelector<T extends object, S extends SelectorInput<T>>(
-    store: StoreType<T>,
-    selector: S
+  store: StoreType<T>,
+  selector: S
 ): Picked<T, S> {
-    const lastSelected = useRef<Partial<T>>({});
-    const prevSelector = useRef<SelectorInput<T> | null>(null);
-    const normalizedRef = useRef<NormalizedSelector<T>[] | null>(null);
-    const keysRef = useRef<(keyof T)[] | null>(null);
-    const isFirstRunRef = useRef(true);
-    const lastValues = useRef<Partial<T>>({});
-    const subscribeRef = useRef<((onStoreChange: () => void) => () => void) | null>(null);
-
-    if (!prevSelector.current || !shallowEqualSelector(prevSelector.current, selector)) {
-        const normalized: NormalizedSelector<T>[] = [];
-        const keys: (keyof T)[] = [];
-
-        for (const item of selector) {
-            if (typeof item === 'string') {
-                const key = item as keyof T;
-                normalized.push({ key });
-                keys.push(key);
-            } else {
-                const customSelector = item as CustomSelector<T>;
-                for (const key in customSelector) {
-                    const compare = customSelector[key as keyof typeof customSelector];
-                    const typedKey = key as keyof T;
-                    normalized.push({ key: typedKey, compare: compare as CompareFn<T[keyof T]> });
-                    keys.push(typedKey);
-                }
-            }
+  const lastSelected = useRef<Partial<T>>({});
+  const prevSelector = useRef<SelectorInput<T> | null>(null);
+  const normalizedRef = useRef<NormalizedSelector<T>[] | null>(null);
+  const keysRef = useRef<(keyof T)[] | null>(null);
+  const isFirstRunRef = useRef(true);
+  const lastValues = useRef<Partial<T>>({});
+  const subscribeRef = useRef<((onStoreChange: () => void) => () => void) | null>(null);
+
+  if (!prevSelector.current || !shallowEqualSelector(prevSelector.current, selector)) {
+    const normalized: NormalizedSelector<T>[] = [];
+    const keys: (keyof T)[] = [];
+
+    for (const item of selector) {
+      if (typeof item === 'string') {
+        const key = item as keyof T;
+        normalized.push({ key });
+        keys.push(key);
+      } else {
+        const customSelector = item as CustomSelector<T>;
+        for (const key in customSelector) {
+          const compare = customSelector[key as keyof typeof customSelector];
+          const typedKey = key as keyof T;
+          normalized.push({ key: typedKey, compare: compare as CompareFn<T[keyof T]> });
+          keys.push(typedKey);
         }
+      }
+    }
 
-        normalizedRef.current = normalized;
-        keysRef.current = keys;
-        prevSelector.current = selector;
+    normalizedRef.current = normalized;
+    keysRef.current = keys;
+    prevSelector.current = selector;
+  }
+
+  const normalized = normalizedRef.current!;
+  const keys = keysRef.current!;
+
+  const getSnapshot = () => {
+    const current = store.get();
+    const isFirstRun = isFirstRunRef.current;
+
+    if (isFirstRun) {
+      isFirstRunRef.current = false;
+      const result = {} as Partial<T>;
+      for (const { key } of normalized) {
+        const value = current[key];
+        lastValues.current[key] = value;
+        result[key] = value;
+      }
+      lastSelected.current = result;
+      return result as Picked<T, S>;
     }
 
-    const normalized = normalizedRef.current!;
-    const keys = keysRef.current!;
-
-    const getSnapshot = () => {
-        const current = store.get();
-        const isFirstRun = isFirstRunRef.current;
-
-        if (isFirstRun) {
-            isFirstRunRef.current = false;
-            const result = {} as Partial<T>;
-            for (const { key } of normalized) {
-                const value = current[key];
-                lastValues.current[key] = value;
-                result[key] = value;
-            }
-            lastSelected.current = result;
-            return result as Picked<T, S>;
+    const hasChanges = () => {
+      for (const { key, compare } of normalized) {
+        const prevVal = lastValues.current[key];
+        const nextVal = current[key];
+        if (prevVal === undefined ? true : (compare?.(prevVal, nextVal) ?? !Object.is(prevVal, nextVal))) {
+          return true;
         }
+      }
+      return false;
+    };
 
-        // Check for changes with early return
-        const hasChanges = () => {
-            for (const { key, compare } of normalized) {
-                const prevVal = lastValues.current[key];
-                const nextVal = current[key];
-                if (prevVal === undefined ? true : (compare?.(prevVal, nextVal) ?? !Object.is(prevVal, nextVal))) {
-                    return true;
-                }
-            }
-            return false;
-        };
-
-        if (!hasChanges()) {
-            return lastSelected.current as Picked<T, S>;
-        }
+    if (!hasChanges()) {
+      return lastSelected.current as Picked<T, S>;
+    }
 
-        // Build result only when changes detected
-        const result = {} as Partial<T>;
-        for (const { key, compare } of normalized) {
-            const prevVal = lastValues.current[key];
-            const nextVal = current[key];
-
-            // Hoist the comparison logic
-            const isFirstTime = prevVal === undefined;
-            const changed = isFirstTime || (compare ? !compare(prevVal, nextVal) : !Object.is(prevVal, nextVal));
-
-            if (changed) {
-                lastValues.current[key] = nextVal;
-                result[key] = nextVal;
-            } else {
-                result[key] = prevVal;
-            }
-        }
+    const result = {} as Partial<T>;
+    for (const { key, compare } of normalized) {
+      const prevVal = lastValues.current[key];
+      const nextVal = current[key];
 
-        lastSelected.current = result;
-        return result as Picked<T, S>;
-    };
+      const isFirstTime = prevVal === undefined;
+      const changed = isFirstTime || (compare ? !compare(prevVal, nextVal) : !Object.is(prevVal, nextVal));
 
-    const staticSnapshot = useMemo(() => {
-        const current = store.get();
-        const result = {} as Partial<T>;
-        for (const key of keys) {
-            result[key] = current[key];
-        }
-        return result as Picked<T, S>;
-    }, [keys]);
+      if (changed) {
+        lastValues.current[key] = nextVal;
+        result[key] = nextVal;
+      } else {
+        result[key] = prevVal;
+      }
+    }
 
+    lastSelected.current = result;
+    return result as Picked<T, S>;
+  };
 
-    if (!subscribeRef.current || keysRef.current !== keys) {
-        const currentKeys = keys;
-        subscribeRef.current = (onStoreChange: () => void) =>
-            store.subscribe(currentKeys, onStoreChange);
+  const staticSnapshot = useMemo(() => {
+    const current = store.get();
+    const result = {} as Partial<T>;
+    for (const key of keys) {
+      result[key] = current[key];
     }
+    return result as Picked<T, S>;
+  }, [keys]);
+
+
+  if (!subscribeRef.current || keysRef.current !== keys) {
+    const currentKeys = keys;
+    subscribeRef.current = (onStoreChange: () => void) =>
+      store.subscribe(currentKeys, onStoreChange);
+  }
 
-    return useSyncExternalStore(subscribeRef.current, getSnapshot, () => staticSnapshot);
+  return useSyncExternalStore(subscribeRef.current, getSnapshot, () => staticSnapshot);
 }