@hanzogui/use-store 3.0.6 → 4.4.0

package/dist/cjs/useStore.cjs

@@ -2,33 +2,35 @@ var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf,
-  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, {
-      get: all[name],
-      enumerable: !0
-    });
-  },
-  __copyProps = (to, from, except, desc) => {
-    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
       get: () => from[key],
       enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
     });
-    return to;
-  };
+  }
+  return to;
+};
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-    value: mod,
-    enumerable: !0
-  }) : target, mod)),
-  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-    value: !0
-  }), mod);
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
 var useStore_exports = {};
 __export(useStore_exports, {
   allStores: () => allStores,
@@ -48,12 +50,12 @@ __export(useStore_exports, {
   useStoreSelector: () => useStoreSelector
 });
 module.exports = __toCommonJS(useStore_exports);
-var import_react = __toESM(require("react"), 1),
-  import_comparators = require("./comparators.cjs"),
-  import_configureUseStore = require("./configureUseStore.cjs"),
-  import_constants = require("./constants.cjs"),
-  import_helpers = require("./helpers.cjs"),
-  import_useStoreDebug = require("./useStoreDebug.cjs");
+var import_react = __toESM(require("react"), 1);
+var import_comparators = require("./comparators.cjs");
+var import_configureUseStore = require("./configureUseStore.cjs");
+var import_constants = require("./constants.cjs");
+var import_helpers = require("./helpers.cjs");
+var import_useStoreDebug = require("./useStoreDebug.cjs");
 const idFn = _ => _;
 function useStore(StoreKlass, props, options = import_constants.defaultOptions) {
   const info = getOrCreateStoreInfo(StoreKlass, props, options);
@@ -61,26 +63,30 @@ function useStore(StoreKlass, props, options = import_constants.defaultOptions)
 }
 function useStoreDebug(StoreKlass, props) {
   return useStore(StoreKlass, props, {
-    debug: !0
+    debug: true
   });
 }
 function createStore(StoreKlass, props, options) {
   return getOrCreateStoreInfo(StoreKlass, props, options)?.store;
 }
 function useGlobalStore(instance, debug) {
-  const store = instance[import_constants.UNWRAP_PROXY],
-    uid = (0, import_helpers.getStoreUid)(store.constructor, store.props),
-    info = import_helpers.cache.get(uid);
-  if (!info) throw new Error("This store not created using createStore()");
+  const store = instance[import_constants.UNWRAP_PROXY];
+  const uid = (0, import_helpers.getStoreUid)(store.constructor, store.props);
+  const info = import_helpers.cache.get(uid);
+  if (!info) {
+    throw new Error(`This store not created using createStore()`);
+  }
   return useStoreFromInfo(info, void 0, {
     debug
   });
 }
 function useGlobalStoreSelector(instance, selector, debug) {
-  const store = instance[import_constants.UNWRAP_PROXY],
-    uid = (0, import_helpers.getStoreUid)(store.constructor, store.props),
-    info = import_helpers.cache.get(uid);
-  if (!info) throw new Error("This store not created using createStore()");
+  const store = instance[import_constants.UNWRAP_PROXY];
+  const uid = (0, import_helpers.getStoreUid)(store.constructor, store.props);
+  const info = import_helpers.cache.get(uid);
+  if (!info) {
+    throw new Error(`This store not created using createStore()`);
+  }
   return useStoreFromInfo(info, selector, {
     debug
   });
@@ -89,9 +95,11 @@ function createUseStore(StoreKlass) {
   return (props, options) => useStore(StoreKlass, props, options);
 }
 function createUseStoreSelector(StoreKlass, selector) {
-  return props => useStore(StoreKlass, props, {
-    selector
-  });
+  return props => {
+    return useStore(StoreKlass, props, {
+      selector
+    });
+  };
 }
 function useStoreSelector(StoreKlass, selector, props) {
   return useStore(StoreKlass, props, {
@@ -100,7 +108,8 @@ function useStoreSelector(StoreKlass, selector, props) {
 }
 const storeAccessTrackers = /* @__PURE__ */new Set();
 function trackStoresAccess(cb) {
-  return storeAccessTrackers.add(cb), () => {
+  storeAccessTrackers.add(cb);
+  return () => {
     storeAccessTrackers.delete(cb);
   };
 }
@@ -109,113 +118,155 @@ function getStore(StoreKlass, props) {
 }
 function getOrCreateStore(StoreKlass, props) {
   return getOrCreateStoreInfo(StoreKlass, props, {
-    refuseCreation: !1
+    refuseCreation: false
   })?.store;
 }
 function getStoreInfo(StoreKlass, props) {
   return getOrCreateStoreInfo(StoreKlass, props, {
-    refuseCreation: !0
+    refuseCreation: true
   });
 }
 const onCreateListeners = /* @__PURE__ */new Set();
 function onCreateStore(cb) {
-  return onCreateListeners.add(cb), () => {
+  onCreateListeners.add(cb);
+  return () => {
     onCreateListeners.delete(cb);
   };
 }
 function getOrCreateStoreInfo(StoreKlass, props, options, propsKeyCalculated) {
-  if (!StoreKlass) return null;
+  if (!StoreKlass) {
+    return null;
+  }
   const uid = (0, import_helpers.getStoreUid)(StoreKlass, propsKeyCalculated ?? props);
-  if (!options?.avoidCache && import_helpers.cache.has(uid)) return import_helpers.cache.get(uid);
-  if (options?.refuseCreation) throw new Error(`No store exists (${StoreKlass.name}) with props: ${props}`);
+  if (!options?.avoidCache && import_helpers.cache.has(uid)) {
+    return import_helpers.cache.get(uid);
+  }
+  if (options?.refuseCreation) {
+    throw new Error(`No store exists (${StoreKlass.name}) with props: ${props}`);
+  }
   const storeInstance = new StoreKlass(props);
   storeInstance.props = props;
-  const getters = {},
-    actions = {},
-    stateKeys = /* @__PURE__ */new Set(),
-    descriptors = (0, import_helpers.getStoreDescriptors)(storeInstance);
+  const getters = {};
+  const actions = {};
+  const stateKeys = /* @__PURE__ */new Set();
+  const descriptors = (0, import_helpers.getStoreDescriptors)(storeInstance);
   for (const key in descriptors) {
     const descriptor = descriptors[key];
-    typeof descriptor.value == "function" ? actions[key] = descriptor.value : typeof descriptor.get == "function" ? getters[key] = descriptor.get : key !== "props" && key[0] !== "_" && stateKeys.add(key);
+    if (typeof descriptor.value === "function") {
+      actions[key] = descriptor.value;
+    } else if (typeof descriptor.get === "function") {
+      getters[key] = descriptor.get;
+    } else {
+      if (key !== "props" && key[0] !== "_") {
+        stateKeys.add(key);
+      }
+    }
   }
-  const keyComparators = storeInstance._comparators,
-    listeners = /* @__PURE__ */new Set(),
-    storeInfo = {
-      uid,
-      keyComparators,
-      storeInstance,
-      getters,
-      stateKeys,
-      props,
-      actions,
-      debug: options?.debug,
-      disableTracking: !1,
-      gettersState: {
-        getCache: /* @__PURE__ */new Map(),
-        depsToGetter: /* @__PURE__ */new Map(),
-        curGetKeys: /* @__PURE__ */new Set(),
-        isGetting: !1
-      },
-      listeners,
-      trackers: /* @__PURE__ */new Set(),
-      version: 0,
-      subscribe: onChanged => (listeners.add(onChanged), () => {
+  const keyComparators = storeInstance["_comparators"];
+  const listeners = /* @__PURE__ */new Set();
+  const storeInfo = {
+    uid,
+    keyComparators,
+    storeInstance,
+    getters,
+    stateKeys,
+    props,
+    actions,
+    debug: options?.debug,
+    disableTracking: false,
+    gettersState: {
+      getCache: /* @__PURE__ */new Map(),
+      depsToGetter: /* @__PURE__ */new Map(),
+      curGetKeys: /* @__PURE__ */new Set(),
+      isGetting: false
+    },
+    listeners,
+    trackers: /* @__PURE__ */new Set(),
+    version: 0,
+    subscribe: onChanged => {
+      listeners.add(onChanged);
+      return () => {
         listeners.delete(onChanged);
-      }),
-      triggerUpdate: () => {
-        storeInfo.version = (storeInfo.version + 1) % Number.MAX_SAFE_INTEGER;
-        for (const cb of listeners) cb();
-      }
+      };
     },
-    store = createProxiedStore(
-    // we assign store right after and proxiedStore never accesses it until later on
-    storeInfo);
-  process.env.NODE_ENV === "development" && (allStores[StoreKlass.name + uid] = store), store.mount?.(), storeInfo.store = store;
+    triggerUpdate: () => {
+      storeInfo.version = (storeInfo.version + 1) % Number.MAX_SAFE_INTEGER;
+      for (const cb of listeners) {
+        cb();
+      }
+    }
+  };
+  const store = createProxiedStore(
+  // we assign store right after and proxiedStore never accesses it until later on
+  storeInfo);
+  if (process.env.NODE_ENV === "development") {
+    allStores[StoreKlass.name + uid] = store;
+  }
+  store.mount?.();
+  storeInfo.store = store;
   const result = storeInfo;
-  return import_helpers.cache.set(uid, result), onCreateListeners.forEach(cb => cb(result)), result;
+  import_helpers.cache.set(uid, result);
+  onCreateListeners.forEach(cb => cb(result));
+  return result;
 }
 const allStores = {};
-process.env.NODE_ENV === "development" && (globalThis.Store ||= allStores);
-const emptyObj = {},
-  selectKeys = (obj, keys) => {
-    if (!keys.length) return emptyObj;
-    const res = {};
-    for (const key of keys) res[key] = obj[key];
-    return res;
-  };
-let isInReaction = !1;
+if (process.env.NODE_ENV === "development") {
+  globalThis["Store"] ||= allStores;
+}
+const emptyObj = {};
+const selectKeys = (obj, keys) => {
+  if (!keys.length) {
+    return emptyObj;
+  }
+  const res = {};
+  for (const key of keys) {
+    res[key] = obj[key];
+  }
+  return res;
+};
+let isInReaction = false;
 const setIsInReaction = val => {
   isInReaction = val;
 };
 function useStoreFromInfo(info, userSelector, options) {
-  const store = info?.store,
-    internal = import_react.default.useRef(void 0),
-    component = (0, import_useStoreDebug.useCurrentComponent)();
-  internal.current || (internal.current = {
-    component,
-    tracked: /* @__PURE__ */new Set(),
-    last: null,
-    lastKeys: null
-  });
-  const curInternal = internal.current,
-    shouldPrintDebug = options?.debug,
-    getSnapshot = import_react.default.useCallback(() => {
-      if (!info || !store) return;
-      const curInternal2 = internal.current,
-        isTracking = curInternal2.tracked.size,
-        keys = [...(isTracking ? curInternal2.tracked : info.stateKeys)],
-        nextKeys = `${info.version}${keys.join("")}${userSelector || ""}`,
-        lastKeys = curInternal2.lastKeys;
-      if (nextKeys === curInternal2.lastKeys) return curInternal2.last;
-      curInternal2.lastKeys = nextKeys;
-      let snap;
-      info.disableTracking = !0;
-      const last = curInternal2.last;
-      userSelector ? snap = userSelector(store) : snap = selectKeys(store, keys), info.disableTracking = !1;
-      const isUnchanged = !userSelector && !isTracking && last || typeof last < "u" && (0, import_comparators.isEqualSubsetShallow)(last, snap, {
-        keyComparators: info.keyComparators
-      });
-      return shouldPrintDebug && console.info("\u{1F311} getSnapshot", {
+  const store = info?.store;
+  const internal = import_react.default.useRef(void 0);
+  const component = (0, import_useStoreDebug.useCurrentComponent)();
+  if (!internal.current) {
+    internal.current = {
+      component,
+      tracked: /* @__PURE__ */new Set(),
+      last: null,
+      lastKeys: null
+    };
+  }
+  const curInternal = internal.current;
+  const shouldPrintDebug = options?.debug;
+  const getSnapshot = import_react.default.useCallback(() => {
+    if (!info || !store) return;
+    const curInternal2 = internal.current;
+    const isTracking = curInternal2.tracked.size;
+    const keys = [...(!isTracking ? info.stateKeys : curInternal2.tracked)];
+    const nextKeys = `${info.version}${keys.join("")}${userSelector || ""}`;
+    const lastKeys = curInternal2.lastKeys;
+    if (nextKeys === curInternal2.lastKeys) {
+      return curInternal2.last;
+    }
+    curInternal2.lastKeys = nextKeys;
+    let snap;
+    info.disableTracking = true;
+    const last = curInternal2.last;
+    if (userSelector) {
+      snap = userSelector(store);
+    } else {
+      snap = selectKeys(store, keys);
+    }
+    info.disableTracking = false;
+    const isUnchanged = !userSelector && !isTracking && last || typeof last !== "undefined" && (0, import_comparators.isEqualSubsetShallow)(last, snap, {
+      keyComparators: info.keyComparators
+    });
+    if (shouldPrintDebug) {
+      console.info("\u{1F311} getSnapshot", {
         storeState: selectKeys(store, Object.keys(store)),
         userSelector,
         info,
@@ -227,15 +278,38 @@ function useStoreFromInfo(info, userSelector, options) {
         curInternal: curInternal2,
         nextKeys,
         lastKeys
-      }), isUnchanged ? last : (curInternal2.last = snap, snap);
-    }, [store]),
-    state = import_react.default.useSyncExternalStore(info?.subscribe || idFn, getSnapshot, getSnapshot);
-  return !info || !store || !state || userSelector ? state : new Proxy(store, {
+      });
+    }
+    if (isUnchanged) {
+      return last;
+    }
+    curInternal2.last = snap;
+    return snap;
+  }, [store]);
+  const state = import_react.default.useSyncExternalStore(info?.subscribe || idFn, getSnapshot, getSnapshot);
+  if (!info || !store || !state) {
+    return state;
+  }
+  if (userSelector) {
+    return state;
+  }
+  return new Proxy(store, {
     get(target, key) {
       const curVal = Reflect.get(target, key);
-      if (isInReaction) return curVal;
+      if (isInReaction) {
+        return curVal;
+      }
       const keyString = key;
-      return (info.stateKeys.has(keyString) || keyString in info.getters) && (shouldPrintDebug && console.info("\u{1F440} tracking", keyString), curInternal.tracked.add(keyString)), Reflect.has(state, key) ? Reflect.get(state, key) : curVal;
+      if (info.stateKeys.has(keyString) || keyString in info.getters) {
+        if (shouldPrintDebug) {
+          console.info("\u{1F440} tracking", keyString);
+        }
+        curInternal.tracked.add(keyString);
+      }
+      if (Reflect.has(state, key)) {
+        return Reflect.get(state, key);
+      }
+      return curVal;
     }
   });
 }
@@ -243,31 +317,47 @@ let setters = /* @__PURE__ */new Set();
 const logStack = /* @__PURE__ */new Set();
 function createProxiedStore(storeInfo) {
   const {
-      actions,
-      storeInstance,
-      getters,
-      gettersState
-    } = storeInfo,
-    {
-      getCache,
-      curGetKeys,
-      depsToGetter
-    } = gettersState,
-    constr = storeInstance.constructor,
-    shouldDebug2 = storeInfo.debug ?? import_useStoreDebug.DebugStores.has(constr);
-  let didSet = !1;
+    actions,
+    storeInstance,
+    getters,
+    gettersState
+  } = storeInfo;
+  const {
+    getCache,
+    curGetKeys,
+    depsToGetter
+  } = gettersState;
+  const constr = storeInstance.constructor;
+  const shouldDebug2 = storeInfo.debug ?? import_useStoreDebug.DebugStores.has(constr);
+  let didSet = false;
   const wrappedActions = {};
   for (const key in actions) {
-    if (key === "subscribe") continue;
-    const actionFn = actions[key],
-      isGetFn = key.startsWith("get");
-    if (wrappedActions[key] = function (...args) {
+    if (key === "subscribe") {
+      continue;
+    }
+    const actionFn = actions[key];
+    const isGetFn = key.startsWith("get");
+    wrappedActions[key] = function useStoreAction(...args) {
       let res;
-      return isGetFn || gettersState.isGetting ? Reflect.apply(actionFn, proxiedStore, args) : (process.env.NODE_ENV === "development" && shouldDebug2 && console.info("(debug) startAction", key), res = Reflect.apply(actionFn, proxiedStore, args), res instanceof Promise ? res.then(finishAction) : (finishAction(), res));
-    }, process.env.NODE_ENV === "development") {
+      if (isGetFn || gettersState.isGetting) {
+        return Reflect.apply(actionFn, proxiedStore, args);
+      }
+      if (process.env.NODE_ENV === "development" && shouldDebug2) {
+        console.info("(debug) startAction", key);
+      }
+      res = Reflect.apply(actionFn, proxiedStore, args);
+      if (res instanceof Promise) {
+        return res.then(finishAction);
+      }
+      finishAction();
+      return res;
+    };
+    if (process.env.NODE_ENV === "development") {
       let hashCode = function (str) {
           let hash = 0;
-          for (let i = 0; i < str.length; i++) hash = str.charCodeAt(i) + ((hash << 5) - hash);
+          for (let i = 0; i < str.length; i++) {
+            hash = str.charCodeAt(i) + ((hash << 5) - hash);
+          }
           return hash;
         },
         strColor = function (str) {
@@ -278,29 +368,41 @@ function createProxiedStore(storeInfo) {
         wrappedActions[key] = new Proxy(ogAction, {
           apply(target, thisArg, args) {
             const isDebugging = shouldDebug2 || storeInfo.debug;
-            if (!(process.env.LOG_LEVEL !== "0" && (isDebugging || import_configureUseStore.configureOpts.logLevel !== "error"))) return Reflect.apply(target, thisArg, args);
+            const shouldLog = process.env.LOG_LEVEL !== "0" && (isDebugging || import_configureUseStore.configureOpts.logLevel !== "error");
+            if (!shouldLog) {
+              return Reflect.apply(target, thisArg, args);
+            }
             setters = /* @__PURE__ */new Set();
-            const curSetters = setters,
-              isTopLevelLogger = logStack.size == 0,
-              logs = /* @__PURE__ */new Set();
+            const curSetters = setters;
+            const isTopLevelLogger = logStack.size == 0;
+            const logs = /* @__PURE__ */new Set();
             logStack.add(logs);
             let res;
             const id = counter++;
             try {
               res = Reflect.apply(target, thisArg, args);
             } catch (err) {
-              throw console.error("Error", err), err;
+              console.error("Error", err);
+              throw err;
             } finally {
               logStack.add("end");
-              const name = constr.name,
-                color = strColor(name),
-                simpleArgs = args.map(import_helpers.simpleStr);
-              if (logs.add([`%c \u{1F311} ${id} ${name.padStart(isTopLevelLogger ? 8 : 4)}%c.${key}(${simpleArgs.join(", ")})${isTopLevelLogger && logStack.size > 1 ? ` (+${logStack.size - 1})` : ""}`, `color: ${color};`, "color: black;"]), curSetters.size && curSetters.forEach(({
-                key: key2,
-                value
-              }) => {
-                typeof value == "string" || typeof value == "number" || typeof value == "boolean" ? logs.add([` SET ${key2} ${value}`, value]) : logs.add([` SET ${key2}`, value]);
-              }), isTopLevelLogger) {
+              const name = constr.name;
+              const color = strColor(name);
+              const simpleArgs = args.map(import_helpers.simpleStr);
+              logs.add([`%c \u{1F311} ${id} ${name.padStart(isTopLevelLogger ? 8 : 4)}%c.${key}(${simpleArgs.join(", ")})${isTopLevelLogger && logStack.size > 1 ? ` (+${logStack.size - 1})` : ""}`, `color: ${color};`, "color: black;"]);
+              if (curSetters.size) {
+                curSetters.forEach(({
+                  key: key2,
+                  value
+                }) => {
+                  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+                    logs.add([` SET ${key2} ${value}`, value]);
+                  } else {
+                    logs.add([` SET ${key2}`, value]);
+                  }
+                });
+              }
+              if (isTopLevelLogger) {
                 let error = null;
                 try {
                   for (const item of logStack) {
@@ -310,15 +412,33 @@ function createProxiedStore(storeInfo) {
                     }
                     const [head, ...rest] = item;
                     if (head) {
-                      console.groupCollapsed(...head), console.groupCollapsed("..."), console.info("args", args), console.info("response", res), console.groupCollapsed("trace"), console.trace(), console.groupEnd(), console.groupEnd();
-                      for (const [name2, ...log] of rest) console.groupCollapsed(name2), console.info(...log), console.groupEnd();
-                    } else console.info("Weird log", head, ...rest);
+                      console.groupCollapsed(...head);
+                      console.groupCollapsed("...");
+                      console.info("args", args);
+                      console.info("response", res);
+                      console.groupCollapsed("trace");
+                      console.trace();
+                      console.groupEnd();
+                      console.groupEnd();
+                      for (const [name2, ...log] of rest) {
+                        console.groupCollapsed(name2);
+                        console.info(...log);
+                        console.groupEnd();
+                      }
+                    } else {
+                      console.info("Weird log", head, ...rest);
+                    }
                   }
                 } catch (err) {
                   error = err;
                 }
-                for (const _ of logStack) console.groupEnd();
-                error && console.error("error loggin", error), logStack.clear();
+                for (const _ of logStack) {
+                  console.groupEnd();
+                }
+                if (error) {
+                  console.error(`error loggin`, error);
+                }
+                logStack.clear();
               }
               return res;
             }
@@ -327,64 +447,131 @@ function createProxiedStore(storeInfo) {
       }
     }
   }
-  const finishAction = val => (process.env.NODE_ENV === "development" && shouldDebug2 && console.info("(debug) finishAction", {
-    didSet
-  }), didSet && (storeInfo.triggerUpdate(), didSet = !1), val);
-  let isTriggering = !1;
+  const finishAction = val => {
+    if (process.env.NODE_ENV === "development" && shouldDebug2) {
+      console.info("(debug) finishAction", {
+        didSet
+      });
+    }
+    if (didSet) {
+      storeInfo.triggerUpdate();
+      didSet = false;
+    }
+    return val;
+  };
+  let isTriggering = false;
   const proxiedStore = new Proxy(storeInstance, {
     // GET
     get(_, key) {
-      if (key in wrappedActions) return wrappedActions[key];
-      if (key in passThroughKeys) return Reflect.get(storeInstance, key);
-      if (key === import_constants.UNWRAP_PROXY) return storeInstance;
-      if (key === import_helpers.UNWRAP_STORE_INFO) return storeInfo;
-      if (storeAccessTrackers.size && storeAccessTrackers.forEach(cb => cb(storeInfo)), typeof key != "string") return Reflect.get(storeInstance, key);
-      if (storeInfo.disableTracking || gettersState.isGetting && gettersState.curGetKeys.add(key), key in getters) {
-        if (getCache.has(key)) return getCache.get(key);
+      if (key in wrappedActions) {
+        return wrappedActions[key];
+      }
+      if (key in passThroughKeys) {
+        return Reflect.get(storeInstance, key);
+      }
+      if (key === import_constants.UNWRAP_PROXY) {
+        return storeInstance;
+      }
+      if (key === import_helpers.UNWRAP_STORE_INFO) {
+        return storeInfo;
+      }
+      if (storeAccessTrackers.size) {
+        storeAccessTrackers.forEach(cb => cb(storeInfo));
+      }
+      if (typeof key !== "string") {
+        return Reflect.get(storeInstance, key);
+      }
+      if (!storeInfo.disableTracking) {
+        if (gettersState.isGetting) {
+          gettersState.curGetKeys.add(key);
+        } else {}
+      }
+      if (key in getters) {
+        if (getCache.has(key)) {
+          return getCache.get(key);
+        }
         curGetKeys.clear();
         const isSubGetter = gettersState.isGetting;
-        gettersState.isGetting = !0;
+        gettersState.isGetting = true;
         const res = getters[key].call(proxiedStore);
-        isSubGetter || (gettersState.isGetting = !1);
-        for (const gk of curGetKeys) depsToGetter.has(gk) || depsToGetter.set(gk, /* @__PURE__ */new Set()), depsToGetter.get(gk).add(key);
-        return getCache.set(key, res), res;
+        if (!isSubGetter) {
+          gettersState.isGetting = false;
+        }
+        for (const gk of curGetKeys) {
+          if (!depsToGetter.has(gk)) {
+            depsToGetter.set(gk, /* @__PURE__ */new Set());
+          }
+          const cur = depsToGetter.get(gk);
+          cur.add(key);
+        }
+        getCache.set(key, res);
+        return res;
       }
       return Reflect.get(storeInstance, key);
     },
     // SET
     set(target, key, value, receiver) {
-      const cur = Reflect.get(target, key),
-        res = Reflect.set(target, key, value, receiver);
-      return res && cur !== value && (typeof key == "string" && (clearGetterCache(key), shouldDebug2 && (setters.add({
-        key,
-        value
-      }), getShouldDebug(storeInfo) && console.info("(debug) SET", res, key, value)), process.env.NODE_ENV === "development" && shouldDebug2 && console.info("SET...", {
-        key,
-        value
-      })), isTriggering || (isTriggering = !0, waitForEventLoop(() => {
-        storeInfo.triggerUpdate(), isTriggering = !1;
-      }))), res;
+      const cur = Reflect.get(target, key);
+      const res = Reflect.set(target, key, value, receiver);
+      if (res && cur !== value) {
+        if (typeof key === "string") {
+          clearGetterCache(key);
+          if (shouldDebug2) {
+            setters.add({
+              key,
+              value
+            });
+            if (getShouldDebug(storeInfo)) {
+              console.info("(debug) SET", res, key, value);
+            }
+          }
+          if (process.env.NODE_ENV === "development" && shouldDebug2) {
+            console.info("SET...", {
+              key,
+              value
+            });
+          }
+        }
+        if (!isTriggering) {
+          isTriggering = true;
+          waitForEventLoop(() => {
+            storeInfo.triggerUpdate();
+            isTriggering = false;
+          });
+        }
+      }
+      return res;
     }
   });
   function clearGetterCache(setKey) {
     const parentGetters = depsToGetter.get(setKey);
-    if (getCache.delete(setKey), !!parentGetters) for (const gk of parentGetters) getCache.delete(gk), depsToGetter.has(gk) && clearGetterCache(gk);
+    getCache.delete(setKey);
+    if (!parentGetters) {
+      return;
+    }
+    for (const gk of parentGetters) {
+      getCache.delete(gk);
+      if (depsToGetter.has(gk)) {
+        clearGetterCache(gk);
+      }
+    }
   }
   return proxiedStore;
 }
-const waitForEventLoop = process.env.NODE_ENV === "test" ? cb => cb() : queueMicrotask;
+const waitForEventLoop = process.env.NODE_ENV === "test" || false ? cb => cb() : queueMicrotask;
 let counter = 0;
 const passThroughKeys = {
-  subscribe: !0,
-  _version: !0,
-  _trackers: !0,
-  $$typeof: !0,
-  _listeners: !0,
-  _enableTracking: !0
+  subscribe: true,
+  _version: true,
+  _trackers: true,
+  $$typeof: true,
+  _listeners: true,
+  _enableTracking: true
 };
 function getShouldDebug(storeInfo) {
   const info = {
     storeInstance: storeInfo.store
   };
-  return [...storeInfo.trackers].some(tracker => tracker.component && (0, import_useStoreDebug.shouldDebug)(tracker.component, info));
+  const trackers = storeInfo.trackers;
+  return [...trackers].some(tracker => tracker.component && (0, import_useStoreDebug.shouldDebug)(tracker.component, info));
 }