floppy-disk 3.6.1 → 3.7.0-beta.2

package/react.js

@@ -104,11 +104,7 @@ const createStores = (initialState, options) => {
       store.key = key;
       store.keyHash = keyHash;
       stores.set(keyHash, store);
-    }
-    const useStore = (options2) => useStoreState(store, options2);
-    return Object.assign(useStore, {
-      ...store,
-      delete: () => {
+      store.delete = () => {
         if (store.getSubscriberCount() > 0) {
           console.warn(
             "Cannot delete store while it still has active subscribers. Unsubscribe all listeners before deleting the store."
@@ -117,13 +113,15 @@ const createStores = (initialState, options) => {
         }
         store.setState(initialState);
         return stores.delete(keyHash);
-      }
-    });
+      };
+    }
+    const useStore = (options2) => useStoreState(store, options2);
+    return Object.assign(useStore, store);
   };
   return getStore;
 };
 
-const INITIAL_STATE$1 = {
+const INITIAL_STATE$2 = {
   isPending: false,
   isRevalidating: false,
   willRetryAt: void 0,
@@ -151,15 +149,15 @@ const createQuery = (queryFn, options = {}) => {
     onSettled = vanilla.noop,
     shouldRetry: shouldRetryFn = (_, s) => s.retryCount === 0 ? [true, 1500] : [false]
   } = options;
-  const initialState = { ...INITIAL_STATE$1 };
+  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 { metadata, revalidate: revalidate2 } = internals.get(store);
-      clearTimeout(metadata.garbageCollectionTimeoutId);
+      const { internal, revalidate: revalidate2 } = store;
+      clearTimeout(internal.garbageCollectionTimeoutId);
       if (vanilla.isClient) {
         if (revalidateOnFocus) {
           focusListeners.add(revalidate2);
@@ -169,9 +167,9 @@ const createQuery = (queryFn, options = {}) => {
           }
         }
         if (revalidateOnReconnect) {
-          onlineListeners.add(revalidate2);
+          onlineListeners$1.add(revalidate2);
           if (!onlineListenersAdded) {
-            window.addEventListener("online", onWindowOnline);
+            window.addEventListener("online", onWindowOnline$1);
             onlineListenersAdded = true;
           }
         }
@@ -180,15 +178,15 @@ const createQuery = (queryFn, options = {}) => {
     onLastUnsubscribe: (state, store) => {
       var _a;
       (_a = options.onLastUnsubscribe) == null ? void 0 : _a.call(options, state, store);
-      const { metadata, revalidate: revalidate2 } = internals.get(store);
-      clearTimeout(metadata.retryTimeoutId);
-      if (metadata.retryResolver) {
+      const { internal, revalidate: revalidate2 } = store;
+      clearTimeout(internal.retryTimeoutId);
+      if (internal.retryResolver) {
         store.setState({ willRetryAt: void 0 });
-        metadata.retryResolver(store.getState());
-        metadata.retryResolver = void 0;
+        internal.retryResolver(store.getState());
+        internal.retryResolver = void 0;
       }
-      metadata.garbageCollectionTimeoutId = setTimeout(() => {
-        if (metadata.promiseResolver || metadata.retryResolver) {
+      internal.garbageCollectionTimeoutId = setTimeout(() => {
+        if (internal.promiseResolver || internal.retryResolver) {
           store.setState(initialState);
         } else {
           stores.delete(variableHash);
@@ -203,23 +201,22 @@ const createQuery = (queryFn, options = {}) => {
           }
         }
         if (revalidateOnReconnect) {
-          onlineListeners.delete(revalidate2);
-          if (onlineListeners.size === 0) {
-            window.removeEventListener("online", onWindowOnline);
+          onlineListeners$1.delete(revalidate2);
+          if (onlineListeners$1.size === 0) {
+            window.removeEventListener("online", onWindowOnline$1);
             onlineListenersAdded = false;
           }
         }
       }
     }
   });
-  const internals = /* @__PURE__ */ new WeakMap();
-  const configureInternals = (store, variable) => ({
-    metadata: {},
+  const getApis = (store, variable) => ({
+    internal: {},
     setInitialData: (data, revalidate2 = false) => {
       const state = store.getState();
       if (state.state === "INITIAL" && state.data === void 0) {
-        const { metadata } = internals.get(store);
-        if (revalidate2) metadata.isInvalidated = true;
+        const { internal } = store;
+        if (revalidate2) internal.isInvalidated = true;
         store.setState({
           state: "SUCCESS",
           isSuccess: true,
@@ -237,28 +234,28 @@ const createQuery = (queryFn, options = {}) => {
       return revalidate(store, variable, overwriteOngoingExecution);
     },
     invalidate: (options2) => {
-      const { metadata } = internals.get(store);
-      metadata.isInvalidated = true;
+      const { internal } = store;
+      internal.isInvalidated = true;
       if (store.getSubscriberCount() > 0) {
-        internals.get(store).execute(options2);
+        store.execute(options2);
         return true;
       }
       return false;
     },
     reset: () => {
       var _a, _b;
-      const { metadata } = internals.get(store);
-      clearTimeout(metadata.retryTimeoutId);
-      if (metadata.retryResolver || metadata.promiseResolver) {
+      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 = metadata.promiseResolver) == null ? void 0 : _a.call(metadata, initialState);
-        (_b = metadata.retryResolver) == null ? void 0 : _b.call(metadata, initialState);
-        metadata.promiseResolver = void 0;
-        metadata.retryResolver = void 0;
+        (_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;
       }
-      metadata.promise = void 0;
+      internal.promise = void 0;
       store.setState(initialState);
     },
     delete: () => {
@@ -268,35 +265,36 @@ const createQuery = (queryFn, options = {}) => {
         );
         return false;
       }
-      internals.get(store).reset();
+      store.reset();
       return stores.delete(store.variableHash);
     },
     optimisticUpdate: (optimisticData) => {
-      const { metadata, revalidate: revalidate2, rollbackOptimisticUpdate } = internals.get(store);
-      metadata.rollbackData = store.getState().data;
+      const { internal, revalidate: revalidate2, rollbackOptimisticUpdate } = store;
+      internal.rollbackData = store.getState().data;
       store.setState({ data: optimisticData });
       return { revalidate: revalidate2, rollback: rollbackOptimisticUpdate };
     },
     rollbackOptimisticUpdate: () => {
-      const { metadata } = internals.get(store);
-      store.setState({ data: metadata.rollbackData });
-      return metadata.rollbackData;
+      const { internal } = store;
+      store.setState({ data: internal.rollbackData });
+      return internal.rollbackData;
     }
   });
   const execute = async (store, variable, overwriteOngoingExecution = false) => {
-    const { metadata } = internals.get(store);
-    if (!overwriteOngoingExecution && metadata.promise) return metadata.promise;
-    clearTimeout(metadata.retryTimeoutId);
+    const { internal: _internal } = store;
+    const internal = _internal;
+    if (!overwriteOngoingExecution && internal.promise) return internal.promise;
+    clearTimeout(internal.retryTimeoutId);
     const createPromise = () => {
       const promise = new Promise((resolve) => {
-        metadata.promiseResolver = resolve;
+        internal.promiseResolver = resolve;
         const stateBeforeExecute = store.getState();
         store.setState({
           isPending: true,
           isRevalidating: stateBeforeExecute.state === "SUCCESS",
           willRetryAt: void 0,
-          isRetrying: !!metadata.retryResolver,
-          retryCount: metadata.retryResolver ? stateBeforeExecute.retryCount + 1 : 0
+          isRetrying: !!internal.retryResolver,
+          retryCount: internal.retryResolver ? stateBeforeExecute.retryCount + 1 : 0
         });
         queryFn(variable, stateBeforeExecute, store.variableHash).then((data) => {
           var _a;
@@ -305,8 +303,8 @@ const createQuery = (queryFn, options = {}) => {
               "Query function returned undefined. Successful responses must not be undefined."
             );
           }
-          if (!metadata.promiseResolver) return;
-          if (promise !== metadata.promise) return resolve(metadata.promise);
+          if (!internal.promiseResolver) return;
+          if (promise !== internal.promise) return resolve(internal.promise);
           const now = Date.now();
           store.setState({
             isPending: false,
@@ -322,17 +320,17 @@ const createQuery = (queryFn, options = {}) => {
             error: void 0,
             errorUpdatedAt: void 0
           });
-          metadata.isInvalidated = false;
-          metadata.rollbackData = data;
+          internal.isInvalidated = false;
+          internal.rollbackData = data;
           resolve(store.getState());
-          (_a = metadata.retryResolver) == null ? void 0 : _a.call(metadata, store.getState());
-          metadata.retryResolver = void 0;
+          (_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 (!metadata.promiseResolver && !metadata.retryResolver) return;
-          if (promise !== metadata.promise) return resolve(metadata.promise);
+          if (!internal.promiseResolver && !internal.retryResolver) return;
+          if (promise !== internal.promise) return resolve(internal.promise);
           const nextState = {
             ...store.getState(),
             isPending: false,
@@ -342,8 +340,8 @@ const createQuery = (queryFn, options = {}) => {
           const [shouldRetry, retryDelay] = shouldRetryFn(error, nextState);
           const hasSubscriber = store.getSubscriberCount() > 0;
           if (shouldRetry && hasSubscriber) {
-            metadata.retryResolver = resolve;
-            metadata.retryTimeoutId = setTimeout(createPromise, retryDelay);
+            internal.retryResolver = resolve;
+            internal.retryTimeoutId = setTimeout(createPromise, retryDelay);
             store.setState({
               isPending: false,
               isRevalidating: false,
@@ -356,43 +354,38 @@ const createQuery = (queryFn, options = {}) => {
               isRevalidating: false,
               isRetrying: false,
               retryCount: 0,
+              state: store.getState().state === "SUCCESS" ? "SUCCESS_BUT_REVALIDATION_ERROR" : "ERROR",
+              isError: true,
               error,
-              errorUpdatedAt: Date.now(),
-              ...store.getState().data ? {
-                state: "SUCCESS_BUT_REVALIDATION_ERROR",
-                isError: false
-              } : {
-                state: "ERROR",
-                isError: true
-              }
+              errorUpdatedAt: Date.now()
             });
             const state = store.getState();
             resolve(state);
-            (_a = metadata.retryResolver) == null ? void 0 : _a.call(metadata, state);
-            metadata.retryResolver = void 0;
+            (_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 (metadata.promise === promise) {
-            metadata.promise = void 0;
-            metadata.promiseResolver = void 0;
+          if (internal.promise === promise) {
+            internal.promise = void 0;
+            internal.promiseResolver = void 0;
           }
         });
       });
-      metadata.promise = promise;
+      internal.promise = promise;
       return promise;
     };
     return createPromise();
   };
   const revalidate = async (store, variable, overwriteOngoingExecution) => {
-    const { metadata } = internals.get(store);
-    if (!overwriteOngoingExecution && metadata.promise) return metadata.promise;
+    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 && !metadata.isInvalidated) return state;
+      if (isFresh && !internal.isInvalidated) return state;
     }
     return execute(store, variable, overwriteOngoingExecution);
   };
@@ -409,7 +402,16 @@ const createQuery = (queryFn, options = {}) => {
       );
       store.variableHash = variableHash;
       stores.set(variableHash, store);
-      internals.set(store, configureInternals(store, variable));
+      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 {
@@ -477,15 +479,11 @@ const createQuery = (queryFn, options = {}) => {
       return trackedState;
     };
     return Object.assign(useStore, {
-      subscribe: store.subscribe,
-      getSubscriberCount: store.getSubscriberCount,
-      getState: store.getState,
+      ...store,
       setState: (value) => {
         console.debug("Manual setState (not via provided actions) on query store");
         store.setState(value);
-      },
-      ...internals.get(store),
-      variableHash
+      }
     });
   };
   return Object.assign(getStore, {
@@ -496,7 +494,7 @@ const createQuery = (queryFn, options = {}) => {
      * - Useful for bulk refetching.
      */
     executeAll: (options2) => {
-      stores.forEach((store) => internals.get(store).execute(options2));
+      stores.forEach((store) => store.execute(options2));
     },
     /**
      * Revalidates all query instances.
@@ -505,7 +503,7 @@ const createQuery = (queryFn, options = {}) => {
      * - Only re-fetches stale queries.
      */
     revalidateAll: (options2) => {
-      stores.forEach((store) => internals.get(store).revalidate(options2));
+      stores.forEach((store) => store.revalidate(options2));
     },
     /**
      * Invalidates all query instances.
@@ -515,13 +513,13 @@ const createQuery = (queryFn, options = {}) => {
      * - Invalidated queries bypass `staleTime` until successfully executed again.
      */
     invalidateAll: (options2) => {
-      stores.forEach((store) => internals.get(store).invalidate(options2));
+      stores.forEach((store) => store.invalidate(options2));
     },
     /**
      * Resets all query instances.
      */
     resetAll: () => {
-      stores.forEach((store) => internals.get(store).reset());
+      stores.forEach((store) => store.reset());
     }
   });
 };
@@ -529,10 +527,10 @@ let focusListenersAdded = false;
 const focusListeners = /* @__PURE__ */ new Set();
 const onWindowFocus = () => [...focusListeners].forEach((fn) => fn());
 let onlineListenersAdded = false;
-const onlineListeners = /* @__PURE__ */ new Set();
-const onWindowOnline = () => [...onlineListeners].forEach((fn) => fn());
+const onlineListeners$1 = /* @__PURE__ */ new Set();
+const onWindowOnline$1 = () => [...onlineListeners$1].forEach((fn) => fn());
 
-const INITIAL_STATE = {
+const INITIAL_STATE$1 = {
   state: "INITIAL",
   isPending: false,
   isSuccess: false,
@@ -545,7 +543,7 @@ const INITIAL_STATE = {
 };
 const createMutation = (mutationFn, options = {}) => {
   const { onSuccess = vanilla.noop, onError, onSettled = vanilla.noop } = options;
-  const initialState = { ...INITIAL_STATE };
+  const initialState = { ...INITIAL_STATE$1 };
   let ongoingPromise;
   const resolveFns = /* @__PURE__ */ new Set([]);
   const store = vanilla.initStore(initialState, options);
@@ -663,7 +661,7 @@ const useMutation = (mutationFn, options = {}) => {
   callbackRef.current.onSuccess = onSuccess;
   callbackRef.current.onError = onError;
   callbackRef.current.onSettled = onSettled;
-  const stateRef = react.useRef({ ...INITIAL_STATE });
+  const stateRef = react.useRef({ ...INITIAL_STATE$1 });
   const [, reRender] = react.useState({});
   const refs = react.useRef({
     mutationFn,
@@ -746,7 +744,7 @@ const useMutation = (mutationFn, options = {}) => {
         "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 };
+    stateRef.current = { ...INITIAL_STATE$1 };
     reRender({});
   }, []);
   const r = [
@@ -760,10 +758,230 @@ const useMutation = (mutationFn, options = {}) => {
   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 experimental_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 clearDataTimeoutIds = /* @__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 (vanilla.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 (vanilla.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 getStore = (variable = {}) => {
+    const variableHash = vanilla.getHash(variable);
+    let store;
+    if (stores.has(variableHash)) {
+      store = stores.get(variableHash);
+    } else {
+      store = vanilla.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 = () => {
+        var _a;
+        const { connectionState } = store.getState();
+        if (connectionState === "CONNECTING") return;
+        (_a = disconnectFns.get(store)) == null ? void 0 : _a();
+        store.setState({
+          connectionState: "CONNECTING",
+          connectingAt: Date.now()
+        });
+        const connection = connect(variable, {
+          connected: () => {
+            store.setState({
+              connectionState: "CONNECTED",
+              connectedAt: Date.now(),
+              disconnectedAt: void 0
+            });
+          },
+          data: (reducer) => {
+            store.setState((prev) => {
+              var _a2;
+              return {
+                connectionState: "CONNECTED",
+                connectedAt: (_a2 = prev.connectedAt) != null ? _a2 : 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 = () => {
+        var _a;
+        if (store.getSubscriberCount()) {
+          console.warn("Stream disconnected while there is subscriber");
+        }
+        const disconnectTimeoutIds_ = disconnectTimeoutIds.get(store);
+        if (disconnectTimeoutIds_) {
+          clearTimeout(disconnectTimeoutIds_["last-unsubscribe"]);
+          clearTimeout(disconnectTimeoutIds_["document-hidden"]);
+          clearTimeout(disconnectTimeoutIds_.offline);
+        }
+        (_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);
+        clearDataTimeoutIds.set(
+          store,
+          setTimeout(() => {
+            store.data.reset();
+          }, gcTime)
+        );
+      };
+      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
+        });
+      };
+    }
+    const useStore = (options2) => useStoreState(store, {
+      initialState: { data: options2 == null ? void 0 : options2.initialData }
+    });
+    return Object.assign(useStore, store);
+  };
+  const triggerReconnect = (store, trigger) => {
+    clearTimeout(clearDataTimeoutIds.get(store));
+    const disconnectTimeoutIds_ = disconnectTimeoutIds.get(store);
+    if (disconnectTimeoutIds_) {
+      clearTimeout(disconnectTimeoutIds_["last-unsubscribe"]);
+      clearTimeout(disconnectTimeoutIds_["document-hidden"]);
+      clearTimeout(disconnectTimeoutIds_.offline);
+    }
+    const { connectionState } = store.getState();
+    console.info("triggerReconnect", connectionState);
+    if (connectionState === "INITIAL" || connectionState === "DISCONNECTED") {
+      return store.connection.reconnect();
+    }
+    const shouldReconnect = reconnectOn(trigger, store.getState());
+    console.log({ shouldReconnect });
+    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(() => {
+      store.connection.disconnect();
+    }, 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;
+
 exports.createMutation = createMutation;
 exports.createQuery = createQuery;
 exports.createStore = createStore;
 exports.createStores = createStores;
+exports.experimental_createStream = experimental_createStream;
 exports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;
 exports.useMutation = useMutation;
 exports.useStoreState = useStoreState;