@tamagui/use-store 2.7.6 → 3.0.0-beta.637.1

package/dist/esm/useStore.mjs

@@ -4,412 +4,385 @@ import { configureOpts } from "./configureUseStore.mjs";
 import { UNWRAP_PROXY, defaultOptions } from "./constants.mjs";
 import { UNWRAP_STORE_INFO, cache, getStoreDescriptors, getStoreUid, simpleStr } from "./helpers.mjs";
 import { DebugStores, shouldDebug, useCurrentComponent } from "./useStoreDebug.mjs";
-const idFn = _ => _;
+
+const idFn = (_) => _;
 function useStore(StoreKlass, props, options = defaultOptions) {
-  return useStoreFromInfo(getOrCreateStoreInfo(StoreKlass, props, options), options.selector, options);
+	return useStoreFromInfo(getOrCreateStoreInfo(StoreKlass, props, options), options.selector, options);
 }
 function useStoreDebug(StoreKlass, props) {
-  return useStore(StoreKlass, props, {
-    debug: true
-  });
+	return useStore(StoreKlass, props, { debug: true });
 }
 function createStore(StoreKlass, props, options) {
-  return getOrCreateStoreInfo(StoreKlass, props, options)?.store;
+	return getOrCreateStoreInfo(StoreKlass, props, options)?.store;
 }
 function useGlobalStore(instance, debug) {
-  const store = instance[UNWRAP_PROXY];
-  const uid = getStoreUid(store.constructor, store.props);
-  const info = cache.get(uid);
-  if (!info) throw new Error(`This store not created using createStore()`);
-  return useStoreFromInfo(info, void 0, {
-    debug
-  });
+	const store = instance[UNWRAP_PROXY];
+	const uid = getStoreUid(store.constructor, store.props);
+	const 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) {
-  const store = instance[UNWRAP_PROXY];
-  const uid = getStoreUid(store.constructor, store.props);
-  const info = cache.get(uid);
-  if (!info) throw new Error(`This store not created using createStore()`);
-  return useStoreFromInfo(info, selector, {
-    debug
-  });
+	const store = instance[UNWRAP_PROXY];
+	const uid = getStoreUid(store.constructor, store.props);
+	const info = cache.get(uid);
+	if (!info) throw new Error(`This store not created using createStore()`);
+	return useStoreFromInfo(info, selector, { debug });
 }
 function createUseStore(StoreKlass) {
-  return (props, options) => useStore(StoreKlass, props, options);
+	return (props, options) => useStore(StoreKlass, props, options);
 }
 function createUseStoreSelector(StoreKlass, selector) {
-  return props => {
-    return useStore(StoreKlass, props, {
-      selector
-    });
-  };
+	return (props) => {
+		return useStore(StoreKlass, props, { selector });
+	};
 }
 function useStoreSelector(StoreKlass, selector, props) {
-  return useStore(StoreKlass, props, {
-    selector
-  });
+	return useStore(StoreKlass, props, { selector });
 }
-const storeAccessTrackers = /* @__PURE__ */new Set();
+const storeAccessTrackers = /* @__PURE__ */ new Set();
 function trackStoresAccess(cb) {
-  storeAccessTrackers.add(cb);
-  return () => {
-    storeAccessTrackers.delete(cb);
-  };
+	storeAccessTrackers.add(cb);
+	return () => {
+		storeAccessTrackers.delete(cb);
+	};
 }
 function getStore(StoreKlass, props) {
-  return getStoreInfo(StoreKlass, props)?.store;
+	return getStoreInfo(StoreKlass, props)?.store;
 }
 function getOrCreateStore(StoreKlass, props) {
-  return getOrCreateStoreInfo(StoreKlass, props, {
-    refuseCreation: false
-  })?.store;
+	return getOrCreateStoreInfo(StoreKlass, props, { refuseCreation: false })?.store;
 }
 function getStoreInfo(StoreKlass, props) {
-  return getOrCreateStoreInfo(StoreKlass, props, {
-    refuseCreation: true
-  });
+	return getOrCreateStoreInfo(StoreKlass, props, { refuseCreation: true });
 }
