yuustate 0.0.1 → 3.9.0

package/esm/react.mjs

@@ -0,0 +1,1005 @@
+import { useLayoutEffect, useEffect, useState, useRef, useMemo, useCallback } from 'react';
+import { isClient, initStore, getHash, noop } from 'yuustate/vanilla';
+
+const useIsomorphicLayoutEffect = isClient ? useLayoutEffect : useEffect;
+
+const getValueByPath = (obj, path) => path.reduce((acc, key) => acc == null ? void 0 : acc[key], obj);
+const isPrefixPath = (candidatePrefix, targetPath) => {
+  if (candidatePrefix.length >= targetPath.length) return false;
+  for (let i = 0; i < candidatePrefix.length; i++) {
+    if (candidatePrefix[i] !== targetPath[i]) return false;
+  }
+  return true;
+};
+const compressPaths = (paths) => {
+  const result = [];
+  let prev = null;
+  for (let i = paths.length - 1; i >= 0; i--) {
+    const current = paths[i];
+    if (!prev || !isPrefixPath(current, prev)) result.push(current);
+    prev = current;
+  }
+  return result;
+};
+const useStoreStateProxy = (storeState) => {
+  const usedPathsRef = useRef([]);
+  usedPathsRef.current = [];
+  const trackedState = useMemo(() => {
+    const track = (path) => usedPathsRef.current.push(path);
+    const proxyCache = /* @__PURE__ */ new WeakMap();
+    const createDeepProxy = (target, path = []) => {
+      if (typeof target !== "object" || target === null) {
+        return target;
+      }
+      if (proxyCache.has(target)) {
+        return proxyCache.get(target);
+      }
+      const proxy = new Proxy(target, {
+        get(obj, key) {
+          const newPath = [...path, key];
+          track(newPath);
+          const value = obj[key];
+          return createDeepProxy(value, newPath);
+        }
+      });
+      proxyCache.set(target, proxy);
+      return proxy;
+    };
+    return createDeepProxy(storeState);
+  }, [storeState]);
+  return [trackedState, usedPathsRef];
+};
+const NO_INITIAL_VALUE = {};
+const useStoreStateWithInitializer = (store, initialState = NO_INITIAL_VALUE) => {
+  const initiatedAt = useRef(new WeakMap([[store, 0]]));
+  useEffect(() => {
+    if (initialState === NO_INITIAL_VALUE || initiatedAt.current.get(store)) return;
+    store.setState(initialState);
+    initiatedAt.current.set(store, Date.now());
+  }, [store, initialState]);
+  const storeState = store.getState();
+  const finalState = initialState === NO_INITIAL_VALUE || initiatedAt.current.get(store) ? storeState : { ...storeState, ...initialState };
+  return [finalState, initiatedAt];
+};
+const useStoreState = (store, options = {}) => {
+  const [state] = useStoreStateWithInitializer(store, options.initialState);
+  const [trackedState, usedPathsRef] = useStoreStateProxy(state);
+  const [, reRender] = useState({});
+  useEffect(() => {
+    return store.subscribe((nextState, prevState, changedKeys) => {
+      const paths = compressPaths(usedPathsRef.current);
+      for (const path of paths) {
+        const rootKey = path[0];
+        if (!changedKeys.includes(rootKey)) continue;
+        const prevVal = getValueByPath(prevState, path);
+        const nextVal = getValueByPath(nextState, path);
+        if (!Object.is(prevVal, nextVal)) return reRender({});
+      }
+    });
+  }, [store]);
+  return trackedState;
+};
+
+const createStore = (initialState, options) => {
+  const store = initStore(initialState, options);
+  const useStore = (options2) => useStoreState(store, options2);
+  return Object.assign(useStore, store);
+};
+
+const createStores = (initialState, options) => {
+  const stores = /* @__PURE__ */ new Map();
+  const getStore = (key = {}) => {
+    const keyHash = getHash(key);
+    let store;
+    if (stores.has(keyHash)) {
+      store = stores.get(keyHash);
+    } else {
+      store = initStore(
+        initialState,
+        options
+        // Intentionally using as any: don't want to add generic on `initStore`
+      );
+      store.key = key;
+      store.keyHash = keyHash;
+      stores.set(keyHash, store);
+      store.delete = () => {
+        if (store.getSubscriberCount() > 0) {
+          console.warn(
+            "Cannot delete store while it still has active subscribers. Unsubscribe all listeners before deleting the store."
+          );
+          return false;
+        }
+        store.setState(initialState);
+        return stores.delete(keyHash);
+      };
+    }
+    const useStore = (options2) => useStoreState(store, options2);
+    return Object.assign(useStore, store);
+  };
+  return getStore;
+};
+
+const INITIAL_STATE$2 = {
+  isPending: false,
+  isRevalidating: false,
+  willRetryAt: void 0,
+  isRetrying: false,
+  retryCount: 0,
+  state: "INITIAL",
+  isSuccess: false,
+  isError: false,
+  data: void 0,
+  dataUpdatedAt: void 0,
+  dataStaleAt: void 0,
+  error: void 0,
+  errorUpdatedAt: void 0
+};
+const createQuery = (queryFn, options = {}) => {
+  const {
+    staleTime = 2500,
+    // 2.5 seconds,
+    gcTime = 5 * 60 * 1e3,
+    // 5 minutes
+    revalidateOnFocus = true,
+    revalidateOnReconnect = true,
+    onSuccess = noop,
+    onError,
+    onSettled = noop,
+    shouldRetry: shouldRetryFn = (_, s) => s.retryCount === 0 ? [true, 1500] : [false]
+  } = options;
+  const initialState = { ...INITIAL_STATE$2 };
+  const stores = /* @__PURE__ */ new Map();
+  const configureStoreEvents = (variableHash) => ({
+    ...options,
+    onFirstSubscribe: (state, store) => {
+      var _a;
+      (_a = options.onFirstSubscribe) == null ? void 0 : _a.call(options, state, store);
+      const { internal, revalidate: revalidate2 } = store;
+      clearTimeout(internal.garbageCollectionTimeoutId);
+      if (isClient) {
+        if (revalidateOnFocus) {
+          focusListeners.add(revalidate2);
+          if (!focusListenersAdded) {
+            window.addEventListener("focus", onWindowFocus);
+            focusListenersAdded = true;
+          }
+        }
+        if (revalidateOnReconnect) {
+          onlineListeners$1.add(revalidate2);
+          if (!onlineListenersAdded) {
+            window.addEventListener("online", onWindowOnline$1);
+            onlineListenersAdded = true;
+          }
+        }
+      }
+    },
+    onLastUnsubscribe: (state, store) => {
+      var _a;
+      (_a = options.onLastUnsubscribe) == null ? void 0 : _a.call(options, state, store);
+      const { internal, revalidate: revalidate2 } = store;
+      clearTimeout(internal.retryTimeoutId);
+      if (internal.retryResolver) {
+        store.setState({ willRetryAt: void 0 });
+        internal.retryResolver(store.getState());
+        internal.retryResolver = void 0;
+      }
+      internal.garbageCollectionTimeoutId = setTimeout(() => {
+        if (internal.promiseResolver || internal.retryResolver) {
+          store.setState(initialState);
+        } else {
+          stores.delete(variableHash);
+        }
+      }, gcTime);
+      if (isClient) {
+        if (revalidateOnFocus) {
+          focusListeners.delete(revalidate2);
+          if (focusListeners.size === 0) {
+            window.removeEventListener("focus", onWindowFocus);
+            focusListenersAdded = false;
+          }
+        }
+        if (revalidateOnReconnect) {
+          onlineListeners$1.delete(revalidate2);
+          if (onlineListeners$1.size === 0) {
+            window.removeEventListener("online", onWindowOnline$1);
+            onlineListenersAdded = false;
+          }
+        }
+      }
+    }
+  });
+  const getApis = (store, variable) => ({
+    internal: {},
+    setInitialData: (data, revalidate2 = false) => {
+      const state = store.getState();
+      if (state.state === "INITIAL" && state.data === void 0) {
+        const { internal } = store;
+        if (revalidate2) internal.isInvalidated = true;
+        store.setState({
+          state: "SUCCESS",
+          isSuccess: true,
+          data,
+          dataUpdatedAt: Date.now()
+        });
+        return true;
+      }
+      return false;
+    },
+    execute: ({ overwriteOngoingExecution = true } = {}) => {
+      return execute(store, variable, overwriteOngoingExecution);
+    },
+    revalidate: ({ overwriteOngoingExecution = true } = {}) => {
+      return revalidate(store, variable, overwriteOngoingExecution);
+    },
+    invalidate: (options2) => {
+      const { internal } = store;
+      internal.isInvalidated = true;
+      if (store.getSubscriberCount() > 0) {
+        store.execute(options2);
+        return true;
+      }
+      return false;
+    },
+    reset: () => {
+      var _a, _b;
+      const { internal } = store;
+      clearTimeout(internal.retryTimeoutId);
+      if (internal.retryResolver || internal.promiseResolver) {
+        console.debug(
+          "Ongoing query execution was ignored due to reset(). The result will not update the store state."
+        );
+        (_a = internal.promiseResolver) == null ? void 0 : _a.call(internal, initialState);
+        (_b = internal.retryResolver) == null ? void 0 : _b.call(internal, initialState);
+        internal.promiseResolver = void 0;
+        internal.retryResolver = void 0;
+      }
+      internal.promise = void 0;
+      store.setState(initialState);
+    },
+    delete: () => {
+      if (store.getSubscriberCount() > 0) {
+        console.warn(
+          "Cannot delete query store while it still has active subscribers. Unsubscribe all listeners before deleting the store."
+        );
+        return false;
+      }
+      store.reset();
+      return stores.delete(store.variableHash);
+    },
+    optimisticUpdate: (optimisticData) => {
+      const { internal, revalidate: revalidate2, rollbackOptimisticUpdate } = store;
+      internal.rollbackData = store.getState().data;
+      store.setState({ data: optimisticData });
+      return { revalidate: revalidate2, rollback: rollbackOptimisticUpdate };
+    },
+    rollbackOptimisticUpdate: () => {
+      const { internal } = store;
+      store.setState({ data: internal.rollbackData });
+      return internal.rollbackData;
+    }
+  });
+  const execute = async (store, variable, overwriteOngoingExecution = false) => {
+    const { internal: _internal } = store;
+    const internal = _internal;
+    if (!overwriteOngoingExecution && internal.promise) return internal.promise;
+    clearTimeout(internal.retryTimeoutId);
+    const createPromise = () => {
+      const promise = new Promise((resolve) => {
+        internal.promiseResolver = resolve;
+        const stateBeforeExecute = store.getState();
+        store.setState({
+          isPending: true,
+          isRevalidating: stateBeforeExecute.state === "SUCCESS",
+          willRetryAt: void 0,
+          isRetrying: !!internal.retryResolver,
+          retryCount: internal.retryResolver ? stateBeforeExecute.retryCount + 1 : 0
+        });
+        queryFn(variable, stateBeforeExecute, store.variableHash).then((data) => {
+          var _a;
+          if (data === void 0) {
+            console.error(
+              "Query function returned undefined. Successful responses must not be undefined."
+            );
+          }
+          if (!internal.promiseResolver) return;
+          if (promise !== internal.promise) return resolve(internal.promise);
+          const now = Date.now();
+          store.setState({
+            isPending: false,
+            isRevalidating: false,
+            isRetrying: false,
+            retryCount: 0,
+            state: "SUCCESS",
+            isSuccess: true,
+            isError: false,
+            data,
+            dataUpdatedAt: now,
+            dataStaleAt: now + staleTime,
+            error: void 0,
+            errorUpdatedAt: void 0
+          });
+          internal.isInvalidated = false;
+          internal.rollbackData = data;
+          resolve(store.getState());
+          (_a = internal.retryResolver) == null ? void 0 : _a.call(internal, store.getState());
+          internal.retryResolver = void 0;
+          onSuccess(data, variable, stateBeforeExecute);
+          onSettled(variable, stateBeforeExecute);
+        }).catch((error) => {
+          var _a;
+          if (!internal.promiseResolver && !internal.retryResolver) return;
+          if (promise !== internal.promise) return resolve(internal.promise);
+          const nextState = {
+            ...store.getState(),
+            isPending: false,
+            isRevalidating: false,
+            isRetrying: false
+          };
+          const [shouldRetry, retryDelay] = shouldRetryFn(error, nextState);
+          const hasSubscriber = store.getSubscriberCount() > 0;
+          if (shouldRetry && hasSubscriber) {
+            internal.retryResolver = resolve;
+            internal.retryTimeoutId = setTimeout(createPromise, retryDelay);
+            store.setState({
+              isPending: false,
+              isRevalidating: false,
+              isRetrying: false,
+              willRetryAt: Date.now() + retryDelay
+            });
+          } else {
+            store.setState({
+              isPending: false,
+              isRevalidating: false,
+              isRetrying: false,
+              retryCount: 0,
+              state: store.getState().state === "SUCCESS" ? "SUCCESS_BUT_REVALIDATION_ERROR" : "ERROR",
+              isError: true,
+              error,
+              errorUpdatedAt: Date.now()
+            });
+            const state = store.getState();
+            resolve(state);
+            (_a = internal.retryResolver) == null ? void 0 : _a.call(internal, state);
+            internal.retryResolver = void 0;
+            if (onError) onError(error, variable, stateBeforeExecute);
+            else console.error(state);
+            onSettled(variable, stateBeforeExecute);
+          }
+        }).finally(() => {
+          if (internal.promise === promise) {
+            internal.promise = void 0;
+            internal.promiseResolver = void 0;
+          }
+        });
+      });
+      internal.promise = promise;
+      return promise;
+    };
+    return createPromise();
+  };
+  const revalidate = async (store, variable, overwriteOngoingExecution) => {
+    const { internal } = store;
+    if (!overwriteOngoingExecution && internal.promise) return internal.promise;
+    const state = store.getState();
+    if (state.dataUpdatedAt) {
+      const isFresh = state.dataUpdatedAt + staleTime > Date.now();
+      if (isFresh && !internal.isInvalidated) return state;
+    }
+    return execute(store, variable, overwriteOngoingExecution);
+  };
+  const getStore = (variable = {}) => {
+    const variableHash = getHash(variable);
+    let store;
+    if (stores.has(variableHash)) {
+      store = stores.get(variableHash);
+    } else {
+      store = initStore(
+        initialState,
+        configureStoreEvents(variableHash)
+        // Intentionally using as any: don't want to add generic on `initStore`
+      );
+      store.variableHash = variableHash;
+      stores.set(variableHash, store);
+      const apis = getApis(store, variable);
+      store.setInitialData = apis.setInitialData;
+      store.execute = apis.execute;
+      store.revalidate = apis.revalidate;
+      store.invalidate = apis.invalidate;
+      store.reset = apis.reset;
+      store.delete = apis.delete;
+      store.optimisticUpdate = apis.optimisticUpdate;
+      store.rollbackOptimisticUpdate = apis.rollbackOptimisticUpdate;
+      store.internal = apis.internal;
+    }
+    const useStore = (options2 = {}) => {
+      const {
+        initialData = NO_INITIAL_VALUE,
+        initialDataIsStale = false,
+        revalidateOnMount = true,
+        keepPreviousData
+      } = options2;
+      const [storeState, initialDataInitiatedAt] = useStoreStateWithInitializer(
+        store,
+        initialData === NO_INITIAL_VALUE ? void 0 : {
+          state: "SUCCESS",
+          isSuccess: true,
+          data: initialData
+        }
+      );
+      const prevState = useRef({});
+      let storeStateToBeUsed = storeState;
+      if (storeState.state !== "INITIAL") {
+        prevState.current = {
+          data: storeState.data,
+          dataUpdatedAt: storeState.dataUpdatedAt
+        };
+      } else if (keepPreviousData) {
+        storeStateToBeUsed = { ...storeState, ...prevState.current };
+      }
+      const [trackedState, usedPathsRef] = useStoreStateProxy(
+        revalidateOnMount && storeState.state === "INITIAL" ? (
+          // Optimize rendering on initial state
+          // Do { isPending: true } → result
+          // instead of { isPending: false } → { isPending: true } → result
+          { ...storeStateToBeUsed, isPending: true }
+        ) : storeStateToBeUsed
+      );
+      const [, reRender] = useState({});
+      useEffect(() => {
+        return store.subscribe((nextState, prevState2, changedKeys) => {
+          if (prevState2.state === "INITIAL" && !prevState2.isPending && nextState.isPending && !nextState.isRetrying) {
+            return;
+          }
+          const paths = compressPaths(usedPathsRef.current);
+          for (const path of paths) {
+            const rootKey = path[0];
+            if (!changedKeys.includes(rootKey)) continue;
+            const prevVal = getValueByPath(prevState2, path);
+            const nextVal = getValueByPath(nextState, path);
+            if (!Object.is(prevVal, nextVal)) return reRender({});
+          }
+        });
+      }, [store]);
+      useEffect(() => {
+        if (revalidateOnMount !== false) {
+          if (!initialDataIsStale) {
+            const dataInitiatedAt = initialDataInitiatedAt.current.get(store);
+            if (dataInitiatedAt && dataInitiatedAt + staleTime > Date.now()) {
+              return;
+            }
+          }
+          revalidate(store, variable, false);
+        }
+      }, [store, revalidateOnMount, initialDataIsStale]);
+      if (keepPreviousData) {
+        !!trackedState.error;
+      }
+      return trackedState;
+    };
+    return Object.assign(useStore, {
+      ...store,
+      setState: (value) => {
+        console.debug("Manual setState (not via provided actions) on query store");
+        store.setState(value);
+      }
+    });
+  };
+  return Object.assign(getStore, {
+    /**
+     * Executes all query instances.
+     *
+     * @remarks
+     * - Useful for bulk refetching.
+     */
+    executeAll: (options2) => {
+      stores.forEach((store) => store.execute(options2));
+    },
+    /**
+     * Revalidates all query instances.
+     *
+     * @remarks
+     * - Only re-fetches stale queries.
+     */
+    revalidateAll: (options2) => {
+      stores.forEach((store) => store.revalidate(options2));
+    },
+    /**
+     * Invalidates all query instances.
+     *
+     * @remarks
+     * - Marks all queries as invalidated and triggers revalidation if active.
+     * - Invalidated queries bypass `staleTime` until successfully executed again.
+     */
+    invalidateAll: (options2) => {
+      stores.forEach((store) => store.invalidate(options2));
+    },
+    /**
+     * Resets all query instances.
+     */
+    resetAll: () => {
+      stores.forEach((store) => store.reset());
+    }
+  });
+};
+let focusListenersAdded = false;
+const focusListeners = /* @__PURE__ */ new Set();
+const onWindowFocus = () => [...focusListeners].forEach((fn) => fn());
+let onlineListenersAdded = false;
+const onlineListeners$1 = /* @__PURE__ */ new Set();
+const onWindowOnline$1 = () => [...onlineListeners$1].forEach((fn) => fn());
+
+const INITIAL_STATE$1 = {
+  state: "INITIAL",
+  isPending: false,
+  isSuccess: false,
+  isError: false,
+  variable: void 0,
+  data: void 0,
+  dataUpdatedAt: void 0,
+  error: void 0,
+  errorUpdatedAt: void 0
+};
+const createMutation = (mutationFn, options = {}) => {
+  const { onSuccess = noop, onError, onSettled = noop } = options;
+  const initialState = { ...INITIAL_STATE$1 };
+  let ongoingPromise;
+  const resolveFns = /* @__PURE__ */ new Set([]);
+  const store = initStore(initialState, options);
+  const useStore = () => useStoreState(store);
+  const execute = (variable) => {
+    let currentResolveFn;
+    const stateBeforeExecute = store.getState();
+    if (stateBeforeExecute.isPending) {
+      console.warn(
+        "A mutation was executed while a previous execution is still pending. The previous execution will be ignored (latest execution wins)."
+      );
+    }
+    store.setState({ isPending: true });
+    const promise = new Promise((resolve) => {
+      currentResolveFn = resolve;
+      mutationFn(variable, stateBeforeExecute).then((data) => {
+        if (promise !== ongoingPromise) {
+          return resolve({ data, variable });
+        }
+        store.setState({
+          state: "SUCCESS",
+          isPending: false,
+          isSuccess: true,
+          isError: false,
+          variable,
+          data,
+          dataUpdatedAt: Date.now(),
+          error: void 0,
+          errorUpdatedAt: void 0
+        });
+        resolve({ data, variable });
+        resolveFns.clear();
+        onSuccess(data, variable, stateBeforeExecute);
+      }).catch((error) => {
+        if (promise !== ongoingPromise) {
+          return resolve({ error, variable });
+        }
+        store.setState({
+          state: "ERROR",
+          isPending: false,
+          isSuccess: false,
+          isError: true,
+          variable,
+          data: void 0,
+          dataUpdatedAt: void 0,
+          error,
+          errorUpdatedAt: Date.now()
+        });
+        resolve({ error, variable });
+        resolveFns.clear();
+        if (onError) onError(error, variable, stateBeforeExecute);
+        else console.error(store.getState());
+      }).finally(() => {
+        if (promise !== ongoingPromise) return;
+        onSettled(variable, stateBeforeExecute);
+        ongoingPromise = void 0;
+      });
+    });
+    if (ongoingPromise) resolveFns.forEach((resolveFn) => resolveFn(promise));
+    resolveFns.add(currentResolveFn);
+    ongoingPromise = promise;
+    return promise;
+  };
+  return Object.assign(useStore, {
+    subscribe: store.subscribe,
+    getSubscriberCount: store.getSubscriberCount,
+    getState: store.getState,
+    /**
+     * Manually updates the mutation state.
+     *
+     * @remarks
+     * - Intended for advanced use cases.
+     * - Prefer using provided mutation actions (`execute`, `reset`) instead.
+     */
+    setState: (value) => {
+      console.debug("Manual setState (not via provided actions) on mutation store");
+      store.setState(value);
+    },
+    /**
+     * Executes the mutation.
+     *
+     * @param variable - Input passed to the mutation function
+     *
+     * @returns A promise that always resolves with:
+     * - `{ data, variable }` on success
+     * - `{ error, variable }` on failure
+     *
+     * @remarks
+     * - The promise never rejects to simplify async handling.
+     * - If a mutation is already in progress, a warning is logged.
+     * - When a new execution starts, all previous pending executions will resolve with the result of the latest execution.
+     */
+    execute,
+    /**
+     * Resets the mutation state back to its initial state.
+     *
+     * @remarks
+     * - Does not cancel any ongoing execution.
+     * - If an execution is still pending, its result may override the reset state.
+     */
+    reset: () => {
+      if (store.getState().isPending) {
+        console.warn(
+          "Mutation state was reset while a request is still pending. The request will continue, but its result may override the reset state."
+        );
+      }
+      store.setState(initialState);
+    }
+  });
+};
+
+const useMutation = (mutationFn, options = {}) => {
+  const { onSuccess = noop, onError, onSettled = noop } = options;
+  const callbackRef = useRef({ onSuccess, onError, onSettled });
+  callbackRef.current.onSuccess = onSuccess;
+  callbackRef.current.onError = onError;
+  callbackRef.current.onSettled = onSettled;
+  const stateRef = useRef({ ...INITIAL_STATE$1 });
+  const [, reRender] = useState({});
+  const refs = useRef({
+    mutationFn,
+    ongoingPromise: void 0,
+    resolveFns: /* @__PURE__ */ new Set()
+  });
+  refs.current.mutationFn = mutationFn;
+  const execute = useCallback((variable) => {
+    let currentResolveFn;
+    const stateBeforeExecute = stateRef.current;
+    if (stateBeforeExecute.isPending) {
+      console.warn(
+        "A mutation was executed while a previous execution is still pending. The previous execution will be ignored (latest execution wins)."
+      );
+    }
+    stateRef.current.isPending = true;
+    reRender({});
+    const promise = new Promise(
+      (resolve) => {
+        currentResolveFn = resolve;
+        refs.current.mutationFn(variable, stateBeforeExecute).then((data) => {
+          if (promise !== refs.current.ongoingPromise) {
+            return resolve({ data, variable });
+          }
+          stateRef.current = {
+            state: "SUCCESS",
+            isPending: false,
+            isSuccess: true,
+            isError: false,
+            variable,
+            data,
+            dataUpdatedAt: Date.now(),
+            error: void 0,
+            errorUpdatedAt: void 0
+          };
+          reRender({});
+          resolve({ data, variable });
+          refs.current.resolveFns.clear();
+          callbackRef.current.onSuccess(data, variable, stateBeforeExecute);
+        }).catch((error) => {
+          if (promise !== refs.current.ongoingPromise) {
+            return resolve({ error, variable });
+          }
+          stateRef.current = {
+            state: "ERROR",
+            isPending: false,
+            isSuccess: false,
+            isError: true,
+            variable,
+            data: void 0,
+            dataUpdatedAt: void 0,
+            error,
+            errorUpdatedAt: Date.now()
+          };
+          reRender({});
+          resolve({ error, variable });
+          refs.current.resolveFns.clear();
+          if (callbackRef.current.onError) {
+            callbackRef.current.onError(error, variable, stateBeforeExecute);
+          } else {
+            console.error(stateRef.current);
+          }
+        }).finally(() => {
+          if (promise !== refs.current.ongoingPromise) return;
+          callbackRef.current.onSettled(variable, stateBeforeExecute);
+          refs.current.ongoingPromise = void 0;
+        });
+      }
+    );
+    if (refs.current.ongoingPromise) {
+      refs.current.resolveFns.forEach((resolveFn) => resolveFn(promise));
+    }
+    refs.current.resolveFns.add(currentResolveFn);
+    refs.current.ongoingPromise = promise;
+    return promise;
+  }, []);
+  const reset = useCallback(() => {
+    if (stateRef.current.isPending) {
+      console.warn(
+        "Mutation state was reset while a request is still pending. The request will continue, but its result may override the reset state."
+      );
+    }
+    stateRef.current = { ...INITIAL_STATE$1 };
+    reRender({});
+  }, []);
+  const r = [
+    stateRef.current,
+    {
+      execute,
+      reset,
+      getLatestState: () => stateRef.current
+    }
+  ];
+  return r;
+};
+
+const INITIAL_STATE = {
+  connectionState: "INITIAL",
+  connectingAt: void 0,
+  connectedAt: void 0,
+  disconnectedAt: void 0,
+  state: "INITIAL",
+  isSuccess: false,
+  isError: false,
+  data: void 0,
+  dataUpdatedAt: void 0,
+  error: void 0,
+  errorUpdatedAt: void 0
+};
+const createStream = (connect, disconnect, options = {}) => {
+  const {
+    disconnectOn = () => 5e3,
+    // 5 seconds after any `DisconnectTrigger`
+    reconnectOn = () => false
+    // no need reconnect if still connected
+  } = options.connection || {};
+  const {
+    gcTime = 5 * 60 * 1e3
+    // 5 minutes
+  } = options.data || {};
+  const initialState = { ...INITIAL_STATE };
+  const stores = /* @__PURE__ */ new Map();
+  const connections = /* @__PURE__ */ new WeakMap();
+  const disconnectFns = /* @__PURE__ */ new WeakMap();
+  const disconnectTimeoutIds = /* @__PURE__ */ new WeakMap();
+  const clearAllTimeouts = (store) => {
+    const gcTimeoutId = gcTimeoutIds.get(store);
+    if (gcTimeoutId) {
+      clearTimeout(gcTimeoutId);
+      gcTimeoutIds.delete(store);
+    }
+    const disconnectTimeoutIds_ = disconnectTimeoutIds.get(store);
+    if (disconnectTimeoutIds_) {
+      clearTimeout(disconnectTimeoutIds_["last-unsubscribe"]);
+      clearTimeout(disconnectTimeoutIds_["document-hidden"]);
+      clearTimeout(disconnectTimeoutIds_.offline);
+    }
+  };
+  const gcTimeoutIds = /* @__PURE__ */ new WeakMap();
+  const configureStoreEvents = () => ({
+    ...options,
+    onFirstSubscribe: (state, store) => {
+      var _a, _b;
+      clearTimeout((_a = disconnectTimeoutIds.get(store)) == null ? void 0 : _a["last-unsubscribe"]);
+      (_b = options.onFirstSubscribe) == null ? void 0 : _b.call(options, state, store);
+      triggerReconnect(store, "first-subscribe");
+      if (isClient) {
+        visibilityChangeListeners.add(triggers.visibilityChange);
+        onlineListeners.add(triggers.online);
+        offlineListeners.add(triggers.offline);
+        if (!listenersAdded) {
+          document.addEventListener("visibilitychange", onVisibilityChange);
+          window.addEventListener("online", onWindowOnline);
+          window.addEventListener("offline", onWindowOffline);
+          listenersAdded = true;
+        }
+      }
+    },
+    onLastUnsubscribe: (state, store) => {
+      var _a;
+      (_a = options.onLastUnsubscribe) == null ? void 0 : _a.call(options, state, store);
+      triggerDisconnect(store, "last-unsubscribe");
+      if (isClient) {
+        visibilityChangeListeners.delete(triggers.visibilityChange);
+        onlineListeners.delete(triggers.online);
+        offlineListeners.delete(triggers.offline);
+        if (visibilityChangeListeners.size === 0) {
+          document.removeEventListener("visibilitychange", onVisibilityChange);
+          window.removeEventListener("online", onWindowOnline);
+          window.removeEventListener("offline", onWindowOffline);
+          listenersAdded = false;
+        }
+      }
+    }
+  });
+  const disconnectAndSetState = (store, showLog = false) => {
+    var _a;
+    if (store.getSubscriberCount() && showLog) {
+      console.log("Stream disconnected while there is subscriber");
+    }
+    clearAllTimeouts(store);
+    (_a = disconnectFns.get(store)) == null ? void 0 : _a();
+    if (store.getState().connectionState !== "INITIAL") {
+      store.setState({
+        connectionState: "DISCONNECTED",
+        disconnectedAt: Date.now()
+      });
+    }
+    connections.delete(store);
+    disconnectFns.delete(store);
+    gcTimeoutIds.set(
+      store,
+      setTimeout(() => {
+        if (store.getSubscriberCount() === 0) store.delete();
+      }, gcTime)
+    );
+  };
+  const getStore = (variable = {}) => {
+    const variableHash = getHash(variable);
+    let store;
+    if (stores.has(variableHash)) {
+      store = stores.get(variableHash);
+    } else {
+      store = initStore(
+        initialState,
+        configureStoreEvents()
+        // Intentionally using as any: don't want to add generic on `initStore`
+      );
+      store.variableHash = variableHash;
+      stores.set(variableHash, store);
+      store.connection = {};
+      store.connection.get = () => connections.get(store);
+      store.connection.reconnect = () => {
+        clearAllTimeouts(store);
+        const { connectionState } = store.getState();
+        if (connectionState === "CONNECTING") return;
+        const prevDisconnect = disconnectFns.get(store);
+        if (prevDisconnect) {
+          prevDisconnect();
+          disconnectFns.delete(store);
+        }
+        store.setState({
+          connectionState: "CONNECTING",
+          connectingAt: Date.now(),
+          connectedAt: void 0,
+          disconnectedAt: void 0
+        });
+        const connection = connect(variable, {
+          connected: () => {
+            store.setState({
+              connectionState: "CONNECTED",
+              connectedAt: Date.now(),
+              disconnectedAt: void 0
+            });
+          },
+          data: (reducer) => {
+            store.setState((prev) => {
+              var _a;
+              return {
+                connectionState: "CONNECTED",
+                connectedAt: (_a = prev.connectedAt) != null ? _a : Date.now(),
+                state: "SUCCESS",
+                isSuccess: true,
+                isError: false,
+                data: reducer(prev.data),
+                dataUpdatedAt: Date.now(),
+                error: void 0,
+                errorUpdatedAt: void 0
+              };
+            });
+          },
+          error: (error) => {
+            store.setState((prev) => ({
+              state: prev.state === "SUCCESS" ? "SUCCESS_BUT_THEN_ERROR" : "ERROR",
+              isError: true,
+              error,
+              errorUpdatedAt: Date.now()
+            }));
+          }
+        });
+        connections.set(store, connection);
+        disconnectFns.set(store, () => disconnect(connection));
+      };
+      store.connection.disconnect = () => disconnectAndSetState(store, true);
+      store.data = {};
+      store.data.reset = () => {
+        store.setState({
+          state: "INITIAL",
+          isSuccess: false,
+          isError: false,
+          data: void 0,
+          dataUpdatedAt: void 0,
+          error: void 0,
+          errorUpdatedAt: void 0
+        });
+      };
+      store.delete = () => {
+        if (store.getSubscriberCount() > 0) {
+          console.warn(
+            "Cannot delete store while it still has active subscribers. Unsubscribe all listeners before deleting the store."
+          );
+          return false;
+        }
+        clearAllTimeouts(store);
+        store.setState(initialState);
+        return stores.delete(variableHash);
+      };
+    }
+    const useStore = (options2) => useStoreState(store, {
+      initialState: { data: options2 == null ? void 0 : options2.initialData }
+    });
+    return Object.assign(useStore, {
+      ...store,
+      setState: (value) => {
+        console.debug("Manual setState (not via provided actions) on stream store");
+        store.setState(value);
+      }
+    });
+  };
+  const triggerReconnect = (store, trigger) => {
+    clearAllTimeouts(store);
+    const { connectionState } = store.getState();
+    if (connectionState === "INITIAL" || connectionState === "DISCONNECTED") {
+      queueMicrotask(() => {
+        store.connection.reconnect();
+      });
+      return;
+    }
+    const shouldReconnect = reconnectOn(trigger, store.getState());
+    if (shouldReconnect) store.connection.reconnect();
+  };
+  const triggerDisconnect = (store, trigger) => {
+    const disconnectDelay = disconnectOn(trigger, store.getState());
+    if (typeof disconnectDelay !== "number") return;
+    if (!disconnectTimeoutIds.has(store)) disconnectTimeoutIds.set(store, {});
+    const disconnectTimeoutIds_ = disconnectTimeoutIds.get(store);
+    disconnectTimeoutIds_[trigger] = setTimeout(() => {
+      disconnectAndSetState(store);
+    }, disconnectDelay);
+  };
+  const triggers = {
+    visibilityChange: () => {
+      console.info("visibilityChange", document.visibilityState);
+      if (document.visibilityState === "visible") {
+        stores.forEach((store) => triggerReconnect(store, "document-visible"));
+      } else {
+        stores.forEach((store) => triggerDisconnect(store, "document-hidden"));
+      }
+    },
+    online: () => stores.forEach((store) => triggerReconnect(store, "online")),
+    offline: () => stores.forEach((store) => triggerDisconnect(store, "offline"))
+  };
+  return getStore;
+};
+const visibilityChangeListeners = /* @__PURE__ */ new Set();
+const onVisibilityChange = () => [...visibilityChangeListeners].forEach((fn) => fn());
+const onlineListeners = /* @__PURE__ */ new Set();
+const onWindowOnline = () => [...onlineListeners].forEach((fn) => fn());
+const offlineListeners = /* @__PURE__ */ new Set();
+const onWindowOffline = () => [...offlineListeners].forEach((fn) => fn());
+let listenersAdded = false;
+
+export { createMutation, createQuery, createStore, createStores, createStream, useIsomorphicLayoutEffect, useMutation, useStoreState };