floppy-disk 3.7.0-beta.1 → 3.7.0-beta.2

package/esm/react/create-query.d.mts

@@ -56,7 +56,7 @@ export type QueryState<TData, TError> = {
 } | {
     state: "SUCCESS_BUT_REVALIDATION_ERROR";
     isSuccess: true;
-    isError: false;
+    isError: true;
     data: TData;
     dataUpdatedAt: number;
     dataStaleAt: undefined | number;

package/esm/react/create-stream.d.mts

@@ -0,0 +1,88 @@
+import { type InitStoreOptions, type StoreApi } from "../vanilla.mjs";
+import type { StoreKey } from "./create-stores.mjs";
+type StreamDataState<TData, TError> = {
+    state: "INITIAL";
+    isSuccess: false;
+    isError: false;
+    data: undefined;
+    dataUpdatedAt: undefined;
+    error: undefined;
+    errorUpdatedAt: undefined;
+} | {
+    state: "SUCCESS";
+    isSuccess: true;
+    isError: false;
+    data: TData;
+    dataUpdatedAt: number;
+    error: undefined;
+    errorUpdatedAt: undefined;
+} | {
+    state: "ERROR";
+    isSuccess: false;
+    isError: true;
+    data: undefined;
+    dataUpdatedAt: undefined;
+    error: TError;
+    errorUpdatedAt: number;
+} | {
+    state: "SUCCESS_BUT_THEN_ERROR";
+    isSuccess: true;
+    isError: true;
+    data: TData;
+    dataUpdatedAt: number;
+    error: TError;
+    errorUpdatedAt: number;
+};
+export type StreamState<TData, TError> = ({
+    connectionState: "INITIAL";
+    connectingAt: undefined;
+    connectedAt: undefined;
+    disconnectedAt: undefined;
+} & Extract<StreamDataState<TData, TError>, {
+    state: "INITIAL";
+}>) | ({
+    connectionState: "CONNECTING";
+    connectingAt: number;
+    connectedAt: number | undefined;
+    disconnectedAt: number | undefined;
+} & StreamDataState<TData, TError>) | ({
+    connectionState: "CONNECTED";
+    connectingAt: number;
+    connectedAt: number;
+    disconnectedAt: undefined;
+} & StreamDataState<TData, TError>) | ({
+    connectionState: "DISCONNECTED";
+    connectingAt: number;
+    connectedAt: number | undefined;
+    disconnectedAt: number;
+} & StreamDataState<TData, TError>);
+type DisconnectTrigger = "last-unsubscribe" | "document-hidden" | "offline";
+type ReconnectTrigger = "first-subscribe" | "document-visible" | "online";
+type AdditionalStoreApi<TConnection> = {
+    variableHash: string;
+    connection: {
+        get: () => Readonly<TConnection> | undefined;
+        reconnect: () => void;
+        disconnect: () => void;
+    };
+    data: {
+        reset: () => void;
+    };
+};
+export type StreamOptions<TConnection, TData, TError = Error> = InitStoreOptions<StreamState<TData, TError>, AdditionalStoreApi<TConnection>> & {
+    connection?: {
+        disconnectOn?: (trigger: DisconnectTrigger, state: StreamState<TData, TError>) => false | number;
+        reconnectOn?: (trigger: ReconnectTrigger, state: StreamState<TData, TError>) => boolean;
+    };
+    data?: {
+        gcTime?: number;
+    };
+};
+export declare const experimental_createStream: <TConnection, TData, TVariable extends StoreKey, TError = Error>(connect: (variable: TVariable, emit: {
+    connected: () => void;
+    data: (reducer: (data: TData | undefined) => TData) => void;
+    error: (error: TError) => void;
+}) => TConnection, disconnect: (connection: TConnection) => void, options?: StreamOptions<TConnection, TData, TError>) => (variable?: TVariable) => ((options?: {
+    initialData?: TData;
+}) => StreamState<TData, TError>) & StoreApi<StreamState<TData, TError>> & AdditionalStoreApi<TConnection>;
+export {};

package/esm/react.d.mts

@@ -5,3 +5,4 @@ export * from "./react/create-stores.mjs";
 export * from "./react/create-query.mjs";
 export { createMutation, type MutationOptions, type MutationState, } from "./react/create-mutation.mjs";
 export * from "./react/use-mutation.mjs";
+export * from "./react/create-stream.mjs";

package/esm/react.mjs

@@ -119,7 +119,7 @@ const createStores = (initialState, options) => {
   return getStore;
 };
 
-const INITIAL_STATE$1 = {
+const INITIAL_STATE$2 = {
   isPending: false,
   isRevalidating: false,
   willRetryAt: void 0,
@@ -147,7 +147,7 @@ const createQuery = (queryFn, options = {}) => {
     onSettled = 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,
@@ -165,9 +165,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;
           }
         }
@@ -199,9 +199,9 @@ 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;
           }
         }
