@hanzogui/use-store 3.0.6 → 4.3.1

package/dist/esm/useStore.native.js

@@ -5,19 +5,23 @@ import { UNWRAP_PROXY, defaultOptions } from "./constants.native.js";
 import { UNWRAP_STORE_INFO, cache, getStoreDescriptors, getStoreUid, simpleStr } from "./helpers.native.js";
 import { DebugStores, shouldDebug, useCurrentComponent } from "./useStoreDebug.native.js";
 function _instanceof(left, right) {
-  return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
+  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+    return !!right[Symbol.hasInstance](left);
+  } else {
+    return left instanceof right;
+  }
 }
 var idFn = function (_) {
   return _;
 };
 function useStore(StoreKlass, props) {
-  var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : defaultOptions,
-    info = getOrCreateStoreInfo(StoreKlass, props, options);
+  var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : defaultOptions;
+  var info = getOrCreateStoreInfo(StoreKlass, props, options);
   return useStoreFromInfo(info, options.selector, options);
 }
 function useStoreDebug(StoreKlass, props) {
   return useStore(StoreKlass, props, {
-    debug: !0
+    debug: true
   });
 }
 function createStore(StoreKlass, props, options) {
@@ -25,19 +29,23 @@ function createStore(StoreKlass, props, options) {
   return (_getOrCreateStoreInfo = getOrCreateStoreInfo(StoreKlass, props, options)) === null || _getOrCreateStoreInfo === void 0 ? void 0 : _getOrCreateStoreInfo.store;
 }
 function useGlobalStore(instance, debug) {
-  var store = instance[UNWRAP_PROXY],
-    uid = getStoreUid(store.constructor, store.props),
-    info = cache.get(uid);
-  if (!info) throw new Error("This store not created using createStore()");
+  var store = instance[UNWRAP_PROXY];
+  var uid = getStoreUid(store.constructor, store.props);
+  var info = 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) {
-  var store = instance[UNWRAP_PROXY],
-    uid = getStoreUid(store.constructor, store.props),
-    info = cache.get(uid);
-  if (!info) throw new Error("This store not created using createStore()");
+  var store = instance[UNWRAP_PROXY];
+  var uid = getStoreUid(store.constructor, store.props);
+  var info = cache.get(uid);
+  if (!info) {
+    throw new Error(`This store not created using createStore()`);
+  }
   return useStoreFromInfo(info, selector, {
     debug
   });
@@ -61,7 +69,8 @@ function useStoreSelector(StoreKlass, selector, props) {
 }
 var storeAccessTrackers = /* @__PURE__ */new Set();
 function trackStoresAccess(cb) {
-  return storeAccessTrackers.add(cb), function () {
+  storeAccessTrackers.add(cb);
+  return function () {
     storeAccessTrackers.delete(cb);
   };
 }
@@ -72,419 +81,610 @@ function getStore(StoreKlass, props) {
 function getOrCreateStore(StoreKlass, props) {
   var _getOrCreateStoreInfo;
   return (_getOrCreateStoreInfo = getOrCreateStoreInfo(StoreKlass, props, {
-    refuseCreation: !1
+    refuseCreation: false
   })) === null || _getOrCreateStoreInfo === void 0 ? void 0 : _getOrCreateStoreInfo.store;
 }
 function getStoreInfo(StoreKlass, props) {
   return getOrCreateStoreInfo(StoreKlass, props, {
-    refuseCreation: !0
+    refuseCreation: true
   });
 }
 var onCreateListeners = /* @__PURE__ */new Set();
 function onCreateStore(cb) {
-  return onCreateListeners.add(cb), function () {
+  onCreateListeners.add(cb);
+  return function () {
     onCreateListeners.delete(cb);
   };
 }
 function getOrCreateStoreInfo(StoreKlass, props, options, propsKeyCalculated) {
   var _store_mount;
-  if (!StoreKlass) return null;
-  var uid = getStoreUid(StoreKlass, propsKeyCalculated ?? props);
-  if (!options?.avoidCache && cache.has(uid)) return cache.get(uid);
-  if (options?.refuseCreation) throw new Error(`No store exists (${StoreKlass.name}) with props: ${props}`);
+  if (!StoreKlass) {
+    return null;
+  }
+  var uid = getStoreUid(StoreKlass, propsKeyCalculated !== null && propsKeyCalculated !== void 0 ? propsKeyCalculated : props);
+  if (!(options === null || options === void 0 ? void 0 : options.avoidCache) && cache.has(uid)) {
+    return cache.get(uid);
+  }
+  if (options === null || options === void 0 ? void 0 : options.refuseCreation) {
+    throw new Error(`No store exists (${StoreKlass.name}) with props: ${props}`);
+  }
   var storeInstance = new StoreKlass(props);
   storeInstance.props = props;
-  var getters = {},
-    actions = {},
-    stateKeys = /* @__PURE__ */new Set(),
-    descriptors = getStoreDescriptors(storeInstance);
+  var getters = {};
+  var actions = {};
+  var stateKeys = /* @__PURE__ */new Set();
+  var descriptors = getStoreDescriptors(storeInstance);
   for (var key in descriptors) {
     var 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);
+      }
+    }
   }
-  var 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: function (onChanged) {
-        return listeners.add(onChanged), function () {
-          listeners.delete(onChanged);
-        };
-      },
-      triggerUpdate: function () {
-        storeInfo.version = (storeInfo.version + 1) % Number.MAX_SAFE_INTEGER;
-        var _iteratorNormalCompletion = !0,
-          _didIteratorError = !1,
-          _iteratorError = void 0;
+  var keyComparators = storeInstance["_comparators"];
+  var listeners = /* @__PURE__ */new Set();
+  var storeInfo = {
+    uid,
+    keyComparators,
+    storeInstance,
+    getters,
+    stateKeys,
+    props,
+    actions,
+    debug: options === null || options === void 0 ? void 0 : 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: function (onChanged) {
+      listeners.add(onChanged);
+      return function () {
+        listeners.delete(onChanged);
+      };
+    },
+    triggerUpdate: function () {
+      storeInfo.version = (storeInfo.version + 1) % Number.MAX_SAFE_INTEGER;
+      var _iteratorNormalCompletion = true,
+        _didIteratorError = false,
+        _iteratorError = void 0;
+      try {
+        for (var _iterator = listeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          var cb = _step.value;
+          cb();
+        }
+      } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+      } finally {
         try {
-          for (var _iterator = listeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
-            var cb = _step.value;
-            cb();
+          if (!_iteratorNormalCompletion && _iterator.return != null) {
+            _iterator.return();
           }
-        } catch (err) {
-          _didIteratorError = !0, _iteratorError = err;
         } finally {
-          try {
-            !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
-          } finally {
-            if (_didIteratorError) throw _iteratorError;
+          if (_didIteratorError) {
+            throw _iteratorError;
           }
         }
       }
-    },
-    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 = store.mount) === null || _store_mount === void 0 || _store_mount.call(store), storeInfo.store = store;
+    }
+  };
+  var 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 = store.mount) === null || _store_mount === void 0 ? void 0 : _store_mount.call(store);
+  storeInfo.store = store;
   var result = storeInfo;
-  return cache.set(uid, result), onCreateListeners.forEach(function (cb) {
+  cache.set(uid, result);
+  onCreateListeners.forEach(function (cb) {
     return cb(result);
-  }), result;
+  });
+  return result;
 }
 var allStores = {};
 if (process.env.NODE_ENV === "development") {
   var _globalThis, _Store;
   (_globalThis = globalThis)[_Store = "Store"] || (_globalThis[_Store] = allStores);
 }
-var emptyObj = {},
-  selectKeys = function (obj, keys) {
-    if (!keys.length) return emptyObj;
-    var res = {},
-      _iteratorNormalCompletion = !0,
-      _didIteratorError = !1,
-      _iteratorError = void 0;
+var emptyObj = {};
+var selectKeys = function (obj, keys) {
+  if (!keys.length) {
+    return emptyObj;
+  }
+  var res = {};
+  var _iteratorNormalCompletion = true,
+    _didIteratorError = false,
+    _iteratorError = void 0;
+  try {
+    for (var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var key = _step.value;
+      res[key] = obj[key];
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
     try {
-      for (var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
-        var key = _step.value;
-        res[key] = obj[key];
+      if (!_iteratorNormalCompletion && _iterator.return != null) {
+        _iterator.return();
       }
-    } catch (err) {
-      _didIteratorError = !0, _iteratorError = err;
     } finally {
-      try {
-        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
-      } finally {
-        if (_didIteratorError) throw _iteratorError;
+      if (_didIteratorError) {
+        throw _iteratorError;
       }
     }
-    return res;
-  },
-  isInReaction = !1,
-  setIsInReaction = function (val) {
-    isInReaction = val;
-  };
+  }
+  return res;
+};
+var isInReaction = false;
+var setIsInReaction = function (val) {
+  isInReaction = val;
+};
 function useStoreFromInfo(info, userSelector, options) {
-  var store = info?.store,
-    internal = React.useRef(void 0),
-    component = useCurrentComponent();
-  internal.current || (internal.current = {
-    component,
-    tracked: /* @__PURE__ */new Set(),
-    last: null,
-    lastKeys: null
-  });
-  var curInternal = internal.current,
-    shouldPrintDebug = options?.debug,
-    getSnapshot = React.useCallback(function () {
-      if (!(!info || !store)) {
-        var 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;
-        var snap;
-        info.disableTracking = !0;
-        var last = curInternal2.last;
-        userSelector ? snap = userSelector(store) : snap = selectKeys(store, keys), info.disableTracking = !1;
-        var isUnchanged = !userSelector && !isTracking && last || typeof last < "u" && isEqualSubsetShallow(last, snap, {
-          keyComparators: info.keyComparators
-        });
-        return shouldPrintDebug && console.info("\u{1F311} getSnapshot", {
-          storeState: selectKeys(store, Object.keys(store)),
-          userSelector,
-          info,
-          isUnchanged,
-          component,
-          keys,
-          last,
-          snap,
-          curInternal: curInternal2,
-          nextKeys,
-          lastKeys
-        }), isUnchanged ? last : (curInternal2.last = snap, snap);
-      }
-    }, [store]),
-    state = React.useSyncExternalStore(info?.subscribe || idFn, getSnapshot, getSnapshot);
-  return !info || !store || !state || userSelector ? state : new Proxy(store, {
+  var store = info === null || info === void 0 ? void 0 : info.store;
+  var internal = React.useRef(void 0);
+  var component = useCurrentComponent();
+  if (!internal.current) {
+    internal.current = {
+      component,
+      tracked: /* @__PURE__ */new Set(),
+      last: null,
+      lastKeys: null
+    };
+  }
+  var curInternal = internal.current;
+  var shouldPrintDebug = options === null || options === void 0 ? void 0 : options.debug;
+  var getSnapshot = React.useCallback(function () {
+    if (!info || !store) return;
+    var curInternal2 = internal.current;
+    var isTracking = curInternal2.tracked.size;
+    var keys = [...(!isTracking ? info.stateKeys : curInternal2.tracked)];
+    var nextKeys = `${info.version}${keys.join("")}${userSelector || ""}`;
+    var lastKeys = curInternal2.lastKeys;
+    if (nextKeys === curInternal2.lastKeys) {
+      return curInternal2.last;
+    }
+    curInternal2.lastKeys = nextKeys;
+    var snap;
+    info.disableTracking = true;
+    var last = curInternal2.last;
+    if (userSelector) {
+      snap = userSelector(store);
+    } else {
+      snap = selectKeys(store, keys);
+    }
+    info.disableTracking = false;
+    var isUnchanged = !userSelector && !isTracking && last || typeof last !== "undefined" && isEqualSubsetShallow(last, snap, {
+      keyComparators: info.keyComparators
+    });
+    if (shouldPrintDebug) {
+      console.info("\u{1F311} getSnapshot", {
+        storeState: selectKeys(store, Object.keys(store)),
+        userSelector,
+        info,
+        isUnchanged,
+        component,
+        keys,
+        last,
+        snap,
+        curInternal: curInternal2,
+        nextKeys,
+        lastKeys
+      });
+    }
+    if (isUnchanged) {
+      return last;
+    }
+    curInternal2.last = snap;
+    return snap;
+  }, [store]);
+  var state = React.useSyncExternalStore((info === null || info === void 0 ? void 0 : info.subscribe) || idFn, getSnapshot, getSnapshot);
+  if (!info || !store || !state) {
+    return state;
+  }
+  if (userSelector) {
+    return state;
+  }
+  return new Proxy(store, {
     get(target, key) {
       var curVal = Reflect.get(target, key);
-      if (isInReaction) return curVal;
+      if (isInReaction) {
+        return curVal;
+      }
       var 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;
     }
   });
 }
-var setters = /* @__PURE__ */new Set(),
-  logStack = /* @__PURE__ */new Set();
+var setters = /* @__PURE__ */new Set();
+var logStack = /* @__PURE__ */new Set();
 function createProxiedStore(storeInfo) {
   var _loop = function (key2) {
-      if (key2 === "subscribe") return "continue";
-      var actionFn = actions[key2],
-        isGetFn = key2.startsWith("get");
-      if (wrappedActions[key2] = function () {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
-        var res;
-        return isGetFn || gettersState.isGetting ? Reflect.apply(actionFn, proxiedStore, args) : (process.env.NODE_ENV === "development" && shouldDebug2 && console.info("(debug) startAction", key2), res = Reflect.apply(actionFn, proxiedStore, args), _instanceof(res, Promise) ? res.then(finishAction) : (finishAction(), res));
-      }, process.env.NODE_ENV === "development") {
-        let hashCode2 = function (str) {
-            for (var hash = 0, i = 0; i < str.length; i++) hash = str.charCodeAt(i) + ((hash << 5) - hash);
-            return hash;
-          },
-          strColor2 = function (str) {
-            return `hsl(${hashCode2(str) % 360}, 90%, 40%)`;
-          };
-        var hashCode = hashCode2,
-          strColor = strColor2;
-        if (!key2.startsWith("get") && !key2.startsWith("_") && key2 !== "subscribe") {
-          var ogAction = wrappedActions[key2];
-          wrappedActions[key2] = new Proxy(ogAction, {
-            apply(target, thisArg, args) {
-              var isDebugging = shouldDebug2 || storeInfo.debug,
-                shouldLog = process.env.LOG_LEVEL !== "0" && (isDebugging || configureOpts.logLevel !== "error");
-              if (!shouldLog) return Reflect.apply(target, thisArg, args);
-              setters = /* @__PURE__ */new Set();
-              var curSetters = setters,
-                isTopLevelLogger = logStack.size == 0,
-                logs = /* @__PURE__ */new Set();
-              logStack.add(logs);
-              var res,
-                id = counter++;
-              try {
-                res = Reflect.apply(target, thisArg, args);
-              } catch (err) {
-                throw console.error("Error", err), err;
-              } finally {
-                logStack.add("end");
-                var name = constr.name,
-                  color = strColor2(name),
-                  simpleArgs = args.map(simpleStr);
-                if (logs.add([`%c \u{1F311} ${id} ${name.padStart(isTopLevelLogger ? 8 : 4)}%c.${key2}(${simpleArgs.join(", ")})${isTopLevelLogger && logStack.size > 1 ? ` (+${logStack.size - 1})` : ""}`, `color: ${color};`, "color: black;"]), curSetters.size && curSetters.forEach(function (param) {
+    if (key2 === "subscribe") {
+      return "continue";
+    }
+    var actionFn = actions[key2];
+    var isGetFn = key2.startsWith("get");
+    wrappedActions[key2] = function useStoreAction() {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      var res;
+      if (isGetFn || gettersState.isGetting) {
+        return Reflect.apply(actionFn, proxiedStore, args);
+      }
+      if (process.env.NODE_ENV === "development" && shouldDebug2) {
+        console.info("(debug) startAction", key2);
+      }
+      res = Reflect.apply(actionFn, proxiedStore, args);
+      if (_instanceof(res, Promise)) {
+        return res.then(finishAction);
+      }
+      finishAction();
+      return res;
+    };
+    if (process.env.NODE_ENV === "development") {
+      let hashCode2 = function (str) {
+          var hash = 0;
+          for (var i = 0; i < str.length; i++) {
+            hash = str.charCodeAt(i) + ((hash << 5) - hash);
+          }
+          return hash;
+        },
+        strColor2 = function (str) {
+          return `hsl(${hashCode2(str) % 360}, 90%, 40%)`;
+        };
+      var hashCode = hashCode2,
+        strColor = strColor2;
+      if (!key2.startsWith("get") && !key2.startsWith("_") && key2 !== "subscribe") {
+        var ogAction = wrappedActions[key2];
+        wrappedActions[key2] = new Proxy(ogAction, {
+          apply(target, thisArg, args) {
+            var isDebugging = shouldDebug2 || storeInfo.debug;
+            var shouldLog = process.env.LOG_LEVEL !== "0" && (isDebugging || configureOpts.logLevel !== "error");
+            if (!shouldLog) {
+              return Reflect.apply(target, thisArg, args);
+            }
+            setters = /* @__PURE__ */new Set();
+            var curSetters = setters;
+            var isTopLevelLogger = logStack.size == 0;
+            var logs = /* @__PURE__ */new Set();
+            logStack.add(logs);
+            var res;
+            var id = counter++;
+            try {
+              res = Reflect.apply(target, thisArg, args);
+            } catch (err) {
+              console.error("Error", err);
+              throw err;
+            } finally {
+              logStack.add("end");
+              var name = constr.name;
+              var color = strColor2(name);
+              var simpleArgs = args.map(simpleStr);
+              logs.add([`%c \u{1F311} ${id} ${name.padStart(isTopLevelLogger ? 8 : 4)}%c.${key2}(${simpleArgs.join(", ")})${isTopLevelLogger && logStack.size > 1 ? ` (+${logStack.size - 1})` : ""}`, `color: ${color};`, "color: black;"]);
+              if (curSetters.size) {
+                curSetters.forEach(function (param) {
                   var {
                     key: key3,
                     value
                   } = param;
-                  typeof value == "string" || typeof value == "number" || typeof value == "boolean" ? logs.add([` SET ${key3} ${value}`, value]) : logs.add([` SET ${key3}`, value]);
-                }), isTopLevelLogger) {
-                  var error = null;
+                  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+                    logs.add([` SET ${key3} ${value}`, value]);
+                  } else {
+                    logs.add([` SET ${key3}`, value]);
+                  }
+                });
+              }
+              if (isTopLevelLogger) {
+                var error = null;
+                try {
+                  var _iteratorNormalCompletion = true,
+                    _didIteratorError = false,
+                    _iteratorError = void 0;
                   try {
-                    var _iteratorNormalCompletion = !0,
-                      _didIteratorError = !1,
-                      _iteratorError = void 0;
-                    try {
-                      for (var _iterator = logStack[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
-                        var item = _step.value;
-                        if (item === "end") {
-                          console.groupEnd();
-                          continue;
-                        }
-                        var [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();
-                          var _iteratorNormalCompletion1 = !0,
-                            _didIteratorError1 = !1,
-                            _iteratorError1 = void 0;
+                    for (var _iterator = logStack[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                      var item = _step.value;
+                      if (item === "end") {
+                        console.groupEnd();
+                        continue;
+                      }
+                      var [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();
+                        var _iteratorNormalCompletion1 = true,
+                          _didIteratorError1 = false,
+                          _iteratorError1 = void 0;
+                        try {
+                          for (var _iterator1 = rest[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+                            var [name1, ...log] = _step1.value;
+                            console.groupCollapsed(name1);
+                            console.info(...log);
+                            console.groupEnd();
+                          }
+                        } catch (err) {
+                          _didIteratorError1 = true;
+                          _iteratorError1 = err;
+                        } finally {
                           try {
-                            for (var _iterator1 = rest[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
-                              var [name1, ...log] = _step1.value;
-                              console.groupCollapsed(name1), console.info(...log), console.groupEnd();
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                              _iterator1.return();
                             }
-                          } catch (err) {
-                            _didIteratorError1 = !0, _iteratorError1 = err;
                           } finally {
-                            try {
-                              !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
-                            } finally {
-                              if (_didIteratorError1) throw _iteratorError1;
+                            if (_didIteratorError1) {
+                              throw _iteratorError1;
                             }
                           }
-                        } else console.info("Weird log", head, ...rest);
+                        }
+                      } else {
+                        console.info("Weird log", head, ...rest);
+                      }
+                    }
+                  } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                  } finally {
+                    try {
+                      if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
                       }
-                    } catch (err) {
-                      _didIteratorError = !0, _iteratorError = err;
                     } finally {
-                      try {
-                        !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
-                      } finally {
-                        if (_didIteratorError) throw _iteratorError;
+                      if (_didIteratorError) {
+                        throw _iteratorError;
                       }
                     }
-                  } catch (err) {
-                    error = err;
                   }
-                  var _iteratorNormalCompletion2 = !0,
-                    _didIteratorError2 = !1,
-                    _iteratorError2 = void 0;
+                } catch (err) {
+                  error = err;
+                }
+                var _iteratorNormalCompletion2 = true,
+                  _didIteratorError2 = false,
+                  _iteratorError2 = void 0;
+                try {
+                  for (var _iterator2 = logStack[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                    var _ = _step2.value;
+                    console.groupEnd();
+                  }
+                } catch (err) {
+                  _didIteratorError2 = true;
+                  _iteratorError2 = err;
+                } finally {
                   try {
-                    for (var _iterator2 = logStack[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = !0) {
-                      var _ = _step2.value;
-                      console.groupEnd();
+                    if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                      _iterator2.return();
                     }
-                  } catch (err) {
-                    _didIteratorError2 = !0, _iteratorError2 = err;
                   } finally {
-                    try {
-                      !_iteratorNormalCompletion2 && _iterator2.return != null && _iterator2.return();
-                    } finally {
-                      if (_didIteratorError2) throw _iteratorError2;
+                    if (_didIteratorError2) {
+                      throw _iteratorError2;
                     }
                   }
-                  error && console.error("error loggin", error), logStack.clear();
                 }
-                return res;
+                if (error) {
+                  console.error(`error loggin`, error);
+                }
+                logStack.clear();
               }
+              return res;
             }
-          });
-        }
+          }
+        });
       }
-    },
-    {
-      actions,
-      storeInstance,
-      getters,
-      gettersState
-    } = storeInfo,
-    {
-      getCache,
-      curGetKeys,
-      depsToGetter
-    } = gettersState,
-    constr = storeInstance.constructor,
-    _storeInfo_debug,
-    shouldDebug2 = (_storeInfo_debug = storeInfo.debug) !== null && _storeInfo_debug !== void 0 ? _storeInfo_debug : DebugStores.has(constr),
-    didSet = !1,
-    wrappedActions = {};
+    }
+  };
+  var {
+    actions,
+    storeInstance,
+    getters,
+    gettersState
+  } = storeInfo;
+  var {
+    getCache,
+    curGetKeys,
+    depsToGetter
+  } = gettersState;
+  var constr = storeInstance.constructor;
+  var _storeInfo_debug;
+  var shouldDebug2 = (_storeInfo_debug = storeInfo.debug) !== null && _storeInfo_debug !== void 0 ? _storeInfo_debug : DebugStores.has(constr);
+  var didSet = false;
+  var wrappedActions = {};
   for (var key in actions) _loop(key);
   var finishAction = function (val) {
-      return process.env.NODE_ENV === "development" && shouldDebug2 && console.info("(debug) finishAction", {
+    if (process.env.NODE_ENV === "development" && shouldDebug2) {
+      console.info("(debug) finishAction", {
         didSet
-      }), didSet && (storeInfo.triggerUpdate(), didSet = !1), val;
-    },
-    isTriggering = !1,
-    proxiedStore = new Proxy(storeInstance, {
-      // GET
-      get(_, key2) {
-        if (key2 in wrappedActions) return wrappedActions[key2];
-        if (key2 in passThroughKeys) return Reflect.get(storeInstance, key2);
-        if (key2 === UNWRAP_PROXY) return storeInstance;
-        if (key2 === UNWRAP_STORE_INFO) return storeInfo;
-        if (storeAccessTrackers.size && storeAccessTrackers.forEach(function (cb) {
+      });
+    }
+    if (didSet) {
+      storeInfo.triggerUpdate();
+      didSet = false;
+    }
+    return val;
+  };
+  var isTriggering = false;
+  var proxiedStore = new Proxy(storeInstance, {
+    // GET
+    get(_, key2) {
+      if (key2 in wrappedActions) {
+        return wrappedActions[key2];
+      }
+      if (key2 in passThroughKeys) {
+        return Reflect.get(storeInstance, key2);
+      }
+      if (key2 === UNWRAP_PROXY) {
+        return storeInstance;
+      }
+      if (key2 === UNWRAP_STORE_INFO) {
+        return storeInfo;
+      }
+      if (storeAccessTrackers.size) {
+        storeAccessTrackers.forEach(function (cb) {
           return cb(storeInfo);
-        }), typeof key2 != "string") return Reflect.get(storeInstance, key2);
-        if (storeInfo.disableTracking || gettersState.isGetting && gettersState.curGetKeys.add(key2), key2 in getters) {
-          if (getCache.has(key2)) return getCache.get(key2);
-          curGetKeys.clear();
-          var isSubGetter = gettersState.isGetting;
-          gettersState.isGetting = !0;
-          var res = getters[key2].call(proxiedStore);
-          isSubGetter || (gettersState.isGetting = !1);
-          var _iteratorNormalCompletion = !0,
-            _didIteratorError = !1,
-            _iteratorError = void 0;
+        });
+      }
+      if (typeof key2 !== "string") {
+        return Reflect.get(storeInstance, key2);
+      }
+      if (!storeInfo.disableTracking) {
+        if (gettersState.isGetting) {
+          gettersState.curGetKeys.add(key2);
+        } else {}
+      }
+      if (key2 in getters) {
+        if (getCache.has(key2)) {
+          return getCache.get(key2);
+        }
+        curGetKeys.clear();
+        var isSubGetter = gettersState.isGetting;
+        gettersState.isGetting = true;
+        var res = getters[key2].call(proxiedStore);
+        if (!isSubGetter) {
+          gettersState.isGetting = false;
+        }
+        var _iteratorNormalCompletion = true,
+          _didIteratorError = false,
+          _iteratorError = void 0;
+        try {
+          for (var _iterator = curGetKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var gk = _step.value;
+            if (!depsToGetter.has(gk)) {
+              depsToGetter.set(gk, /* @__PURE__ */new Set());
+            }
+            var cur = depsToGetter.get(gk);
+            cur.add(key2);
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
           try {
-            for (var _iterator = curGetKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
-              var gk = _step.value;
-              depsToGetter.has(gk) || depsToGetter.set(gk, /* @__PURE__ */new Set());
-              var cur = depsToGetter.get(gk);
-              cur.add(key2);
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
             }
-          } catch (err) {
-            _didIteratorError = !0, _iteratorError = err;
           } finally {
-            try {
-              !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
-            } finally {
-              if (_didIteratorError) throw _iteratorError;
+            if (_didIteratorError) {
+              throw _iteratorError;
             }
           }
-          return getCache.set(key2, res), res;
         }
-        return Reflect.get(storeInstance, key2);
-      },
-      // SET
-      set(target, key2, value, receiver) {
-        var cur = Reflect.get(target, key2),
-          res = Reflect.set(target, key2, value, receiver);
-        return res && cur !== value && (typeof key2 == "string" && (clearGetterCache(key2), shouldDebug2 && (setters.add({
-          key: key2,
-          value
-        }), getShouldDebug(storeInfo) && console.info("(debug) SET", res, key2, value)), process.env.NODE_ENV === "development" && shouldDebug2 && console.info("SET...", {
-          key: key2,
-          value
-        })), isTriggering || (isTriggering = !0, waitForEventLoop(function () {
-          storeInfo.triggerUpdate(), isTriggering = !1;
-        }))), res;
+        getCache.set(key2, res);
+        return res;
       }
-    });
+      return Reflect.get(storeInstance, key2);
+    },
+    // SET
+    set(target, key2, value, receiver) {
+      var cur = Reflect.get(target, key2);
+      var res = Reflect.set(target, key2, value, receiver);
+      if (res && cur !== value) {
+        if (typeof key2 === "string") {
+          clearGetterCache(key2);
+          if (shouldDebug2) {
+            setters.add({
+              key: key2,
+              value
+            });
+            if (getShouldDebug(storeInfo)) {
+              console.info("(debug) SET", res, key2, value);
+            }
+          }
+          if (process.env.NODE_ENV === "development" && shouldDebug2) {
+            console.info("SET...", {
+              key: key2,
+              value
+            });
+          }
+        }
+        if (!isTriggering) {
+          isTriggering = true;
+          waitForEventLoop(function () {
+            storeInfo.triggerUpdate();
+            isTriggering = false;
+          });
+        }
+      }
+      return res;
+    }
+  });
   function clearGetterCache(setKey) {
     var parentGetters = depsToGetter.get(setKey);
-    if (getCache.delete(setKey), !!parentGetters) {
-      var _iteratorNormalCompletion = !0,
-        _didIteratorError = !1,
-        _iteratorError = void 0;
+    getCache.delete(setKey);
+    if (!parentGetters) {
+      return;
+    }
+    var _iteratorNormalCompletion = true,
+      _didIteratorError = false,
+      _iteratorError = void 0;
+    try {
+      for (var _iterator = parentGetters[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var gk = _step.value;
+        getCache.delete(gk);
+        if (depsToGetter.has(gk)) {
+          clearGetterCache(gk);
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
       try {
-        for (var _iterator = parentGetters[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
-          var gk = _step.value;
-          getCache.delete(gk), depsToGetter.has(gk) && clearGetterCache(gk);
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
         }
-      } catch (err) {
-        _didIteratorError = !0, _iteratorError = err;
       } finally {
-        try {
-          !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
-        } finally {
-          if (_didIteratorError) throw _iteratorError;
+        if (_didIteratorError) {
+          throw _iteratorError;
         }
       }
     }
   }
   return proxiedStore;
 }
-var waitForEventLoop = (process.env.NODE_ENV, function (cb) {
-    return cb();
-  }),
-  counter = 0,
-  passThroughKeys = {
-    subscribe: !0,
-    _version: !0,
-    _trackers: !0,
-    $$typeof: !0,
-    _listeners: !0,
-    _enableTracking: !0
-  };
+var waitForEventLoop = process.env.NODE_ENV === "test" || true ? function (cb) {
+  return cb();
+} : queueMicrotask;
+var counter = 0;
+var passThroughKeys = {
+  subscribe: true,
+  _version: true,
+  _trackers: true,
+  $$typeof: true,
+  _listeners: true,
+  _enableTracking: true
+};
 function getShouldDebug(storeInfo) {
   var info = {
-      storeInstance: storeInfo.store
-    },
-    trackers = storeInfo.trackers;
+    storeInstance: storeInfo.store
+  };
+  var trackers = storeInfo.trackers;
   return [...trackers].some(function (tracker) {
     return tracker.component && shouldDebug(tracker.component, info);
   });