dev-react-microstore 1.1.2 → 2.0.0

package/dist/index.js

@@ -1 +1 @@
-"use strict";var h=Object.defineProperty;var R=Object.getOwnPropertyDescriptor;var z=Object.getOwnPropertyNames,P=Object.getOwnPropertySymbols;var I=Object.prototype.hasOwnProperty,V=Object.prototype.propertyIsEnumerable;var v=(r,e,t)=>e in r?h(r,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):r[e]=t,j=(r,e)=>{for(var t in e||(e={}))I.call(e,t)&&v(r,t,e[t]);if(P)for(var t of P(e))V.call(e,t)&&v(r,t,e[t]);return r};var C=(r,e)=>{for(var t in e)h(r,t,{get:e[t],enumerable:!0})},F=(r,e,t,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of z(e))!I.call(r,o)&&o!==t&&h(r,o,{get:()=>e[o],enumerable:!(s=R(e,o))||s.enumerable});return r};var O=r=>F(h({},"__esModule",{value:!0}),r);var A={};C(A,{createStoreState:()=>w,useStoreSelector:()=>N});module.exports=O(A);var y=require("react");function w(r){let e=r,t=new Map;return{get:()=>e,set:n=>{var i;if(n==null||typeof n!="object"||Array.isArray(n)){console.error(`set() called with invalid value: ${n===null?"null":n===void 0?"undefined":typeof n}`);return}let u=!1,c=[];for(let S in n)if(Object.prototype.hasOwnProperty.call(n,S)){let d=S;d in e&&!Object.is(e[d],n[d])&&(u=!0,c.push(d))}if(u){e=j(j({},e),n);for(let S of c)(i=t.get(S))==null||i.forEach(d=>d())}},subscribe:(n,u)=>{for(let c of n)t.has(c)||t.set(c,new Set),t.get(c).add(u);return()=>{var c;for(let i of n)(c=t.get(i))==null||c.delete(u)}},select:n=>{let u={},c=e;for(let i of n)u[i]=c[i];return u}}}function E(r,e){return r.length===e.length&&r.every((t,s)=>t===e[s])}function L(r,e,t){let s={};for(let{key:o,compare:p}of t){let T=e[o],n=r[o],u=T===void 0?!0:p?p(T,n):!Object.is(T,n);s[o]=u?n:T}return s}function N(r,e){let t=(0,y.useRef)(r.get()),s=(0,y.useRef)({}),o=(0,y.useRef)(null),p=(0,y.useRef)(null),T=(0,y.useRef)(null),n=(0,y.useRef)(!0);if(!o.current||!E(o.current,e)){let l=[],f=[];for(let a of e)if(typeof a=="string"){let b=a;l.push({key:b}),f.push(b)}else for(let[b,m]of Object.entries(a)){let k=b;l.push({key:k,compare:m}),f.push(k)}p.current=l,T.current=f,o.current=e}let u=p.current,c=T.current,i=()=>{let l=r.get(),f=t.current,a=n.current;return(a||u.some(({key:m,compare:k})=>{var x;let K=f[m],g=l[m];return(x=k==null?void 0:k(K,g))!=null?x:!Object.is(K,g)}))&&(a&&(n.current=!1),t.current=l,s.current=L(l,s.current,u)),s.current},S=(()=>{let l=r.get();return c.reduce((f,a)=>(f[a]=l[a],f),{})})();return(0,y.useSyncExternalStore)(l=>r.subscribe(c,l),i,()=>S)}0&&(module.exports={createStoreState,useStoreSelector});
+"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});

package/dist/index.mjs

@@ -1 +1 @@
-var v=Object.defineProperty;var x=Object.getOwnPropertySymbols;var I=Object.prototype.hasOwnProperty,R=Object.prototype.propertyIsEnumerable;var P=(n,e,t)=>e in n?v(n,e,{enumerable:!0,configurable:!0,writable:!0,value:t}):n[e]=t,h=(n,e)=>{for(var t in e||(e={}))I.call(e,t)&&P(n,t,e[t]);if(x)for(var t of x(e))R.call(e,t)&&P(n,t,e[t]);return n};import{useRef as k,useSyncExternalStore as z}from"react";function w(n){let e=n,t=new Map;return{get:()=>e,set:r=>{var l;if(r==null||typeof r!="object"||Array.isArray(r)){console.error(`set() called with invalid value: ${r===null?"null":r===void 0?"undefined":typeof r}`);return}let c=!1,o=[];for(let p in r)if(Object.prototype.hasOwnProperty.call(r,p)){let f=p;f in e&&!Object.is(e[f],r[f])&&(c=!0,o.push(f))}if(c){e=h(h({},e),r);for(let p of o)(l=t.get(p))==null||l.forEach(f=>f())}},subscribe:(r,c)=>{for(let o of r)t.has(o)||t.set(o,new Set),t.get(o).add(c);return()=>{var o;for(let l of r)(o=t.get(l))==null||o.delete(c)}},select:r=>{let c={},o=e;for(let l of r)c[l]=o[l];return c}}}function V(n,e){return n.length===e.length&&n.every((t,u)=>t===e[u])}function C(n,e,t){let u={};for(let{key:a,compare:d}of t){let y=e[a],r=n[a],c=y===void 0?!0:d?d(y,r):!Object.is(y,r);u[a]=c?r:y}return u}function E(n,e){let t=k(n.get()),u=k({}),a=k(null),d=k(null),y=k(null),r=k(!0);if(!a.current||!V(a.current,e)){let s=[],T=[];for(let i of e)if(typeof i=="string"){let b=i;s.push({key:b}),T.push(b)}else for(let[b,m]of Object.entries(i)){let S=b;s.push({key:S,compare:m}),T.push(S)}d.current=s,y.current=T,a.current=e}let c=d.current,o=y.current,l=()=>{let s=n.get(),T=t.current,i=r.current;return(i||c.some(({key:m,compare:S})=>{var g;let j=T[m],K=s[m];return(g=S==null?void 0:S(j,K))!=null?g:!Object.is(j,K)}))&&(i&&(r.current=!1),t.current=s,u.current=C(s,u.current,c)),u.current},p=(()=>{let s=n.get();return o.reduce((T,i)=>(T[i]=s[i],T),{})})();return z(s=>n.subscribe(o,s),l,()=>p)}export{w as createStoreState,E as useStoreSelector};
+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};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dev-react-microstore",
-  "version": "1.1.2",
+  "version": "2.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