@@ -352,15 +352,10 @@ 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);
@@ -530,10 +525,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,
@@ -546,7 +541,7 @@ const INITIAL_STATE = {
 };
 const createMutation = (mutationFn, options = {}) => {
   const { onSuccess = noop, onError, onSettled = noop } = options;
-  const initialState = { ...INITIAL_STATE };
+  const initialState = { ...INITIAL_STATE$1 };
   let ongoingPromise;
   const resolveFns = /* @__PURE__ */ new Set([]);
   const store = initStore(initialState, options);
@@ -664,7 +659,7 @@ const useMutation = (mutationFn, options = {}) => {
   callbackRef.current.onSuccess = onSuccess;
   callbackRef.current.onError = onError;
   callbackRef.current.onSettled = onSettled;
-  const stateRef = useRef({ ...INITIAL_STATE });
+  const stateRef = useRef({ ...INITIAL_STATE$1 });
   const [, reRender] = useState({});
   const refs = useRef({
     mutationFn,
@@ -747,7 +742,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 = [
@@ -761,4 +756,223 @@ const useMutation = (mutationFn, options = {}) => {
   return r;
 };
 
-export { createMutation, createQuery, createStore, createStores, useIsomorphicLayoutEffect, useMutation, useStoreState };
+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 (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 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 = () => {
+        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;
+
+export { createMutation, createQuery, createStore, createStores, experimental_createStream, useIsomorphicLayoutEffect, useMutation, useStoreState };

package/package.json

@@ -2,7 +2,10 @@
   "name": "floppy-disk",
   "description": "Lightweight unified state management for sync and async data.",
   "private": false,
-  "version": "3.7.0-beta.1",
+  "version": "3.7.0-beta.2",
+  "publishConfig": {
+    "tag": "beta"
+  },
   "keywords": [
     "utilities",
     "store",

package/react/create-query.d.ts

@@ -56,7 +56,7 @@ export type QueryState<TData, TError> = {
 } | {
     state: "SUCCESS_BUT_REVALIDATION_ERROR";
     isSuccess: true;
-    isError: false;
+    isError: true;
     data: TData;
     dataUpdatedAt: number;
     dataStaleAt: undefined | number;

package/react/create-stream.d.ts

@@ -0,0 +1,88 @@
+import { type InitStoreOptions, type StoreApi } from "../vanilla.ts";
+import type { StoreKey } from "./create-stores.ts";
+type StreamDataState<TData, TError> = {
+    state: "INITIAL";
+    isSuccess: false;
+    isError: false;
+    data: undefined;
+    dataUpdatedAt: undefined;
+    error: undefined;
+    errorUpdatedAt: undefined;
+} | {
+    state: "SUCCESS";
+    isSuccess: true;
+    isError: false;
+    data: TData;
+    dataUpdatedAt: number;
+    error: undefined;
+    errorUpdatedAt: undefined;
+} | {
+    state: "ERROR";
+    isSuccess: false;
+    isError: true;
+    data: undefined;
+    dataUpdatedAt: undefined;
+    error: TError;
+    errorUpdatedAt: number;
+} | {
+    state: "SUCCESS_BUT_THEN_ERROR";
+    isSuccess: true;
+    isError: true;
+    data: TData;
+    dataUpdatedAt: number;
+    error: TError;
+    errorUpdatedAt: number;
+};
+export type StreamState<TData, TError> = ({
+    connectionState: "INITIAL";
+    connectingAt: undefined;
+    connectedAt: undefined;
+    disconnectedAt: undefined;
+} & Extract<StreamDataState<TData, TError>, {
+    state: "INITIAL";
+}>) | ({
+    connectionState: "CONNECTING";
+    connectingAt: number;
+    connectedAt: number | undefined;
+    disconnectedAt: number | undefined;
+} & StreamDataState<TData, TError>) | ({
+    connectionState: "CONNECTED";
+    connectingAt: number;
+    connectedAt: number;
+    disconnectedAt: undefined;
+} & StreamDataState<TData, TError>) | ({
+    connectionState: "DISCONNECTED";
+    connectingAt: number;
+    connectedAt: number | undefined;
+    disconnectedAt: number;
+} & StreamDataState<TData, TError>);
+type DisconnectTrigger = "last-unsubscribe" | "document-hidden" | "offline";
+type ReconnectTrigger = "first-subscribe" | "document-visible" | "online";
+type AdditionalStoreApi<TConnection> = {
+    variableHash: string;
+    connection: {
+        get: () => Readonly<TConnection> | undefined;
+        reconnect: () => void;
+        disconnect: () => void;
+    };
+    data: {
+        reset: () => void;
+    };
+};
+export type StreamOptions<TConnection, TData, TError = Error> = InitStoreOptions<StreamState<TData, TError>, AdditionalStoreApi<TConnection>> & {
+    connection?: {
+        disconnectOn?: (trigger: DisconnectTrigger, state: StreamState<TData, TError>) => false | number;
+        reconnectOn?: (trigger: ReconnectTrigger, state: StreamState<TData, TError>) => boolean;
+    };
+    data?: {
+        gcTime?: number;
+    };
+};
+export declare const experimental_createStream: <TConnection, TData, TVariable extends StoreKey, TError = Error>(connect: (variable: TVariable, emit: {
+    connected: () => void;
+    data: (reducer: (data: TData | undefined) => TData) => void;
+    error: (error: TError) => void;
+}) => TConnection, disconnect: (connection: TConnection) => void, options?: StreamOptions<TConnection, TData, TError>) => (variable?: TVariable) => ((options?: {
+    initialData?: TData;
+}) => StreamState<TData, TError>) & StoreApi<StreamState<TData, TError>> & AdditionalStoreApi<TConnection>;
+export {};

package/react.d.ts

@@ -5,3 +5,4 @@ export * from "./react/create-stores.ts";
 export * from "./react/create-query.ts";
 export { createMutation, type MutationOptions, type MutationState, } from "./react/create-mutation.ts";
 export * from "./react/use-mutation.ts";
+export * from "./react/create-stream.ts";

package/react.js

@@ -121,7 +121,7 @@ const createStores = (initialState, options) => {
   return getStore;
 };
 
-const INITIAL_STATE$1 = {
+const INITIAL_STATE$2 = {
   isPending: false,
   isRevalidating: false,
   willRetryAt: void 0,
@@ -149,7 +149,7 @@ 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,
@@ -167,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;
           }
         }
@@ -201,9 +201,9 @@ 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;
           }
         }
@@ -354,15 +354,10 @@ 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);
@@ -532,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,
@@ -548,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);
@@ -666,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,
@@ -749,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 = [
@@ -763,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;