@wow-two-beta/ui-vue 0.0.2

package/dist/foundation/net/index.js

@@ -0,0 +1,840 @@
+import { JitterStrategy, BackoffStrategy, shouldRetry, computeRetryDelay } from "../resilience/index.js";
+import { t as toError } from "../../chunks/ToError-CyTBsmLO.js";
+import { shallowRef, toValue, onMounted, watch, onScopeDispose } from "vue";
+const ConnectionState = {
+  /** Refers to a first connection attempt in flight — nothing has been established yet. */
+  Connecting: "connecting",
+  /** Refers to an established connection that is passing traffic. */
+  Open: "open",
+  /** Refers to a dropped connection with a retry pending or in flight — the distinction the wire ready-state cannot express. */
+  Reconnecting: "reconnecting",
+  /** Refers to a connection that is down and not coming back — closed by the caller, unsupported, or out of retries. */
+  Closed: "closed"
+};
+const EventSourceReadyState = {
+  /** Refers to the connection being established — including the browser's OWN automatic reconnection. */
+  Connecting: 0,
+  /** Refers to an open, streaming connection. */
+  Open: 1,
+  /** Refers to a connection the browser will not retry: a fatal error, or an explicit `close()`. */
+  Closed: 2
+};
+const SocketReadyState = {
+  /** Refers to a handshake in progress; `send()` throws here, which is why this slice queues instead. */
+  Connecting: 0,
+  /** Refers to an open socket ready for frames. */
+  Open: 1,
+  /** Refers to a close handshake in progress; frames sent now are discarded. */
+  Closing: 2,
+  /** Refers to a closed or failed socket. */
+  Closed: 3
+};
+const TransportFailureStatus = 0;
+const DefaultReconnectPolicy = {
+  maxRetries: Number.POSITIVE_INFINITY,
+  backoff: BackoffStrategy.Exponential,
+  baseDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  jitter: JitterStrategy.Equal
+};
+function createReconnectScheduler(options = {}) {
+  const { retry = DefaultReconnectPolicy, random = Math.random, onScheduled } = options;
+  let attempts = 0;
+  let previousDelayMs = 0;
+  let pendingDelayMs;
+  let timer;
+  return {
+    get attempts() {
+      return attempts;
+    },
+    get pendingDelayMs() {
+      return pendingDelayMs;
+    },
+    schedule(run) {
+      if (retry === false) return false;
+      if (timer !== void 0) return true;
+      if (!shouldRetry(retry, attempts, TransportFailureStatus)) return false;
+      const attempt = attempts + 1;
+      const delayMs = computeRetryDelay(retry, attempt, previousDelayMs, random);
+      attempts = attempt;
+      previousDelayMs = delayMs;
+      pendingDelayMs = delayMs;
+      timer = setTimeout(() => {
+        timer = void 0;
+        pendingDelayMs = void 0;
+        run();
+      }, delayMs);
+      onScheduled?.(attempt, delayMs);
+      return true;
+    },
+    reset() {
+      attempts = 0;
+      previousDelayMs = 0;
+    },
+    cancel() {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      pendingDelayMs = void 0;
+    }
+  };
+}
+const ReconnectOwner = {
+  /** Refers to the browser's own `EventSource` retry already being in flight; this wrapper stands down. */
+  Browser: "browser",
+  /** Refers to the browser having given up, with this wrapper's `resilience`-scheduled retry pending. */
+  Wrapper: "wrapper",
+  /** Refers to nobody retrying — reconnection is disabled, the attempt budget is spent, or the stream was closed. */
+  None: "none"
+};
+function parseFrame(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function frameTextOf(event) {
+  const message = event;
+  const data = message.data;
+  return { text: typeof data === "string" ? data : String(data), message };
+}
+function resolveSourceFactory(injected) {
+  if (injected !== void 0) return injected;
+  if (typeof EventSource === "undefined") return void 0;
+  return (url, init) => new EventSource(url, init);
+}
+function createEventStream(url, options = {}) {
+  const {
+    events,
+    onMessage,
+    onOpen,
+    onError,
+    onStateChange,
+    withCredentials = false,
+    parse = parseFrame,
+    retry,
+    random,
+    eventSource
+  } = options;
+  const factory = resolveSourceFactory(eventSource);
+  const scheduler = createReconnectScheduler({ retry, random });
+  let state = ConnectionState.Connecting;
+  let source;
+  let detach;
+  let closed = false;
+  const setState = (next) => {
+    if (state === next) return;
+    state = next;
+    onStateChange?.(next);
+  };
+  const report = (error, owner, attempt) => {
+    try {
+      onError?.(toError(error), { owner, attempt, state });
+    } catch {
+    }
+  };
+  const bind = (target) => {
+    const bound = [];
+    const on = (type, listener) => {
+      target.addEventListener(type, listener);
+      bound.push([type, listener]);
+    };
+    on("open", () => {
+      scheduler.reset();
+      setState(ConnectionState.Open);
+      onOpen?.();
+    });
+    on("error", () => handleError(target));
+    if (onMessage !== void 0) {
+      on("message", (event) => {
+        const { text, message } = frameTextOf(event);
+        onMessage(parse(text), message);
+      });
+    }
+    for (const name of Object.keys(events ?? {})) {
+      const handler = events[name];
+      if (handler === void 0) continue;
+      on(name, (event) => {
+        const { text, message } = frameTextOf(event);
+        handler(parse(text), message);
+      });
+    }
+    return () => {
+      for (const entry of bound) target.removeEventListener(entry[0], entry[1]);
+      bound.length = 0;
+    };
+  };
+  const connect = () => {
+    if (closed || factory === void 0) return;
+    setState(scheduler.attempts === 0 ? ConnectionState.Connecting : ConnectionState.Reconnecting);
+    let opened;
+    try {
+      opened = factory(url, { withCredentials });
+    } catch (error) {
+      const scheduled = scheduler.schedule(connect);
+      setState(scheduled ? ConnectionState.Reconnecting : ConnectionState.Closed);
+      report(error, scheduled ? ReconnectOwner.Wrapper : ReconnectOwner.None, scheduler.attempts);
+      return;
+    }
+    source = opened;
+    detach = bind(opened);
+  };
+  function handleError(target) {
+    if (closed) return;
+    if (target.readyState === EventSourceReadyState.Connecting) {
+      setState(ConnectionState.Reconnecting);
+      report(new Error(`The event stream to ${url} dropped; the browser is reconnecting.`), ReconnectOwner.Browser, 0);
+      return;
+    }
+    detach?.();
+    detach = void 0;
+    target.close();
+    source = void 0;
+    const scheduled = scheduler.schedule(connect);
+    setState(scheduled ? ConnectionState.Reconnecting : ConnectionState.Closed);
+    report(
+      new Error(`The event stream to ${url} failed and the browser stopped retrying.`),
+      scheduled ? ReconnectOwner.Wrapper : ReconnectOwner.None,
+      scheduler.attempts
+    );
+  }
+  if (factory === void 0) {
+    state = ConnectionState.Closed;
+    return {
+      get readyState() {
+        return state;
+      },
+      supported: false,
+      get attempts() {
+        return 0;
+      },
+      close: () => void 0
+    };
+  }
+  connect();
+  return {
+    get readyState() {
+      return state;
+    },
+    supported: true,
+    get attempts() {
+      return scheduler.attempts;
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      scheduler.cancel();
+      detach?.();
+      detach = void 0;
+      source?.close();
+      source = void 0;
+      setState(ConnectionState.Closed);
+    }
+  };
+}
+function useEventStream(url, options = {}) {
+  const readyState = shallowRef(
+    toValue(url) === null ? ConnectionState.Closed : ConnectionState.Connecting
+  );
+  const supported = shallowRef(true);
+  let stream = null;
+  function teardown() {
+    stream?.close();
+    stream = null;
+  }
+  function open() {
+    teardown();
+    const endpoint = toValue(url);
+    if (endpoint === null) {
+      readyState.value = ConnectionState.Closed;
+      return;
+    }
+    const current = toValue(options);
+    const next = createEventStream(endpoint, {
+      ...current,
+      // Every consumer callback is re-read through `toValue` at call time, which is what lets the watcher
+      // depend on `url` alone. `onStateChange` is additionally intercepted to drive this scope's own state.
+      onStateChange: (state) => {
+        readyState.value = state;
+        toValue(options).onStateChange?.(state);
+      },
+      onOpen: () => toValue(options).onOpen?.(),
+      onError: (error, context) => toValue(options).onError?.(error, context),
+      onMessage: (data, event) => toValue(options).onMessage?.(data, event)
+    });
+    stream = next;
+    supported.value = next.supported;
+    readyState.value = next.readyState;
+  }
+  onMounted(open);
+  watch(() => toValue(url), open);
+  onScopeDispose(teardown);
+  const close = () => {
+    stream?.close();
+  };
+  return { readyState, supported, close };
+}
+const DefaultQueueLimit = 100;
+const DefaultPingFrame = () => JSON.stringify({ type: "ping" });
+function resolveSocketFactory(injected) {
+  if (injected !== void 0) return injected;
+  if (typeof WebSocket === "undefined") return void 0;
+  return (url, protocols) => new WebSocket(url, protocols);
+}
+function createSocketClient(url, options = {}) {
+  const {
+    protocols,
+    onMessage,
+    onOpen,
+    onClose,
+    onError,
+    onStateChange,
+    serialize = (message) => JSON.stringify(message),
+    deserialize = (raw) => JSON.parse(raw),
+    retry,
+    heartbeat,
+    queueLimit = DefaultQueueLimit,
+    random,
+    socket: socketFactory
+  } = options;
+  const factory = resolveSocketFactory(socketFactory);
+  const scheduler = createReconnectScheduler({ retry, random });
+  const queue = [];
+  let state = ConnectionState.Connecting;
+  let connection;
+  let detach;
+  let closedByCaller = false;
+  let pingTimer;
+  let pongTimer;
+  const setState = (next) => {
+    if (state === next) return;
+    state = next;
+    onStateChange?.(next);
+  };
+  const report = (error) => {
+    try {
+      onError?.(toError(error));
+    } catch {
+    }
+  };
+  const stopHeartbeat = () => {
+    if (pingTimer !== void 0) {
+      clearInterval(pingTimer);
+      pingTimer = void 0;
+    }
+    if (pongTimer !== void 0) {
+      clearTimeout(pongTimer);
+      pongTimer = void 0;
+    }
+  };
+  const noteTraffic = () => {
+    if (pongTimer !== void 0) {
+      clearTimeout(pongTimer);
+      pongTimer = void 0;
+    }
+  };
+  const recycle = () => {
+    if (closedByCaller) return;
+    stopHeartbeat();
+    detach?.();
+    detach = void 0;
+    const dying = connection;
+    connection = void 0;
+    try {
+      dying?.close();
+    } catch {
+    }
+    const scheduled = scheduler.schedule(connect);
+    setState(scheduled ? ConnectionState.Reconnecting : ConnectionState.Closed);
+  };
+  const startHeartbeat = () => {
+    if (heartbeat === void 0) return;
+    const { intervalMs, timeoutMs = heartbeat.intervalMs, ping = DefaultPingFrame } = heartbeat;
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0) return;
+    pingTimer = setInterval(() => {
+      const live = connection;
+      if (live === void 0 || live.readyState !== SocketReadyState.Open) return;
+      try {
+        live.send(ping());
+      } catch (error) {
+        report(error);
+      }
+      if (pongTimer !== void 0) return;
+      pongTimer = setTimeout(() => {
+        pongTimer = void 0;
+        report(new Error(`The socket to ${url} missed its heartbeat; treating it as half-open.`));
+        recycle();
+      }, timeoutMs);
+    }, intervalMs);
+  };
+  const flushQueue = (target) => {
+    const pending = queue.splice(0, queue.length);
+    for (const frame of pending) {
+      try {
+        target.send(frame);
+      } catch (error) {
+        report(error);
+      }
+    }
+  };
+  const bind = (target) => {
+    const bound = [];
+    const on = (type, listener) => {
+      target.addEventListener(type, listener);
+      bound.push([type, listener]);
+    };
+    on("open", () => {
+      scheduler.reset();
+      setState(ConnectionState.Open);
+      onOpen?.();
+      flushQueue(target);
+      startHeartbeat();
+    });
+    on("message", (event) => {
+      noteTraffic();
+      if (onMessage === void 0) return;
+      const message = event;
+      const data = message.data;
+      if (typeof data !== "string") {
+        report(new Error(`The socket to ${url} delivered a non-text frame, which this client cannot decode.`));
+        return;
+      }
+      let decoded;
+      try {
+        decoded = deserialize(data);
+      } catch (error) {
+        report(error);
+        return;
+      }
+      onMessage(decoded, message);
+    });
+    on("error", () => {
+      report(new Error(`The socket to ${url} reported an error.`));
+    });
+    on("close", (event) => {
+      stopHeartbeat();
+      onClose?.(event);
+      if (closedByCaller) return;
+      detach?.();
+      detach = void 0;
+      connection = void 0;
+      const scheduled = scheduler.schedule(connect);
+      setState(scheduled ? ConnectionState.Reconnecting : ConnectionState.Closed);
+    });
+    return () => {
+      for (const entry of bound) target.removeEventListener(entry[0], entry[1]);
+      bound.length = 0;
+    };
+  };
+  function connect() {
+    if (closedByCaller || factory === void 0) return;
+    setState(scheduler.attempts === 0 ? ConnectionState.Connecting : ConnectionState.Reconnecting);
+    let opened;
+    try {
+      opened = factory(url, protocols);
+    } catch (error) {
+      report(error);
+      const scheduled = scheduler.schedule(connect);
+      setState(scheduled ? ConnectionState.Reconnecting : ConnectionState.Closed);
+      return;
+    }
+    connection = opened;
+    detach = bind(opened);
+  }
+  if (factory === void 0) {
+    state = ConnectionState.Closed;
+    return {
+      get readyState() {
+        return state;
+      },
+      supported: false,
+      get queuedCount() {
+        return 0;
+      },
+      get attempts() {
+        return 0;
+      },
+      send: () => false,
+      close: () => void 0
+    };
+  }
+  connect();
+  return {
+    get readyState() {
+      return state;
+    },
+    supported: true,
+    get queuedCount() {
+      return queue.length;
+    },
+    get attempts() {
+      return scheduler.attempts;
+    },
+    send(message) {
+      if (closedByCaller) return false;
+      let frame;
+      try {
+        frame = serialize(message);
+      } catch (error) {
+        report(error);
+        return false;
+      }
+      const live = connection;
+      if (live !== void 0 && live.readyState === SocketReadyState.Open) {
+        try {
+          live.send(frame);
+          return true;
+        } catch (error) {
+          report(error);
+        }
+      }
+      queue.push(frame);
+      if (queue.length > queueLimit) queue.splice(0, queue.length - queueLimit);
+      return false;
+    },
+    close(code, reason) {
+      if (closedByCaller) return;
+      closedByCaller = true;
+      scheduler.cancel();
+      stopHeartbeat();
+      queue.length = 0;
+      const dying = connection;
+      connection = void 0;
+      try {
+        dying?.close(code, reason);
+      } catch {
+      }
+      detach?.();
+      detach = void 0;
+      setState(ConnectionState.Closed);
+    }
+  };
+}
+function useSocket(url, options = {}) {
+  const readyState = shallowRef(
+    toValue(url) === null ? ConnectionState.Closed : ConnectionState.Connecting
+  );
+  const supported = shallowRef(true);
+  let client = null;
+  function teardown() {
+    client?.close();
+    client = null;
+  }
+  function open() {
+    teardown();
+    const endpoint = toValue(url);
+    if (endpoint === null) {
+      readyState.value = ConnectionState.Closed;
+      return;
+    }
+    const current = toValue(options);
+    const next = createSocketClient(endpoint, {
+      ...current,
+      // Every consumer callback is re-read through `toValue` at call time, which is what lets the watcher
+      // depend on `url` alone. `onStateChange` is additionally intercepted to drive this scope's own state.
+      onStateChange: (state) => {
+        readyState.value = state;
+        toValue(options).onStateChange?.(state);
+      },
+      onOpen: () => toValue(options).onOpen?.(),
+      onClose: (event) => toValue(options).onClose?.(event),
+      onError: (error) => toValue(options).onError?.(error),
+      onMessage: (message, event) => toValue(options).onMessage?.(message, event)
+    });
+    client = next;
+    supported.value = next.supported;
+    readyState.value = next.readyState;
+  }
+  onMounted(open);
+  watch(() => toValue(url), open);
+  onScopeDispose(teardown);
+  const send = (message) => client?.send(message) ?? false;
+  const close = () => {
+    client?.close();
+  };
+  return { readyState, supported, send, close };
+}
+function readOnlineStatus() {
+  try {
+    if (typeof navigator === "undefined") return true;
+    return navigator.onLine !== false;
+  } catch {
+    return true;
+  }
+}
+function subscribeOnline(listener) {
+  if (typeof window === "undefined") return () => void 0;
+  const target = window;
+  const onOnline = () => listener(true);
+  const onOffline = () => listener(false);
+  target.addEventListener("online", onOnline);
+  target.addEventListener("offline", onOffline);
+  let detached = false;
+  return () => {
+    if (detached) return;
+    detached = true;
+    target.removeEventListener("online", onOnline);
+    target.removeEventListener("offline", onOffline);
+  };
+}
+function waitForOnline(options = {}) {
+  const { timeoutMs, signal } = options;
+  if (readOnlineStatus()) return Promise.resolve(true);
+  if (signal?.aborted === true) return Promise.resolve(false);
+  if (typeof window === "undefined") return Promise.resolve(readOnlineStatus());
+  return new Promise((resolve) => {
+    let settled = false;
+    let unsubscribe;
+    let timer;
+    let onAbort;
+    const cleanup = () => {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      unsubscribe?.();
+      unsubscribe = void 0;
+      if (signal !== void 0 && onAbort !== void 0) {
+        signal.removeEventListener("abort", onAbort);
+        onAbort = void 0;
+      }
+    };
+    const finish = (online) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(online);
+    };
+    unsubscribe = subscribeOnline((online) => {
+      if (online) finish(true);
+    });
+    if (timeoutMs !== void 0 && timeoutMs > 0 && Number.isFinite(timeoutMs)) {
+      timer = setTimeout(() => {
+        timer = void 0;
+        finish(false);
+      }, timeoutMs);
+    }
+    if (signal !== void 0) {
+      const listener = () => finish(false);
+      onAbort = listener;
+      signal.addEventListener("abort", listener, { once: true });
+    }
+  });
+}
+const DefaultIntervalMs = 3e4;
+const SuspendReason = {
+  /** Refers to the caller's own `pause()`. Cleared only by `resume()`. */
+  Manual: "manual",
+  /** Refers to a hidden tab. Cleared by `visibilitychange`. */
+  Hidden: "hidden",
+  /** Refers to an offline browser. Cleared by the `online` event. */
+  Offline: "offline"
+};
+const PollerState = {
+  /** Refers to a poller created but not started. */
+  Idle: "idle",
+  /** Refers to a poller with a tick scheduled or running. */
+  Running: "running",
+  /** Refers to a started poller held by at least one suspend reason — paused, hidden, or offline. */
+  Paused: "paused",
+  /** Refers to a stopped poller: timers cleared, listeners detached, restartable with `start()`. */
+  Stopped: "stopped"
+};
+function readHidden() {
+  try {
+    if (typeof document === "undefined") return false;
+    return document.visibilityState === "hidden";
+  } catch {
+    return false;
+  }
+}
+function subscribeVisibility(listener) {
+  if (typeof document === "undefined") return () => void 0;
+  const target = document;
+  const onChange = () => listener(readHidden());
+  target.addEventListener("visibilitychange", onChange);
+  let detached = false;
+  return () => {
+    if (detached) return;
+    detached = true;
+    target.removeEventListener("visibilitychange", onChange);
+  };
+}
+function createPoller(fn, options = {}) {
+  const {
+    intervalMs = DefaultIntervalMs,
+    autoStart = true,
+    immediate = false,
+    pauseWhenHidden = true,
+    pauseWhenOffline = true,
+    refreshOnResume = true,
+    onError,
+    onStateChange
+  } = options;
+  const suspended = /* @__PURE__ */ new Set();
+  let state = PollerState.Idle;
+  let timer;
+  let running = false;
+  let inFlight = false;
+  let unsubscribeVisibility;
+  let unsubscribeOnline;
+  const setState = (next) => {
+    if (state === next) return;
+    state = next;
+    onStateChange?.(next);
+  };
+  const clearPending = () => {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  const scheduleNext = () => {
+    if (!running || suspended.size > 0 || timer !== void 0) return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      void tick();
+    }, intervalMs);
+  };
+  async function tick() {
+    if (!running || suspended.size > 0 || inFlight) return;
+    inFlight = true;
+    try {
+      await fn();
+    } catch (error) {
+      try {
+        onError?.(toError(error));
+      } catch {
+      }
+    } finally {
+      inFlight = false;
+    }
+    scheduleNext();
+  }
+  const suspend = (reason) => {
+    if (suspended.has(reason)) return;
+    suspended.add(reason);
+    clearPending();
+    if (running) setState(PollerState.Paused);
+  };
+  const unsuspend = (reason) => {
+    if (!suspended.delete(reason)) return;
+    if (!running || suspended.size > 0) return;
+    setState(PollerState.Running);
+    if (refreshOnResume) void tick();
+    else scheduleNext();
+  };
+  const attachEnvironment = () => {
+    if (pauseWhenHidden) {
+      if (readHidden()) suspended.add(SuspendReason.Hidden);
+      unsubscribeVisibility = subscribeVisibility((hidden) => {
+        if (hidden) suspend(SuspendReason.Hidden);
+        else unsuspend(SuspendReason.Hidden);
+      });
+    }
+    if (pauseWhenOffline) {
+      if (!readOnlineStatus()) suspended.add(SuspendReason.Offline);
+      unsubscribeOnline = subscribeOnline((online) => {
+        if (online) unsuspend(SuspendReason.Offline);
+        else suspend(SuspendReason.Offline);
+      });
+    }
+  };
+  const detachEnvironment = () => {
+    unsubscribeVisibility?.();
+    unsubscribeVisibility = void 0;
+    unsubscribeOnline?.();
+    unsubscribeOnline = void 0;
+  };
+  const poller = {
+    get state() {
+      return state;
+    },
+    start() {
+      if (running) return;
+      running = true;
+      suspended.clear();
+      attachEnvironment();
+      if (suspended.size > 0) {
+        setState(PollerState.Paused);
+        return;
+      }
+      setState(PollerState.Running);
+      if (immediate) void tick();
+      else scheduleNext();
+    },
+    pause() {
+      suspend(SuspendReason.Manual);
+    },
+    resume() {
+      unsuspend(SuspendReason.Manual);
+    },
+    stop() {
+      if (!running && state === PollerState.Stopped) return;
+      running = false;
+      clearPending();
+      detachEnvironment();
+      suspended.clear();
+      setState(PollerState.Stopped);
+    }
+  };
+  if (autoStart) poller.start();
+  return poller;
+}
+function usePolling(fn, options = {}) {
+  const state = shallowRef(PollerState.Idle);
+  let poller = null;
+  function teardown() {
+    poller?.stop();
+    poller = null;
+  }
+  function build() {
+    teardown();
+    const current = toValue(options);
+    const next = createPoller(() => toValue(fn)(), {
+      ...current,
+      intervalMs: current.intervalMs,
+      onStateChange: (value) => {
+        state.value = value;
+        toValue(options).onStateChange?.(value);
+      },
+      onError: (error) => toValue(options).onError?.(error)
+    });
+    poller = next;
+    state.value = next.state;
+  }
+  onMounted(build);
+  watch(() => toValue(options).intervalMs, build);
+  onScopeDispose(teardown);
+  const pause = () => {
+    poller?.pause();
+  };
+  const resume = () => {
+    poller?.resume();
+  };
+  const stop = () => {
+    poller?.stop();
+  };
+  return { state, pause, resume, stop };
+}
+export {
+  ConnectionState,
+  DefaultReconnectPolicy,
+  EventSourceReadyState,
+  PollerState,
+  ReconnectOwner,
+  SocketReadyState,
+  createEventStream,
+  createPoller,
+  createReconnectScheduler,
+  createSocketClient,
+  readOnlineStatus,
+  subscribeOnline,
+  useEventStream,
+  usePolling,
+  useSocket,
+  waitForOnline
+};
+//# sourceMappingURL=index.js.map