-const onCreateListeners = /* @__PURE__ */new Set();
+const onCreateListeners = /* @__PURE__ */ new Set();
 function onCreateStore(cb) {
-  onCreateListeners.add(cb);
-  return () => {
-    onCreateListeners.delete(cb);
-  };
+	onCreateListeners.add(cb);
+	return () => {
+		onCreateListeners.delete(cb);
+	};
 }
 function getOrCreateStoreInfo(StoreKlass, props, options, propsKeyCalculated) {
-  if (!StoreKlass) return null;
-  const 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}`);
-  const storeInstance = new StoreKlass(props);
-  storeInstance.props = props;
-  const getters = {};
-  const actions = {};
-  const stateKeys = /* @__PURE__ */new Set();
-  const descriptors = 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);
-  }
-  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();
-    }
-  };
-  const store = createProxiedStore(storeInfo);
-  if (process.env.NODE_ENV === "development") allStores[StoreKlass.name + uid] = store;
-  store.mount?.();
-  storeInfo.store = store;
-  const result = storeInfo;
-  cache.set(uid, result);
-  onCreateListeners.forEach(cb => cb(result));
-  return result;
+	if (!StoreKlass) return null;
+	const 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}`);
+	const storeInstance = new StoreKlass(props);
+	storeInstance.props = props;
+	const getters = {};
+	const actions = {};
+	const stateKeys = /* @__PURE__ */ new Set();
+	const descriptors = 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);
+	}
+	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();
+		}
+	};
+	const store = createProxiedStore(storeInfo);
+	if (process.env.NODE_ENV === "development") allStores[StoreKlass.name + uid] = store;
+	store.mount?.();
+	storeInfo.store = store;
+	const result = storeInfo;
+	cache.set(uid, result);
+	onCreateListeners.forEach((cb) => cb(result));
+	return result;
 }
 const allStores = {};
 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;
+	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;
+const setIsInReaction = (val) => {
+	isInReaction = val;
 };
 function useStoreFromInfo(info, userSelector, options) {
-  const store = info?.store;
-  const internal = React.useRef(void 0);
-  const component = 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 = React.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" && isEqualSubsetShallow(last, snap, {
-      keyComparators: info.keyComparators
-    });
-    if (shouldPrintDebug) console.info("🌑 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 = React.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;
-      const keyString = key;
-      if (info.stateKeys.has(keyString) || keyString in info.getters) {
-        if (shouldPrintDebug) console.info("👀 tracking", keyString);
-        curInternal.tracked.add(keyString);
-      }
-      if (Reflect.has(state, key)) return Reflect.get(state, key);
-      return curVal;
-    }
-  });
+	const store = info?.store;
+	const internal = React.useRef(void 0);
+	const component = 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 = React.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" && isEqualSubsetShallow(last, snap, { keyComparators: info.keyComparators });
+		if (shouldPrintDebug) console.info("🌑 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 = React.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;
+		const keyString = key;
+		if (info.stateKeys.has(keyString) || keyString in info.getters) {
+			if (shouldPrintDebug) console.info("👀 tracking", keyString);
+			curInternal.tracked.add(keyString);
+		}
+		if (Reflect.has(state, key)) return Reflect.get(state, key);
+		return curVal;
+	} });
 }