@@ -1,69 +1,79 @@
-import { useRef, useSyncExternalStore } from 'react';
-type StoreListener = () => void;
+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;
+}
 
 export function createStoreState<T extends object>(initialState: T) {
-  let state = initialState;
+    let state = initialState;
 
-  // Map from key to set of subscribers interested in that key
-  const keyListeners = new Map<keyof T, Set<StoreListener>>();
+    const keyListeners = new Map<keyof T, Set<StoreListener>>();
+    const debouncedNotifiers = new Map<keyof T, () => void>();
 
-  const get = () => state;
+    const get = () => state;
 
-  const set = (next: Partial<T>) => {
-    if (next === null || next === undefined || typeof next !== 'object' || Array.isArray(next)) {
-      console.error(`set() called with invalid value: ${next === null ? 'null' : next === undefined ? 'undefined' : typeof next}`);
-      return;
-    }
-    
-    let changed = false;
-    const updatedKeys: (keyof T)[] = [];
-
-    for (const key in next) {
-      if (Object.prototype.hasOwnProperty.call(next, key)) {
-        const typedKey = key as keyof T;
-        if (typedKey in state && !Object.is(state[typedKey], next[typedKey])) {
-          changed = true;
-          updatedKeys.push(typedKey);
+    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 (!changed) return;
+        if (updatedKeys.length === 0) return;
 
-    state = { ...state, ...next };
+        for (const key of updatedKeys) {
+            if (!debouncedNotifiers.has(key)) {
+                debouncedNotifiers.set(key, debounce(() => {
+                    keyListeners.get(key)?.forEach(listener => listener());
+                }, 5));
+            }
+            debouncedNotifiers.get(key)!();
+        }
+    };
 
-    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);
-    }
+    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>>;
@@ -75,115 +85,136 @@ 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
+    [K in S[number] extends infer Item
     ? Item extends keyof T
-      ? Item
-      : keyof Item
+    ? 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]>;
 };
 
-// Helper functions for useStoreSelector
 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]);
-}
-
-function pickKeys<T extends object>(
-  base: T,
-  prev: Partial<T>,
-  selectors: NormalizedSelector<T>[]
-): Partial<T> {
-  const out: Partial<T> = {};
-  for (const { key, compare } of selectors) {
-    const prevVal = prev[key];
-    const nextVal = base[key];
-    const changed = prevVal === undefined ? true : (compare ? compare(prevVal, nextVal) : !Object.is(prevVal, nextVal));
-    out[key] = changed ? nextVal : prevVal;
-  }
-  return out;
+    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 lastState = useRef(store.get());
-  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);
-
-  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 {
-        for (const [key, compare] of Object.entries(item)) {
-          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;
-  }
 
-  const normalized = normalizedRef.current!;
-  const keys = keysRef.current!;
+        normalizedRef.current = normalized;
+        keysRef.current = keys;
+        prevSelector.current = selector;
+    }
 
-  const getSnapshot = () => {
-    const current = store.get();
-    const prev = lastState.current;
+    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 isFirstRun = isFirstRunRef.current;
+        // 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>;
+        }
 
-    const changed = isFirstRun || normalized.some(({ key, compare }) => {
-      const prevVal = prev[key];
-      const nextVal = current[key];
-      return compare?.(prevVal, nextVal) ?? !Object.is(prevVal, nextVal);
-    });
+        // 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;
+            }
+        }
 
-    if (!changed) {
-      return lastSelected.current as Picked<T, S>;
-    }
-    
-    if (isFirstRun) {
-      isFirstRunRef.current = false;
-    }
+        lastSelected.current = result;
+        return result as Picked<T, S>;
+    };
 
-    lastState.current = current;
-    lastSelected.current = pickKeys(current, lastSelected.current, normalized);
-    return lastSelected.current as Picked<T, S>;
-  };
+    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]);
 
-  const staticSnapshot = (() => {
-    const current = store.get();
-    return keys.reduce((acc, key) => {
-      acc[key] = current[key];
-      return acc;
-    }, {} as Partial<T>) as Picked<T, S>;
-  })();
 
-  const subscribe = (onStoreChange: () => void) =>
-    store.subscribe(keys, onStoreChange);
+    if (!subscribeRef.current || keysRef.current !== keys) {
+        const currentKeys = keys;
+        subscribeRef.current = (onStoreChange: () => void) =>
+            store.subscribe(currentKeys, onStoreChange);
+    }
 
-  return useSyncExternalStore(subscribe, getSnapshot, () => staticSnapshot);
+    return useSyncExternalStore(subscribeRef.current, getSnapshot, () => staticSnapshot);
 }