react-realtime-hooks 1.0.0

package/dist/index.js

@@ -0,0 +1,1239 @@
+import { useSyncExternalStore, useRef, useState, useEffect, useEffectEvent, useMemo, startTransition } from 'react';
+
+// src/hooks/useOnlineStatus.ts
+
+// src/core/env.ts
+var isWebSocketSupported = () => typeof WebSocket !== "undefined";
+var isEventSourceSupported = () => typeof EventSource !== "undefined";
+var hasNavigatorOnLineSupport = () => typeof navigator !== "undefined" && typeof navigator.onLine === "boolean";
+var readOnlineStatus = (initialOnline = true) => {
+  if (!hasNavigatorOnLineSupport()) {
+    return {
+      isOnline: initialOnline,
+      isSupported: false
+    };
+  }
+  return {
+    isOnline: navigator.onLine,
+    isSupported: true
+  };
+};
+
+// src/hooks/useOnlineStatus.ts
+var subscribeToOnlineStatus = (onStoreChange) => {
+  if (typeof window === "undefined") {
+    return () => {
+    };
+  }
+  window.addEventListener("online", onStoreChange);
+  window.addEventListener("offline", onStoreChange);
+  return () => {
+    window.removeEventListener("online", onStoreChange);
+    window.removeEventListener("offline", onStoreChange);
+  };
+};
+var createEmptyTransitionState = () => ({
+  lastChangedAt: null,
+  wentOfflineAt: null,
+  wentOnlineAt: null
+});
+var useOnlineStatus = (options = {}) => {
+  const initialOnline = options.initialOnline ?? true;
+  const trackTransitions = options.trackTransitions ?? true;
+  const isOnline = useSyncExternalStore(
+    subscribeToOnlineStatus,
+    () => readOnlineStatus(initialOnline).isOnline,
+    () => initialOnline
+  );
+  const previousOnlineRef = useRef(isOnline);
+  const [transitions, setTransitions] = useState(createEmptyTransitionState);
+  useEffect(() => {
+    if (!trackTransitions) {
+      previousOnlineRef.current = isOnline;
+      setTransitions(createEmptyTransitionState);
+      return;
+    }
+    if (previousOnlineRef.current === isOnline) {
+      return;
+    }
+    const changedAt = Date.now();
+    previousOnlineRef.current = isOnline;
+    setTransitions((current) => ({
+      lastChangedAt: changedAt,
+      wentOfflineAt: isOnline ? current.wentOfflineAt : changedAt,
+      wentOnlineAt: isOnline ? changedAt : current.wentOnlineAt
+    }));
+  }, [isOnline, trackTransitions]);
+  return {
+    isOnline,
+    isSupported: hasNavigatorOnLineSupport(),
+    ...transitions
+  };
+};
+
+// src/core/reconnect.ts
+var DEFAULT_RECONNECT_OPTIONS = {
+  backoffFactor: 2,
+  enabled: true,
+  initialDelayMs: 1e3,
+  jitterRatio: 0.2,
+  maxDelayMs: 3e4,
+  resetOnSuccess: true
+};
+var clampNumber = (value, min, max) => Math.min(max, Math.max(min, value));
+var sanitizeDelay = (value) => {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  return Math.max(0, Math.round(value));
+};
+var sanitizeBackoffFactor = (value) => {
+  if (!Number.isFinite(value)) {
+    return DEFAULT_RECONNECT_OPTIONS.backoffFactor;
+  }
+  return Math.max(1, value);
+};
+var sanitizeMaxAttempts = (value) => {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (!Number.isFinite(value)) {
+    return null;
+  }
+  return Math.max(0, Math.floor(value));
+};
+var sanitizeJitterRatio = (value) => {
+  if (!Number.isFinite(value)) {
+    return DEFAULT_RECONNECT_OPTIONS.jitterRatio;
+  }
+  return clampNumber(value, 0, 1);
+};
+var normalizeReconnectOptions = (options) => {
+  if (options === false) {
+    return null;
+  }
+  const initialDelayMs = sanitizeDelay(
+    options?.initialDelayMs ?? DEFAULT_RECONNECT_OPTIONS.initialDelayMs
+  );
+  const maxDelayMs = Math.max(
+    initialDelayMs,
+    sanitizeDelay(options?.maxDelayMs ?? DEFAULT_RECONNECT_OPTIONS.maxDelayMs)
+  );
+  const normalized = {
+    backoffFactor: sanitizeBackoffFactor(
+      options?.backoffFactor ?? DEFAULT_RECONNECT_OPTIONS.backoffFactor
+    ),
+    enabled: options?.enabled ?? DEFAULT_RECONNECT_OPTIONS.enabled,
+    initialDelayMs,
+    jitterRatio: sanitizeJitterRatio(
+      options?.jitterRatio ?? DEFAULT_RECONNECT_OPTIONS.jitterRatio
+    ),
+    maxAttempts: sanitizeMaxAttempts(options?.maxAttempts),
+    maxDelayMs,
+    resetOnSuccess: options?.resetOnSuccess ?? DEFAULT_RECONNECT_OPTIONS.resetOnSuccess
+  };
+  if (options?.getDelayMs !== void 0) {
+    normalized.getDelayMs = options.getDelayMs;
+  }
+  if (options?.onCancel !== void 0) {
+    normalized.onCancel = options.onCancel;
+  }
+  if (options?.onReset !== void 0) {
+    normalized.onReset = options.onReset;
+  }
+  if (options?.onSchedule !== void 0) {
+    normalized.onSchedule = options.onSchedule;
+  }
+  return normalized;
+};
+var createReconnectDelayContext = (attempt, options, lastDelayMs) => ({
+  attempt: Math.max(1, Math.floor(attempt)),
+  backoffFactor: options.backoffFactor,
+  initialDelayMs: options.initialDelayMs,
+  jitterRatio: options.jitterRatio,
+  lastDelayMs,
+  maxDelayMs: options.maxDelayMs
+});
+var defaultReconnectDelayStrategy = (context) => {
+  const exponent = Math.max(0, context.attempt - 1);
+  const baseDelay = context.initialDelayMs * context.backoffFactor ** exponent;
+  return Math.min(context.maxDelayMs, sanitizeDelay(baseDelay));
+};
+var applyJitterToDelay = (delayMs, jitterRatio, random = Math.random) => {
+  if (delayMs === 0 || jitterRatio === 0) {
+    return delayMs;
+  }
+  const safeRandom = clampNumber(random(), 0, 1);
+  const variance = delayMs * jitterRatio;
+  const offset = (safeRandom * 2 - 1) * variance;
+  return sanitizeDelay(delayMs + offset);
+};
+var calculateReconnectDelay = (context, options = {}) => {
+  const baseDelay = sanitizeDelay(
+    (options.strategy ?? defaultReconnectDelayStrategy)(context)
+  );
+  const cappedDelay = Math.min(context.maxDelayMs, baseDelay);
+  return Math.min(
+    context.maxDelayMs,
+    applyJitterToDelay(cappedDelay, context.jitterRatio, options.random)
+  );
+};
+var canScheduleReconnectAttempt = (attempt, options) => {
+  if (!options.enabled) {
+    return false;
+  }
+  if (attempt < 1) {
+    return false;
+  }
+  return options.maxAttempts === null || attempt <= options.maxAttempts;
+};
+var createReconnectAttempt = (attempt, trigger, options, lastDelayMs, config = {}) => {
+  if (!canScheduleReconnectAttempt(attempt, options)) {
+    return null;
+  }
+  const context = createReconnectDelayContext(attempt, options, lastDelayMs);
+  const calculationOptions = {};
+  if (config.random !== void 0) {
+    calculationOptions.random = config.random;
+  }
+  if (options.getDelayMs !== void 0) {
+    calculationOptions.strategy = options.getDelayMs;
+  }
+  return {
+    attempt,
+    delayMs: calculateReconnectDelay(context, calculationOptions),
+    scheduledAt: config.now ?? Date.now(),
+    trigger
+  };
+};
+
+// src/core/timers.ts
+var sanitizeTimerDelay = (delayMs) => {
+  if (!Number.isFinite(delayMs)) {
+    return 0;
+  }
+  return Math.max(0, Math.round(delayMs));
+};
+var createManagedTimeout = () => {
+  let timeoutId = null;
+  return {
+    cancel() {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    },
+    isActive() {
+      return timeoutId !== null;
+    },
+    schedule(callback, delayMs) {
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = setTimeout(() => {
+        timeoutId = null;
+        callback();
+      }, sanitizeTimerDelay(delayMs));
+    }
+  };
+};
+var createManagedInterval = () => {
+  let intervalId = null;
+  return {
+    cancel() {
+      if (intervalId !== null) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+    },
+    isActive() {
+      return intervalId !== null;
+    },
+    start(callback, intervalMs) {
+      if (intervalId !== null) {
+        clearInterval(intervalId);
+      }
+      intervalId = setInterval(callback, sanitizeTimerDelay(intervalMs));
+    }
+  };
+};
+
+// src/hooks/useReconnect.ts
+var createInitialState = (enabled) => ({
+  attempt: 0,
+  nextDelayMs: null,
+  status: enabled ? "idle" : "stopped"
+});
+var useReconnect = (options = {}) => {
+  const normalizedOptions = normalizeReconnectOptions(options) ?? normalizeReconnectOptions();
+  const timeoutRef = useRef(createManagedTimeout());
+  const lastDelayRef = useRef(null);
+  const [state, setState] = useState(
+    () => createInitialState(normalizedOptions.enabled)
+  );
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const commitState = (next) => {
+    const resolved = typeof next === "function" ? next(stateRef.current) : next;
+    stateRef.current = resolved;
+    startTransition(() => {
+      setState(resolved);
+    });
+  };
+  const runAttempt = useEffectEvent((attempt) => {
+    commitState({
+      attempt,
+      nextDelayMs: null,
+      status: "running"
+    });
+  });
+  const emitSchedule = useEffectEvent((attempt) => {
+    normalizedOptions.onSchedule?.(attempt);
+  });
+  const emitCancel = useEffectEvent(() => {
+    normalizedOptions.onCancel?.();
+  });
+  const emitReset = useEffectEvent(() => {
+    normalizedOptions.onReset?.();
+  });
+  useEffect(() => {
+    if (!normalizedOptions.enabled) {
+      timeoutRef.current.cancel();
+      commitState((current) => ({
+        ...current,
+        nextDelayMs: null,
+        status: "stopped"
+      }));
+      return;
+    }
+    commitState(
+      (current) => current.status === "stopped" ? {
+        ...current,
+        status: "idle"
+      } : current
+    );
+  }, [normalizedOptions.enabled]);
+  useEffect(() => () => {
+    timeoutRef.current.cancel();
+  }, []);
+  const schedule = (trigger = "manual") => {
+    const current = stateRef.current;
+    const nextAttempt = current.attempt + 1;
+    const attempt = createReconnectAttempt(
+      nextAttempt,
+      trigger,
+      normalizedOptions,
+      lastDelayRef.current
+    );
+    timeoutRef.current.cancel();
+    if (attempt === null) {
+      commitState((snapshot) => ({
+        ...snapshot,
+        nextDelayMs: null,
+        status: "stopped"
+      }));
+      return;
+    }
+    lastDelayRef.current = attempt.delayMs;
+    timeoutRef.current.schedule(() => {
+      runAttempt(attempt.attempt);
+    }, attempt.delayMs);
+    commitState({
+      attempt: attempt.attempt,
+      nextDelayMs: attempt.delayMs,
+      status: "scheduled"
+    });
+    emitSchedule(attempt);
+  };
+  const cancel = () => {
+    const current = stateRef.current;
+    const shouldEmitCancel = timeoutRef.current.isActive() || current.status === "scheduled" || current.status === "running";
+    timeoutRef.current.cancel();
+    commitState((snapshot) => ({
+      ...snapshot,
+      nextDelayMs: null,
+      status: "stopped"
+    }));
+    if (shouldEmitCancel) {
+      emitCancel();
+    }
+  };
+  const reset = () => {
+    timeoutRef.current.cancel();
+    lastDelayRef.current = null;
+    commitState(createInitialState(normalizedOptions.enabled));
+    emitReset();
+  };
+  const markConnected = () => {
+    timeoutRef.current.cancel();
+    if (normalizedOptions.resetOnSuccess) {
+      lastDelayRef.current = null;
+      commitState(createInitialState(normalizedOptions.enabled));
+      emitReset();
+      return;
+    }
+    commitState((current) => ({
+      ...current,
+      nextDelayMs: null,
+      status: normalizedOptions.enabled ? "idle" : "stopped"
+    }));
+  };
+  return {
+    attempt: state.attempt,
+    cancel,
+    isActive: state.status === "scheduled" || state.status === "running",
+    isScheduled: state.status === "scheduled",
+    markConnected,
+    nextDelayMs: state.nextDelayMs,
+    reset,
+    schedule,
+    status: state.status
+  };
+};
+var createInitialState2 = (isRunning) => ({
+  hasTimedOut: false,
+  isRunning,
+  lastAckAt: null,
+  lastBeatAt: null,
+  latencyMs: null
+});
+var useHeartbeat = (options) => {
+  const enabled = options.enabled ?? true;
+  const startOnMount = options.startOnMount ?? true;
+  const intervalRef = useRef(createManagedInterval());
+  const timeoutRef = useRef(createManagedTimeout());
+  const [state, setState] = useState(
+    () => createInitialState2(enabled && startOnMount)
+  );
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const commitState = (next) => {
+    const resolved = typeof next === "function" ? next(stateRef.current) : next;
+    stateRef.current = resolved;
+    setState(resolved);
+  };
+  const handleTimeout = useEffectEvent(() => {
+    commitState((current) => ({
+      ...current,
+      hasTimedOut: true
+    }));
+    options.onTimeout?.();
+  });
+  const scheduleTimeout = useEffectEvent(() => {
+    if (options.timeoutMs === void 0) {
+      timeoutRef.current.cancel();
+      return;
+    }
+    timeoutRef.current.schedule(() => {
+      handleTimeout();
+    }, options.timeoutMs);
+  });
+  const runBeat = useEffectEvent(() => {
+    const performedAt = Date.now();
+    commitState((current) => ({
+      ...current,
+      hasTimedOut: false,
+      lastBeatAt: performedAt
+    }));
+    scheduleTimeout();
+    options.onBeat?.();
+    void options.beat?.();
+  });
+  const start = () => {
+    if (!enabled) {
+      return;
+    }
+    if (!intervalRef.current.isActive()) {
+      intervalRef.current.start(() => {
+        runBeat();
+      }, options.intervalMs);
+    }
+    commitState((current) => ({
+      ...current,
+      hasTimedOut: false,
+      isRunning: true
+    }));
+  };
+  const stop = () => {
+    intervalRef.current.cancel();
+    timeoutRef.current.cancel();
+    commitState((current) => ({
+      ...current,
+      hasTimedOut: false,
+      isRunning: false
+    }));
+  };
+  const beat = () => {
+    if (!enabled) {
+      return;
+    }
+    runBeat();
+  };
+  const notifyAck = (message) => {
+    if (stateRef.current.lastBeatAt === null) {
+      return false;
+    }
+    const matchesAck = options.matchesAck === void 0 || options.matchesAck(message);
+    if (!matchesAck) {
+      return false;
+    }
+    const acknowledgedAt = Date.now();
+    timeoutRef.current.cancel();
+    commitState((current) => ({
+      ...current,
+      hasTimedOut: false,
+      lastAckAt: acknowledgedAt,
+      latencyMs: current.lastBeatAt === null ? null : acknowledgedAt - current.lastBeatAt
+    }));
+    return true;
+  };
+  useEffect(() => {
+    if (!enabled) {
+      stop();
+      return;
+    }
+    if (startOnMount) {
+      start();
+      return stop;
+    }
+    stop();
+    return void 0;
+  }, [enabled, options.intervalMs, startOnMount]);
+  useEffect(() => () => {
+    intervalRef.current.cancel();
+    timeoutRef.current.cancel();
+  }, []);
+  return {
+    beat,
+    hasTimedOut: state.hasTimedOut,
+    isRunning: state.isRunning,
+    lastAckAt: state.lastAckAt,
+    lastBeatAt: state.lastBeatAt,
+    latencyMs: state.latencyMs,
+    notifyAck,
+    start,
+    stop
+  };
+};
+
+// src/core/connection-state.ts
+var createConnectionStateSnapshot = (status, config = {}) => {
+  const base = {
+    isSupported: config.isSupported ?? true,
+    lastChangedAt: config.lastChangedAt ?? null
+  };
+  switch (status) {
+    case "open":
+      return {
+        ...base,
+        isClosed: false,
+        isConnected: true,
+        isConnecting: false,
+        status
+      };
+    case "connecting":
+    case "reconnecting":
+      return {
+        ...base,
+        isClosed: false,
+        isConnected: false,
+        isConnecting: true,
+        status
+      };
+    case "closing":
+      return {
+        ...base,
+        isClosed: false,
+        isConnected: false,
+        isConnecting: false,
+        status
+      };
+    case "idle":
+    case "closed":
+    case "error":
+      return {
+        ...base,
+        isClosed: true,
+        isConnected: false,
+        isConnecting: false,
+        status
+      };
+  }
+};
+
+// src/core/url.ts
+var normalizeResolvedUrl = (value) => {
+  if (value === null) {
+    return null;
+  }
+  if (value instanceof URL) {
+    return value.toString();
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+};
+var resolveUrlProvider = (url) => {
+  const resolved = typeof url === "function" ? url() : url;
+  return normalizeResolvedUrl(resolved ?? null);
+};
+
+// src/hooks/useWebSocket.ts
+var createInitialState3 = (status = "idle") => ({
+  bufferedAmount: 0,
+  lastChangedAt: null,
+  lastCloseEvent: null,
+  lastError: null,
+  lastMessage: null,
+  lastMessageEvent: null,
+  status
+});
+var defaultParseMessage = (event) => event.data;
+var defaultSerializeMessage = (message) => {
+  if (typeof message === "string" || message instanceof Blob || message instanceof ArrayBuffer) {
+    return message;
+  }
+  if (ArrayBuffer.isView(message)) {
+    return message;
+  }
+  return JSON.stringify(message);
+};
+var resolveFactoryValue = (value) => typeof value === "function" ? value() : value;
+var toProtocolsDependency = (protocols) => {
+  if (protocols === void 0) {
+    return "";
+  }
+  return Array.isArray(protocols) ? protocols.join("|") : protocols;
+};
+var toHeartbeatConfig = (heartbeat) => heartbeat === void 0 || heartbeat === false ? null : heartbeat;
+var useWebSocket = (options) => {
+  const connect = options.connect ?? true;
+  const supported = isWebSocketSupported();
+  const resolvedUrl = useMemo(() => resolveUrlProvider(options.url), [options.url]);
+  const protocolsDependency = toProtocolsDependency(options.protocols);
+  const socketRef = useRef(null);
+  const socketKeyRef = useRef(null);
+  const manualCloseRef = useRef(false);
+  const manualOpenRef = useRef(false);
+  const skipCloseReconnectRef = useRef(false);
+  const suppressReconnectRef = useRef(false);
+  const [openNonce, setOpenNonce] = useState(0);
+  const [state, setState] = useState(
+    () => createInitialState3(connect ? "connecting" : "idle")
+  );
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const reconnectEnabled = options.reconnect !== false && supported && resolvedUrl !== null;
+  const reconnect = useReconnect(
+    options.reconnect === false ? { enabled: false } : {
+      ...options.reconnect,
+      enabled: reconnectEnabled && (options.reconnect?.enabled ?? true)
+    }
+  );
+  const heartbeatEnabled = options.heartbeat !== false && supported && resolvedUrl !== null;
+  const heartbeatConfig = toHeartbeatConfig(
+    options.heartbeat
+  );
+  const heartbeatHookOptions = heartbeatConfig === null ? {
+    enabled: false,
+    intervalMs: 1e3,
+    startOnMount: false
+  } : {
+    beat: () => {
+      const socket2 = socketRef.current;
+      if (socket2 === null || socket2.readyState !== WebSocket.OPEN) {
+        return false;
+      }
+      const heartbeatMessage = heartbeatConfig.message;
+      if (heartbeatMessage !== void 0) {
+        const serialized = (options.serializeMessage ?? defaultSerializeMessage)(
+          resolveFactoryValue(heartbeatMessage)
+        );
+        socket2.send(serialized);
+      }
+      return heartbeatConfig.beat?.() ?? true;
+    },
+    enabled: heartbeatEnabled && (heartbeatConfig.enabled ?? true),
+    intervalMs: heartbeatConfig.intervalMs,
+    startOnMount: false
+  };
+  if (heartbeatConfig !== null && heartbeatConfig.timeoutMs !== void 0) {
+    heartbeatHookOptions.timeoutMs = heartbeatConfig.timeoutMs;
+  }
+  if (heartbeatConfig !== null && heartbeatConfig.matchesAck !== void 0) {
+    heartbeatHookOptions.matchesAck = heartbeatConfig.matchesAck;
+  }
+  if (heartbeatConfig !== null && heartbeatConfig.onBeat !== void 0) {
+    heartbeatHookOptions.onBeat = heartbeatConfig.onBeat;
+  }
+  if (heartbeatConfig !== null && heartbeatConfig.onTimeout !== void 0) {
+    heartbeatHookOptions.onTimeout = heartbeatConfig.onTimeout;
+  }
+  const heartbeat = useHeartbeat(
+    heartbeatHookOptions
+  );
+  const commitState = (next) => {
+    const resolved = typeof next === "function" ? next(stateRef.current) : next;
+    stateRef.current = resolved;
+    setState(resolved);
+  };
+  const closeSocket = useEffectEvent((code, reason) => {
+    const socket2 = socketRef.current;
+    if (socket2 === null) {
+      return;
+    }
+    socketRef.current = null;
+    socketKeyRef.current = null;
+    if (socket2.readyState === WebSocket.OPEN || socket2.readyState === WebSocket.CONNECTING) {
+      socket2.close(code, reason);
+    }
+  });
+  const parseMessage = useEffectEvent((event) => {
+    const parser = options.parseMessage ?? defaultParseMessage;
+    return parser(event);
+  });
+  const updateBufferedAmount = useEffectEvent(() => {
+    commitState((current) => ({
+      ...current,
+      bufferedAmount: socketRef.current?.bufferedAmount ?? 0
+    }));
+  });
+  const handleOpen = useEffectEvent((event, socket2) => {
+    manualCloseRef.current = false;
+    suppressReconnectRef.current = false;
+    reconnect.markConnected();
+    heartbeat.start();
+    commitState((current) => ({
+      ...current,
+      bufferedAmount: socket2.bufferedAmount,
+      lastChangedAt: Date.now(),
+      status: "open"
+    }));
+    options.onOpen?.(event, socket2);
+  });
+  const handleMessage = useEffectEvent((event) => {
+    try {
+      const message = parseMessage(event);
+      heartbeat.notifyAck(message);
+      commitState((current) => ({
+        ...current,
+        bufferedAmount: socketRef.current?.bufferedAmount ?? current.bufferedAmount,
+        lastMessage: message,
+        lastMessageEvent: event
+      }));
+      options.onMessage?.(message, event);
+    } catch {
+      const parseError = new Event("error");
+      commitState((current) => ({
+        ...current,
+        lastError: parseError,
+        status: "error"
+      }));
+    }
+  });
+  const handleError = useEffectEvent((event) => {
+    heartbeat.stop();
+    commitState((current) => ({
+      ...current,
+      lastError: event,
+      status: "error"
+    }));
+    options.onError?.(event);
+  });
+  const handleClose = useEffectEvent((event) => {
+    socketRef.current = null;
+    socketKeyRef.current = null;
+    heartbeat.stop();
+    updateBufferedAmount();
+    const skipCloseReconnect = skipCloseReconnectRef.current;
+    skipCloseReconnectRef.current = false;
+    const shouldReconnect = !suppressReconnectRef.current && !skipCloseReconnect && reconnectEnabled && (options.shouldReconnect?.(event) ?? true);
+    commitState((current) => ({
+      ...current,
+      lastChangedAt: Date.now(),
+      lastCloseEvent: event,
+      status: shouldReconnect ? "reconnecting" : "closed"
+    }));
+    options.onClose?.(event);
+    if (shouldReconnect) {
+      reconnect.schedule("close");
+    } else {
+      suppressReconnectRef.current = false;
+    }
+  });
+  const open = () => {
+    manualCloseRef.current = false;
+    manualOpenRef.current = true;
+    suppressReconnectRef.current = false;
+    reconnect.cancel();
+    setOpenNonce((current) => current + 1);
+  };
+  const reconnectNow = () => {
+    manualCloseRef.current = false;
+    manualOpenRef.current = true;
+    skipCloseReconnectRef.current = true;
+    suppressReconnectRef.current = true;
+    heartbeat.stop();
+    closeSocket();
+    suppressReconnectRef.current = false;
+    reconnect.schedule("manual");
+  };
+  const close = (code, reason) => {
+    manualCloseRef.current = true;
+    manualOpenRef.current = false;
+    suppressReconnectRef.current = true;
+    reconnect.cancel();
+    heartbeat.stop();
+    commitState((current) => ({
+      ...current,
+      lastChangedAt: Date.now(),
+      status: "closing"
+    }));
+    closeSocket(code, reason);
+  };
+  const send = (message) => {
+    const socket2 = socketRef.current;
+    if (socket2 === null || socket2.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+    const serializer = options.serializeMessage ?? defaultSerializeMessage;
+    socket2.send(serializer(message));
+    updateBufferedAmount();
+    return true;
+  };
+  useEffect(() => {
+    if (!supported) {
+      socketKeyRef.current = null;
+      commitState((current) => ({
+        ...current,
+        status: "closed"
+      }));
+      return;
+    }
+    if (resolvedUrl === null) {
+      socketKeyRef.current = null;
+      closeSocket();
+      commitState((current) => ({
+        ...current,
+        status: "closed"
+      }));
+      return;
+    }
+    const shouldConnect = connect && !manualCloseRef.current || manualOpenRef.current || reconnect.status === "running";
+    const nextSocketKey = `${resolvedUrl}::${protocolsDependency}::${options.binaryType ?? "blob"}`;
+    if (!shouldConnect) {
+      if (socketRef.current !== null) {
+        suppressReconnectRef.current = true;
+        closeSocket();
+      }
+      socketKeyRef.current = null;
+      commitState((current) => ({
+        ...current,
+        status: manualCloseRef.current ? "closed" : "idle"
+      }));
+      return;
+    }
+    if (socketRef.current !== null && socketKeyRef.current !== nextSocketKey) {
+      suppressReconnectRef.current = true;
+      closeSocket();
+    }
+    if (socketRef.current !== null) {
+      return;
+    }
+    const socket2 = new WebSocket(resolvedUrl, options.protocols);
+    socketRef.current = socket2;
+    socketKeyRef.current = nextSocketKey;
+    socket2.binaryType = options.binaryType ?? "blob";
+    commitState((current) => ({
+      ...current,
+      bufferedAmount: socket2.bufferedAmount,
+      lastChangedAt: Date.now(),
+      status: reconnect.status === "running" || reconnect.status === "scheduled" ? "reconnecting" : "connecting"
+    }));
+    const handleSocketOpen = (event) => {
+      handleOpen(event, socket2);
+    };
+    const handleSocketMessage = (event) => {
+      handleMessage(event);
+    };
+    const handleSocketError = (event) => {
+      handleError(event);
+    };
+    const handleSocketClose = (event) => {
+      handleClose(event);
+    };
+    socket2.addEventListener("open", handleSocketOpen);
+    socket2.addEventListener("message", handleSocketMessage);
+    socket2.addEventListener("error", handleSocketError);
+    socket2.addEventListener("close", handleSocketClose);
+    return () => {
+      socket2.removeEventListener("open", handleSocketOpen);
+      socket2.removeEventListener("message", handleSocketMessage);
+      socket2.removeEventListener("error", handleSocketError);
+      socket2.removeEventListener("close", handleSocketClose);
+    };
+  }, [
+    connect,
+    openNonce,
+    options.binaryType,
+    protocolsDependency,
+    reconnect.status,
+    resolvedUrl,
+    supported
+  ]);
+  useEffect(() => () => {
+    suppressReconnectRef.current = true;
+    socketKeyRef.current = null;
+    const socket2 = socketRef.current;
+    socketRef.current = null;
+    if (socket2 === null) {
+      return;
+    }
+    if (socket2.readyState === WebSocket.OPEN || socket2.readyState === WebSocket.CONNECTING) {
+      socket2.close();
+    }
+  }, []);
+  useEffect(() => {
+    if (state.status !== "open") {
+      heartbeat.stop();
+    }
+  }, [state.status]);
+  const status = (reconnect.status === "scheduled" || reconnect.status === "running") && state.status !== "open" ? "reconnecting" : state.status;
+  const snapshot = createConnectionStateSnapshot(status, {
+    isSupported: supported,
+    lastChangedAt: state.lastChangedAt
+  });
+  const heartbeatState = options.heartbeat === false ? null : {
+    hasTimedOut: heartbeat.hasTimedOut,
+    isRunning: heartbeat.isRunning,
+    lastAckAt: heartbeat.lastAckAt,
+    lastBeatAt: heartbeat.lastBeatAt,
+    latencyMs: heartbeat.latencyMs
+  };
+  const reconnectState = options.reconnect === false ? null : {
+    attempt: reconnect.attempt,
+    isScheduled: reconnect.isScheduled,
+    nextDelayMs: reconnect.nextDelayMs,
+    status: reconnect.status
+  };
+  const commonResult = {
+    bufferedAmount: state.bufferedAmount,
+    close,
+    heartbeatState,
+    lastCloseEvent: state.lastCloseEvent,
+    lastError: state.lastError,
+    lastMessage: state.lastMessage,
+    lastMessageEvent: state.lastMessageEvent,
+    open,
+    reconnect: reconnectNow,
+    reconnectState,
+    send,
+    transport: "websocket"
+  };
+  const socket = socketRef.current;
+  if (snapshot.status === "open") {
+    return {
+      ...snapshot,
+      ...commonResult,
+      socket
+    };
+  }
+  return {
+    ...snapshot,
+    ...commonResult,
+    socket
+  };
+};
+var createInitialState4 = (status = "idle") => ({
+  lastChangedAt: null,
+  lastError: null,
+  lastEventName: null,
+  lastMessage: null,
+  lastMessageEvent: null,
+  status
+});
+var defaultParseMessage2 = (event) => event.data;
+var toEventsDependency = (events) => {
+  if (events === void 0 || events.length === 0) {
+    return "";
+  }
+  return [...new Set(events)].sort().join("|");
+};
+var normalizeNamedEvents = (events) => {
+  if (events === void 0 || events.length === 0) {
+    return [];
+  }
+  return [...new Set(events)].filter((eventName) => eventName !== "message");
+};
+var useEventSource = (options) => {
+  const connect = options.connect ?? true;
+  const supported = isEventSourceSupported();
+  const resolvedUrl = useMemo(() => resolveUrlProvider(options.url), [options.url]);
+  const eventsDependency = toEventsDependency(options.events);
+  const namedEvents = useMemo(
+    () => normalizeNamedEvents(options.events),
+    [eventsDependency]
+  );
+  const eventSourceRef = useRef(null);
+  const eventSourceKeyRef = useRef(null);
+  const manualCloseRef = useRef(false);
+  const manualOpenRef = useRef(false);
+  const skipErrorReconnectRef = useRef(false);
+  const suppressReconnectRef = useRef(false);
+  const [openNonce, setOpenNonce] = useState(0);
+  const [state, setState] = useState(
+    () => createInitialState4(connect ? "connecting" : "idle")
+  );
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const reconnectEnabled = options.reconnect !== false && supported && resolvedUrl !== null;
+  const reconnect = useReconnect(
+    options.reconnect === false ? { enabled: false } : {
+      ...options.reconnect,
+      enabled: reconnectEnabled && (options.reconnect?.enabled ?? true)
+    }
+  );
+  const commitState = (next) => {
+    const resolved = typeof next === "function" ? next(stateRef.current) : next;
+    stateRef.current = resolved;
+    setState(resolved);
+  };
+  const closeEventSource = useEffectEvent(() => {
+    const source = eventSourceRef.current;
+    if (source === null) {
+      return;
+    }
+    eventSourceRef.current = null;
+    eventSourceKeyRef.current = null;
+    source.close();
+  });
+  const parseMessage = useEffectEvent((event) => {
+    const parser = options.parseMessage ?? defaultParseMessage2;
+    return parser(event);
+  });
+  const handleOpen = useEffectEvent((event, source) => {
+    manualCloseRef.current = false;
+    suppressReconnectRef.current = false;
+    reconnect.markConnected();
+    commitState((current) => ({
+      ...current,
+      lastChangedAt: Date.now(),
+      status: "open"
+    }));
+    options.onOpen?.(event, source);
+  });
+  const commitParsedMessage = useEffectEvent(
+    (eventName, event, isNamedEvent) => {
+      try {
+        const message = parseMessage(event);
+        commitState((current) => ({
+          ...current,
+          lastEventName: eventName,
+          lastMessage: message,
+          lastMessageEvent: event
+        }));
+        if (isNamedEvent) {
+          options.onEvent?.(eventName, message, event);
+          return;
+        }
+        options.onMessage?.(message, event);
+      } catch {
+        const parseError = new Event("error");
+        commitState((current) => ({
+          ...current,
+          lastError: parseError,
+          status: "error"
+        }));
+      }
+    }
+  );
+  const handleError = useEffectEvent((event, source) => {
+    const skipErrorReconnect = skipErrorReconnectRef.current;
+    skipErrorReconnectRef.current = false;
+    const shouldReconnect = !suppressReconnectRef.current && !skipErrorReconnect && reconnectEnabled && (options.shouldReconnect?.(event) ?? true);
+    const readyState = source.readyState;
+    commitState((current) => ({
+      ...current,
+      lastChangedAt: Date.now(),
+      lastError: event,
+      status: readyState === EventSource.OPEN ? "open" : shouldReconnect ? "reconnecting" : "closed"
+    }));
+    options.onError?.(event);
+    if (!shouldReconnect) {
+      suppressReconnectRef.current = false;
+      closeEventSource();
+      return;
+    }
+    if (readyState === EventSource.CLOSED) {
+      eventSourceRef.current = null;
+      eventSourceKeyRef.current = null;
+      reconnect.schedule("error");
+    }
+  });
+  const open = () => {
+    manualCloseRef.current = false;
+    manualOpenRef.current = true;
+    suppressReconnectRef.current = false;
+    reconnect.cancel();
+    setOpenNonce((current) => current + 1);
+  };
+  const reconnectNow = () => {
+    manualCloseRef.current = false;
+    manualOpenRef.current = true;
+    skipErrorReconnectRef.current = true;
+    suppressReconnectRef.current = true;
+    closeEventSource();
+    suppressReconnectRef.current = false;
+    reconnect.schedule("manual");
+  };
+  const close = () => {
+    manualCloseRef.current = true;
+    manualOpenRef.current = false;
+    suppressReconnectRef.current = true;
+    reconnect.cancel();
+    closeEventSource();
+    commitState((current) => ({
+      ...current,
+      lastChangedAt: Date.now(),
+      status: "closed"
+    }));
+  };
+  useEffect(() => {
+    if (!supported) {
+      eventSourceKeyRef.current = null;
+      commitState((current) => ({
+        ...current,
+        status: "closed"
+      }));
+      return;
+    }
+    if (resolvedUrl === null) {
+      eventSourceKeyRef.current = null;
+      closeEventSource();
+      commitState((current) => ({
+        ...current,
+        status: "closed"
+      }));
+      return;
+    }
+    const shouldConnect = connect && !manualCloseRef.current || manualOpenRef.current || reconnect.status === "running";
+    const nextEventSourceKey = [
+      resolvedUrl,
+      options.withCredentials ? "credentials" : "anonymous",
+      eventsDependency
+    ].join("::");
+    if (!shouldConnect) {
+      if (eventSourceRef.current !== null) {
+        suppressReconnectRef.current = true;
+        closeEventSource();
+      }
+      eventSourceKeyRef.current = null;
+      commitState((current) => ({
+        ...current,
+        status: manualCloseRef.current ? "closed" : "idle"
+      }));
+      return;
+    }
+    if (eventSourceRef.current !== null && eventSourceKeyRef.current !== nextEventSourceKey) {
+      suppressReconnectRef.current = true;
+      closeEventSource();
+    }
+    if (eventSourceRef.current !== null) {
+      return;
+    }
+    const source = new EventSource(resolvedUrl, {
+      withCredentials: options.withCredentials ?? false
+    });
+    eventSourceRef.current = source;
+    eventSourceKeyRef.current = nextEventSourceKey;
+    commitState((current) => ({
+      ...current,
+      lastChangedAt: Date.now(),
+      status: reconnect.status === "running" || reconnect.status === "scheduled" ? "reconnecting" : "connecting"
+    }));
+    const handleSourceOpen = (event) => {
+      handleOpen(event, source);
+    };
+    const handleSourceMessage = (event) => {
+      commitParsedMessage("message", event, false);
+    };
+    const namedEventHandlers = /* @__PURE__ */ new Map();
+    const handleSourceError = (event) => {
+      handleError(event, source);
+    };
+    source.addEventListener("open", handleSourceOpen);
+    source.addEventListener("message", handleSourceMessage);
+    for (const eventName of namedEvents) {
+      const handler = (event) => {
+        commitParsedMessage(eventName, event, true);
+      };
+      namedEventHandlers.set(eventName, handler);
+      source.addEventListener(eventName, handler);
+    }
+    source.addEventListener("error", handleSourceError);
+    return () => {
+      source.removeEventListener("open", handleSourceOpen);
+      source.removeEventListener("message", handleSourceMessage);
+      for (const [eventName, handler] of namedEventHandlers) {
+        source.removeEventListener(eventName, handler);
+      }
+      source.removeEventListener("error", handleSourceError);
+    };
+  }, [
+    connect,
+    eventsDependency,
+    namedEvents,
+    openNonce,
+    options.withCredentials,
+    reconnect.status,
+    resolvedUrl,
+    supported
+  ]);
+  useEffect(() => () => {
+    suppressReconnectRef.current = true;
+    eventSourceKeyRef.current = null;
+    const source = eventSourceRef.current;
+    eventSourceRef.current = null;
+    if (source !== null) {
+      source.close();
+    }
+  }, []);
+  const status = (reconnect.status === "scheduled" || reconnect.status === "running") && state.status !== "open" ? "reconnecting" : state.status;
+  const snapshot = createConnectionStateSnapshot(status, {
+    isSupported: supported,
+    lastChangedAt: state.lastChangedAt
+  });
+  const reconnectState = options.reconnect === false ? null : {
+    attempt: reconnect.attempt,
+    isScheduled: reconnect.isScheduled,
+    nextDelayMs: reconnect.nextDelayMs,
+    status: reconnect.status
+  };
+  const commonResult = {
+    close,
+    lastError: state.lastError,
+    lastEventName: state.lastEventName,
+    lastMessage: state.lastMessage,
+    lastMessageEvent: state.lastMessageEvent,
+    open,
+    reconnect: reconnectNow,
+    reconnectState,
+    transport: "eventsource"
+  };
+  const eventSource = eventSourceRef.current;
+  if (snapshot.status === "open") {
+    return {
+      ...snapshot,
+      ...commonResult,
+      eventSource
+    };
+  }
+  return {
+    ...snapshot,
+    ...commonResult,
+    eventSource
+  };
+};
+
+export { useEventSource, useHeartbeat, useOnlineStatus, useReconnect, useWebSocket };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map