-let setters = /* @__PURE__ */new Set();
-const logStack = /* @__PURE__ */new Set();
+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 ?? DebugStores.has(constr);
-  let didSet = false;
-  const wrappedActions = {};
-  for (const key in actions) {
-    if (key === "subscribe") continue;
-    const actionFn = actions[key];
-    const isGetFn = key.startsWith("get");
-    wrappedActions[key] = function useStoreAction(...args) {
-      let res;
-      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);
-          return hash;
-        },
-        strColor = function (str) {
-          return `hsl(${hashCode(str) % 360}, 90%, 40%)`;
-        };
-      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;
-            if (!(process.env.LOG_LEVEL !== "0" && (isDebugging || 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();
-            logStack.add(logs);
-            let res;
-            const id = counter++;
-            try {
-              res = Reflect.apply(target, thisArg, args);
-            } catch (err) {
-              console.error("Error", err);
-              throw err;
-            } finally {
-              logStack.add("end");
-              const name = constr.name;
-              const color = strColor(name);
-              const simpleArgs = args.map(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) {
-                    if (item === "end") {
-                      console.groupEnd();
-                      continue;
-                    }
-                    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);
-                  }
-                } catch (err) {
-                  error = err;
-                }
-                for (const _ of logStack) console.groupEnd();
-                if (error) console.error(`error loggin`, error);
-                logStack.clear();
-              }
-              return res;
-            }
-          }
-        });
-      }
-    }
-  }
-  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(_, key) {
-      if (key in wrappedActions) return wrappedActions[key];
-      if (key in passThroughKeys) return Reflect.get(storeInstance, key);
-      if (key === UNWRAP_PROXY) return storeInstance;
-      if (key === 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);
-      }
-      if (key in getters) {
-        if (getCache.has(key)) return getCache.get(key);
-        curGetKeys.clear();
-        const isSubGetter = gettersState.isGetting;
-        gettersState.isGetting = true;
-        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());
-          depsToGetter.get(gk).add(key);
-        }
-        getCache.set(key, res);
-        return res;
-      }
-      return Reflect.get(storeInstance, key);
-    },
-    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.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);
-    getCache.delete(setKey);
-    if (!parentGetters) return;
-    for (const gk of parentGetters) {
-      getCache.delete(gk);
-      if (depsToGetter.has(gk)) clearGetterCache(gk);
-    }
-  }
-  return proxiedStore;
+	const { actions, storeInstance, getters, gettersState } = storeInfo;
+	const { getCache, curGetKeys, depsToGetter } = gettersState;
+	const constr = storeInstance.constructor;
+	const shouldDebug2 = storeInfo.debug ?? DebugStores.has(constr);
+	let didSet = false;
+	const wrappedActions = {};
+	for (const key in actions) {
+		if (key === "subscribe") continue;
+		const actionFn = actions[key];
+		const isGetFn = key.startsWith("get");
+		wrappedActions[key] = function useStoreAction(...args) {
+			let res;
+			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);
+				return hash;
+			}, strColor = function(str) {
+				return `hsl(${hashCode(str) % 360}, 90%, 40%)`;
+			};
+			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;
+					if (!(process.env.LOG_LEVEL !== "0" && (isDebugging || 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();
+					logStack.add(logs);
+					let res;
+					const id = counter++;
+					try {
+						res = Reflect.apply(target, thisArg, args);
+					} catch (err) {
+						console.error("Error", err);
+						throw err;
+					} finally {
+						logStack.add("end");
+						const name = constr.name;
+						const color = strColor(name);
+						const simpleArgs = args.map(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) {
+									if (item === "end") {
+										console.groupEnd();
+										continue;
+									}
+									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);
+								}
+							} catch (err) {
+								error = err;
+							}
+							for (const _ of logStack) console.groupEnd();
+							if (error) console.error(`error loggin`, error);
+							logStack.clear();
+						}
+						return res;
+					}
+				} });
+			}
+		}
+	}
+	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(_, key) {
+			if (key in wrappedActions) return wrappedActions[key];
+			if (key in passThroughKeys) return Reflect.get(storeInstance, key);
+			if (key === UNWRAP_PROXY) return storeInstance;
+			if (key === 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);
+			}
+			if (key in getters) {
+				if (getCache.has(key)) return getCache.get(key);
+				curGetKeys.clear();
+				const isSubGetter = gettersState.isGetting;
+				gettersState.isGetting = true;
+				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());
+					depsToGetter.get(gk).add(key);
+				}
+				getCache.set(key, res);
+				return res;
+			}
+			return Reflect.get(storeInstance, key);
+		},
+		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.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);
+		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" || false ? cb => cb() : queueMicrotask;
+const waitForEventLoop = process.env.NODE_ENV === "test" || false ? (cb) => cb() : queueMicrotask;
 let counter = 0;
 const passThroughKeys = {
-  subscribe: true,
-  _version: true,
-  _trackers: true,
-  $$typeof: true,
-  _listeners: true,
-  _enableTracking: true
+	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 && shouldDebug(tracker.component, info));
+	const info = { storeInstance: storeInfo.store };
+	return [...storeInfo.trackers].some((tracker) => tracker.component && shouldDebug(tracker.component, info));
 }
+
 export { allStores, createStore, createUseStore, createUseStoreSelector, getOrCreateStore, getStore, getStoreInfo, onCreateStore, setIsInReaction, trackStoresAccess, useGlobalStore, useGlobalStoreSelector, useStore, useStoreDebug, useStoreSelector };
 //# sourceMappingURL=useStore.mjs.map