@tamagui/use-store 1.61.3 → 1.62.1

package/dist/cjs/useStore.js

@@ -1,21 +1,17 @@
-"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   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") {
+    __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))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 var useStore_exports = {};
 __export(useStore_exports, {
   allStores: () => allStores,
@@ -35,42 +31,28 @@ __export(useStore_exports, {
   useStoreSelector: () => useStoreSelector
 });
 module.exports = __toCommonJS(useStore_exports);
-var import_react = require("react");
-var import_comparators = require("./comparators");
-var import_configureUseStore = require("./configureUseStore");
-var import_constants = require("./constants");
-var import_helpers = require("./helpers");
-var import_useStoreDebug = require("./useStoreDebug");
+var import_react = require("react"), import_comparators = require("./comparators"), import_configureUseStore = require("./configureUseStore"), import_constants = require("./constants"), import_helpers = require("./helpers"), import_useStoreDebug = require("./useStoreDebug");
 const idFn = (_) => _;
 function useStore(StoreKlass, props, options = import_constants.defaultOptions) {
-  const selectorCb = (0, import_react.useCallback)(options.selector || idFn, []);
-  const selector = options.selector ? selectorCb : options.selector;
-  const info = getOrCreateStoreInfo(StoreKlass, props, options);
+  const selectorCb = (0, import_react.useCallback)(options.selector || idFn, []), selector = options.selector ? selectorCb : options.selector, info = getOrCreateStoreInfo(StoreKlass, props, options);
   return useStoreFromInfo(info, selector, options);
 }
 function useStoreDebug(StoreKlass, props) {
-  return useStore(StoreKlass, props, { debug: true });
+  return useStore(StoreKlass, props, { debug: !0 });
 }
 function createStore(StoreKlass, props, options) {
-  var _a;
-  return (_a = getOrCreateStoreInfo(StoreKlass, props, options)) == null ? void 0 : _a.store;
+  return getOrCreateStoreInfo(StoreKlass, props, options)?.store;
 }
 function useGlobalStore(instance, debug) {
-  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()`);
-  }
+  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()");
   return useStoreFromInfo(info, void 0, { debug });
 }
 function useGlobalStoreSelector(instance, selector, debug) {
-  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()`);
-  }
+  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()");
   return useStoreFromInfo(info, selector, { debug });
 }
 function createUseStore(StoreKlass) {
@@ -79,75 +61,52 @@ function createUseStore(StoreKlass) {
   };
 }
 function createUseStoreSelector(StoreKlass, selector) {
-  return (props) => {
-    return useStore(StoreKlass, props, { selector });
-  };
+  return (props) => useStore(StoreKlass, props, { selector });
 }
 function useStoreSelector(StoreKlass, selector, props) {
   return useStore(StoreKlass, props, { selector });
 }
 const storeAccessTrackers = /* @__PURE__ */ new Set();
 function trackStoresAccess(cb) {
-  storeAccessTrackers.add(cb);
-  return () => {
+  return storeAccessTrackers.add(cb), () => {
     storeAccessTrackers.delete(cb);
   };
 }
 function getStore(StoreKlass, props) {
-  var _a;
-  return (_a = getStoreInfo(StoreKlass, props)) == null ? void 0 : _a.store;
+  return getStoreInfo(StoreKlass, props)?.store;
 }
 function getOrCreateStore(StoreKlass, props) {
-  var _a;
-  return (_a = getOrCreateStoreInfo(StoreKlass, props, {
-    refuseCreation: false
-  })) == null ? void 0 : _a.store;
+  return getOrCreateStoreInfo(StoreKlass, props, {
+    refuseCreation: !1
+  })?.store;
 }
 function getStoreInfo(StoreKlass, props) {
   return getOrCreateStoreInfo(StoreKlass, props, {
-    refuseCreation: true
+    refuseCreation: !0
   });
 }
 const onCreateListeners = /* @__PURE__ */ new Set();
 function onCreateStore(cb) {
-  onCreateListeners.add(cb);
-  return () => {
+  return onCreateListeners.add(cb), () => {
     onCreateListeners.delete(cb);
   };
 }
 function getOrCreateStoreInfo(StoreKlass, props, options, propsKeyCalculated) {
-  var _a;
-  if (!StoreKlass) {
+  if (!StoreKlass)
     return null;
-  }
   const uid = (0, import_helpers.getStoreUid)(StoreKlass, propsKeyCalculated ?? props);
-  if (!(options == null ? void 0 : options.avoidCache) && import_helpers.cache.has(uid)) {
+  if (!options?.avoidCache && import_helpers.cache.has(uid))
     return import_helpers.cache.get(uid);
-  }
-  if (options == null ? void 0 : options.refuseCreation) {
+  if (options?.refuseCreation)
     throw new Error(`No store exists (${StoreKlass.name}) with props: ${props}`);
-  }
   const storeInstance = new StoreKlass(props);
   storeInstance.props = props;
-  const getters = {};
-  const actions = {};
-  const stateKeys = /* @__PURE__ */ new Set();
-  const descriptors = (0, import_helpers.getStoreDescriptors)(storeInstance);
+  const getters = {}, actions = {}, stateKeys = /* @__PURE__ */ new Set(), descriptors = (0, import_helpers.getStoreDescriptors)(storeInstance);
   for (const key in descriptors) {
     const descriptor = descriptors[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);
-      }
-    }
+    typeof descriptor.value == "function" ? actions[key] = descriptor.value : typeof descriptor.get == "function" ? getters[key] = descriptor.get : key !== "props" && key[0] !== "_" && stateKeys.add(key);
   }
-  const keyComparators = storeInstance["_comparators"];
-  const listeners = /* @__PURE__ */ new Set();
-  const storeInfo = {
+  const keyComparators = storeInstance._comparators, listeners = /* @__PURE__ */ new Set(), storeInfo = {
     uid,
     keyComparators,
     storeInstance,
@@ -155,217 +114,129 @@ function getOrCreateStoreInfo(StoreKlass, props, options, propsKeyCalculated) {
     stateKeys,
     props,
     actions,
-    debug: options == null ? void 0 : options.debug,
-    disableTracking: false,
+    debug: options?.debug,
+    disableTracking: !1,
     gettersState: {
       getCache: /* @__PURE__ */ new Map(),
       depsToGetter: /* @__PURE__ */ new Map(),
       curGetKeys: /* @__PURE__ */ new Set(),
-      isGetting: false
+      isGetting: !1
     },
     listeners,
     trackers: /* @__PURE__ */ new Set(),
     version: 0,
-    subscribe: (onChanged) => {
-      listeners.add(onChanged);
-      return () => {
-        listeners.delete(onChanged);
-      };
-    },
+    subscribe: (onChanged) => (listeners.add(onChanged), () => {
+      listeners.delete(onChanged);
+    }),
     triggerUpdate: () => {
       storeInfo.version = (storeInfo.version + 1) % Number.MAX_SAFE_INTEGER;
-      for (const cb of listeners) {
+      for (const cb of listeners)
         cb();
-      }
     }
-  };
-  const store = createProxiedStore(
+  }, store = createProxiedStore(
     // we assign store right after and proxiedStore never accesses it until later on
     storeInfo
   );
-  if (process.env.NODE_ENV === "development") {
-    allStores[uid] = store;
-  }
-  (_a = store.mount) == null ? void 0 : _a.call(store);
-  storeInfo.store = store;
+  process.env.NODE_ENV === "development" && (allStores[uid] = store), store.mount?.(), storeInfo.store = store;
   const result = storeInfo;
-  import_helpers.cache.set(uid, result);
-  onCreateListeners.forEach((cb) => cb(result));
-  return result;
+  return import_helpers.cache.set(uid, result), onCreateListeners.forEach((cb) => cb(result)), result;
 }
-const allStores = {};
-const emptyObj = {};
-const selectKeys = (obj, keys) => {
-  if (!keys.length) {
+const allStores = {}, emptyObj = {}, selectKeys = (obj, keys) => {
+  if (!keys.length)
     return emptyObj;
-  }
   const res = {};
-  for (const key of keys) {
+  for (const key of keys)
     res[key] = obj[key];
-  }
   return res;
 };
-let isInReaction = false;
+let isInReaction = !1;
 const setIsInReaction = (val) => {
   isInReaction = val;
 };
 function useStoreFromInfo(info, userSelector, options) {
-  const store = info == null ? void 0 : info.store;
-  const internal = (0, import_react.useRef)();
-  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 == null ? void 0 : options.debug;
-  const getSnapshot = (0, import_react.useCallback)(() => {
+  const store = info?.store, internal = (0, import_react.useRef)(), 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 = (0, import_react.useCallback)(() => {
     if (!info || !store)
       return;
-    const curInternal2 = internal.current;
-    const keys = [...!curInternal2.tracked.size ? info.stateKeys : curInternal2.tracked];
-    const nextKeys = `${info.version}${keys.join("")}${userSelector || ""}`;
-    const lastKeys = curInternal2.lastKeys;
-    if (nextKeys === curInternal2.lastKeys) {
+    const curInternal2 = internal.current, keys = [...curInternal2.tracked.size ? 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 = true;
+    info.disableTracking = !0;
     const last = curInternal2.last;
-    if (userSelector) {
-      snap = userSelector(store);
-    } else {
-      snap = selectKeys(store, keys);
-    }
-    info.disableTracking = false;
-    const isUnchanged = typeof last !== "undefined" && (0, import_comparators.isEqualSubsetShallow)(last, snap, {
+    userSelector ? snap = userSelector(store) : snap = selectKeys(store, keys), info.disableTracking = !1;
+    const isUnchanged = typeof last < "u" && (0, import_comparators.isEqualSubsetShallow)(last, snap, {
       keyComparators: info.keyComparators
     });
-    if (shouldPrintDebug) {
-      console.log("\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]);
-  const state = (0, import_react.useSyncExternalStore)((info == null ? void 0 : info.subscribe) || idFn, getSnapshot, getSnapshot);
-  if (!info || !store || !state) {
-    return state;
-  }
-  if (userSelector) {
-    return state;
-  }
-  return new Proxy(store, {
+    return shouldPrintDebug && console.log("\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 = (0, import_react.useSyncExternalStore)(info?.subscribe || idFn, getSnapshot, getSnapshot);
+  return !info || !store || !state || userSelector ? state : new Proxy(store, {
     get(target, key) {
       const curVal = Reflect.get(target, key);
-      if (isInReaction) {
+      if (isInReaction)
         return curVal;
-      }
       const keyString = key;
-      if (info.stateKeys.has(keyString) || keyString in info.getters) {
-        if (shouldPrintDebug) {
-          console.log("tracking", keyString);
-        }
-        curInternal.tracked.add(keyString);
-      }
-      if (Reflect.has(state, key)) {
-        return Reflect.get(state, key);
-      }
-      return curVal;
+      return (info.stateKeys.has(keyString) || keyString in info.getters) && (shouldPrintDebug && console.log("tracking", keyString), curInternal.tracked.add(keyString)), Reflect.has(state, key) ? Reflect.get(state, key) : curVal;
     }
   });
 }
 let setters = /* @__PURE__ */ new Set();
 const logStack = /* @__PURE__ */ new Set();
 function createProxiedStore(storeInfo) {
-  const { 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 { actions, storeInstance, getters, gettersState } = storeInfo, { getCache, curGetKeys, depsToGetter } = gettersState, constr = storeInstance.constructor, shouldDebug2 = storeInfo.debug ?? import_useStoreDebug.DebugStores.has(constr);
+  let didSet = !1;
   const wrappedActions = {};
   for (const key in actions) {
-    if (key === "subscribe") {
+    if (key === "subscribe")
       continue;
-    }
-    const actionFn = actions[key];
-    const isGetFn = key.startsWith("get");
-    wrappedActions[key] = function useStoreAction(...args) {
+    const actionFn = actions[key], isGetFn = key.startsWith("get");
+    if (wrappedActions[key] = function(...args) {
       let res;
-      if (isGetFn || gettersState.isGetting) {
-        return Reflect.apply(actionFn, proxiedStore, args);
-      }
-      if (process.env.NODE_ENV === "development" && shouldDebug2) {
-        console.log("(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 hashCode2 = function(str) {
+      return isGetFn || gettersState.isGetting ? Reflect.apply(actionFn, proxiedStore, args) : (process.env.NODE_ENV === "development" && shouldDebug2 && console.log("(debug) startAction", key), res = Reflect.apply(actionFn, proxiedStore, args), res instanceof Promise ? res.then(finishAction) : (finishAction(), res));
+    }, process.env.NODE_ENV === "development") {
+      let hashCode = function(str) {
         let hash = 0;
-        for (let i = 0; i < str.length; i++) {
+        for (let 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%)`;
+      }, strColor = function(str) {
+        return `hsl(${hashCode(str) % 360}, 90%, 40%)`;
       };
-      var hashCode = hashCode2, strColor = strColor2;
       if (!key.startsWith("get") && !key.startsWith("_") && key !== "subscribe") {
         const ogAction = wrappedActions[key];
         wrappedActions[key] = new Proxy(ogAction, {
           apply(target, thisArg, args) {
             const isDebugging = shouldDebug2 || storeInfo.debug;
-            const shouldLog = process.env.LOG_LEVEL !== "0" && (isDebugging || import_configureUseStore.configureOpts.logLevel !== "error");
-            if (!shouldLog) {
+            if (!(process.env.LOG_LEVEL !== "0" && (isDebugging || import_configureUseStore.configureOpts.logLevel !== "error")))
               return Reflect.apply(target, thisArg, args);
-            }
             setters = /* @__PURE__ */ new Set();
-            const curSetters = setters;
-            const isTopLevelLogger = logStack.size == 0;
-            const logs = /* @__PURE__ */ new Set();
+            const curSetters = setters, isTopLevelLogger = logStack.size == 0, logs = /* @__PURE__ */ new Set();
             logStack.add(logs);
             let res;
             const id = counter++;
             try {
               res = Reflect.apply(target, thisArg, args);
             } catch (err) {
-              console.error("Error", err);
-              throw err;
+              throw console.error("Error", err), err;
             } finally {
               logStack.add("end");
-              const name = constr.name;
-              const color = strColor2(name);
-              const simpleArgs = args.map(import_helpers.simpleStr);
-              logs.add([
+              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;"
-              ]);
-              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) {
+              ]), 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) {
                 let error = null;
                 try {
                   for (const item of [...logStack]) {
@@ -375,33 +246,18 @@ function createProxiedStore(storeInfo) {
                     }
                     const [head, ...rest] = item;
                     if (head) {
-                      console.groupCollapsed(...head);
-                      console.groupCollapsed("...");
-                      console.log("args", args);
-                      console.log("response", res);
-                      console.groupCollapsed("trace");
-                      console.trace();
-                      console.groupEnd();
-                      console.groupEnd();
-                      for (const [name2, ...log] of rest) {
-                        console.groupCollapsed(name2);
-                        console.log(...log);
-                        console.groupEnd();
-                      }
-                    } else {
+                      console.groupCollapsed(...head), console.groupCollapsed("..."), console.log("args", args), console.log("response", res), console.groupCollapsed("trace"), console.trace(), console.groupEnd(), console.groupEnd();
+                      for (const [name2, ...log] of rest)
+                        console.groupCollapsed(name2), console.log(...log), console.groupEnd();
+                    } else
                       console.log("Weird log", head, ...rest);
-                    }
                   }
                 } catch (err) {
                   error = err;
                 }
-                for (const _ of [...logStack]) {
+                for (const _ of [...logStack])
                   console.groupEnd();
-                }
-                if (error) {
-                  console.error(`error loggin`, error);
-                }
-                logStack.clear();
+                error && console.error("error loggin", error), logStack.clear();
               }
               return res;
             }
@@ -410,124 +266,64 @@ function createProxiedStore(storeInfo) {
       }
     }
   }
-  const finishAction = (val) => {
-    if (process.env.NODE_ENV === "development" && shouldDebug2) {
-      console.log("(debug) finishAction", { didSet });
-    }
-    if (didSet) {
-      storeInfo.triggerUpdate();
-      didSet = false;
-    }
-    return val;
-  };
-  let isTriggering = false;
+  const finishAction = (val) => (process.env.NODE_ENV === "development" && shouldDebug2 && console.log("(debug) finishAction", { didSet }), didSet && (storeInfo.triggerUpdate(), didSet = !1), val);
+  let isTriggering = !1;
   const proxiedStore = new Proxy(storeInstance, {
     // GET
     get(_, key) {
-      if (key in wrappedActions) {
+      if (key in wrappedActions)
         return wrappedActions[key];
-      }
-      if (key in passThroughKeys) {
+      if (key in passThroughKeys)
         return Reflect.get(storeInstance, key);
-      }
-      if (key === import_constants.UNWRAP_PROXY) {
+      if (key === import_constants.UNWRAP_PROXY)
         return storeInstance;
-      }
-      if (key === import_helpers.UNWRAP_STORE_INFO) {
+      if (key === import_helpers.UNWRAP_STORE_INFO)
         return storeInfo;
-      }
-      if (storeAccessTrackers.size) {
-        storeAccessTrackers.forEach((cb) => cb(storeInfo));
-      }
-      if (typeof key !== "string") {
+      if (storeAccessTrackers.size && storeAccessTrackers.forEach((cb) => cb(storeInfo)), 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)) {
+      if (storeInfo.disableTracking || gettersState.isGetting && gettersState.curGetKeys.add(key), key in getters) {
+        if (getCache.has(key))
           return getCache.get(key);
-        }
         curGetKeys.clear();
         const isSubGetter = gettersState.isGetting;
-        gettersState.isGetting = true;
+        gettersState.isGetting = !0;
         const res = getters[key].call(proxiedStore);
-        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;
+        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;
       }
       return Reflect.get(storeInstance, key);
     },
     // SET
     set(target, key, value, receiver) {
-      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.log("(debug) SET", res, key, value);
-          }
-        }
-        if (process.env.NODE_ENV === "development" && shouldDebug2) {
-          console.log("SET...", { key, value });
-        }
-        if (!isTriggering) {
-          isTriggering = true;
-          waitForEventLoop(() => {
-            storeInfo.triggerUpdate();
-            isTriggering = false;
-          });
-        }
-      }
-      return res;
+      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.log("(debug) SET", res, key, value)), process.env.NODE_ENV === "development" && shouldDebug2 && console.log("SET...", { key, value }), isTriggering || (isTriggering = !0, waitForEventLoop(() => {
+        storeInfo.triggerUpdate(), isTriggering = !1;
+      }))), res;
     }
   });
   function clearGetterCache(setKey) {
     const parentGetters = depsToGetter.get(setKey);
-    getCache.delete(setKey);
-    if (!parentGetters) {
-      return;
-    }
-    for (const gk of parentGetters) {
-      getCache.delete(gk);
-      if (depsToGetter.has(gk)) {
-        clearGetterCache(gk);
-      }
-    }
+    if (getCache.delete(setKey), !!parentGetters)
+      for (const gk of parentGetters)
+        getCache.delete(gk), depsToGetter.has(gk) && clearGetterCache(gk);
   }
   return proxiedStore;
 }
 const waitForEventLoop = process.env.NODE_ENV === "test" ? (cb) => cb() : queueMicrotask;
 let counter = 0;
 const passThroughKeys = {
-  subscribe: true,
-  _version: true,
-  _trackers: true,
-  $$typeof: true,
-  _listeners: true,
-  _enableTracking: true
+  subscribe: !0,
+  _version: !0,
+  _trackers: !0,
+  $$typeof: !0,
+  _listeners: !0,
+  _enableTracking: !0
 };
 function getShouldDebug(storeInfo) {
   const info = { storeInstance: storeInfo.store };
-  const trackers = storeInfo.trackers;
-  return [...trackers].some(
+  return [...storeInfo.trackers].some(
     (tracker) => tracker.component && (0, import_useStoreDebug.shouldDebug)(tracker.component, info)
   );
 }