@maxtroost/use-websocket 1.0.0

package/dist/index.js

@@ -0,0 +1,595 @@
+import { Store as e, useStore as t } from "@tanstack/react-store";
+import { Store as n } from "@tanstack/store";
+import { deepEqual as r } from "fast-equals";
+import { createElement as i, useEffect as a, useId as o, useRef as s, useState as c } from "react";
+import { useIsomorphicLayoutEffect as l } from "usehooks-ts";
+import { closeSnackbar as u, enqueueSnackbar as d } from "notistack";
+import { v4 as f } from "uuid";
+//#region src/lib/types.ts
+var p = /* @__PURE__ */ function(e) {
+	return e[e.UNINSTANTIATED = -1] = "UNINSTANTIATED", e[e.CONNECTING = 0] = "CONNECTING", e[e.OPEN = 1] = "OPEN", e[e.CLOSING = 2] = "CLOSING", e[e.CLOSED = 3] = "CLOSED", e;
+}({});
+function m() {
+	return {
+		message: void 0,
+		subscribed: !1,
+		pendingSubscription: !1,
+		subscribedAt: void 0,
+		receivedAt: void 0,
+		connected: !1,
+		messageError: void 0,
+		serverError: void 0
+	};
+}
+//#endregion
+//#region src/lib/websocketStores.ts
+var h = new e(/* @__PURE__ */ new Map()), g = new e(/* @__PURE__ */ new Map()), _ = () => {
+	h.state.forEach((e) => {
+		e.reconnect();
+	});
+}, v = (e) => new Promise((t) => setTimeout(t, e)), y = {
+	NORMAL_CLOSURE: 1e3,
+	GOING_AWAY: 1001,
+	INTERNAL_ERROR: 1011,
+	SERVICE_RESTART: 1012,
+	TRY_AGAIN_LATER: 1013,
+	ABNORMAL_CLOSURE: 1006
+}, b = {
+	MAX_RETRY_ATTEMPTS: 20,
+	NOTIFICATION_THRESHOLD: 10,
+	TRY_AGAIN_LATER_DELAY_MS: 3e4,
+	DELAYS: {
+		FIRST_PHASE: 4e3,
+		SECOND_PHASE: 3e4,
+		THIRD_PHASE: 9e4
+	},
+	PHASE_THRESHOLDS: {
+		FIRST: 5,
+		SECOND: 10
+	}
+}, x = {
+	PRODUCTION_MS: 3e3,
+	TEST_MS: 10
+}, S = { PONG_TIMEOUT_MS: 1e4 }, C = { enabled: !0 }, w = 1e4, T = (e) => e < b.PHASE_THRESHOLDS.FIRST ? b.DELAYS.FIRST_PHASE : e < b.PHASE_THRESHOLDS.SECOND ? b.DELAYS.SECOND_PHASE : b.DELAYS.THIRD_PHASE, E = () => 40 * 1e3, D = (e) => typeof e == "object" && !!e && "uri" in e && typeof e.uri == "string", O = (e) => e ? [
+	"error",
+	"conflict",
+	"exception"
+].includes(e) : !1, k = () => typeof window < "u" && window.navigator.onLine, A = (e) => typeof window < "u" && window.navigator.onLine && e !== void 0 && e.readyState === WebSocket.OPEN, j = (e, t, n) => {
+	t > b.NOTIFICATION_THRESHOLD && d(`trying to reconnect to ${e} in ${n / 1e3} seconds.`, {
+		key: `${e}-offline`,
+		variant: "error",
+		preventDuplicate: !0
+	});
+}, M = (e, t) => {
+	let n = `${e}-max-retries`;
+	d(`Connection to ${e} failed after maximum retries.`, {
+		key: n,
+		variant: "error",
+		preventDuplicate: !0,
+		action: (e) => i("button", {
+			onClick: () => {
+				t(), u(e);
+			},
+			style: {
+				marginLeft: 8,
+				padding: "4px 12px",
+				background: "rgba(255,255,255,0.2)",
+				border: "none",
+				borderRadius: 4,
+				color: "inherit",
+				cursor: "pointer",
+				fontSize: 14,
+				fontWeight: 500
+			}
+		}, "Retry")
+	});
+}, N = (e, t) => {
+	t > b.NOTIFICATION_THRESHOLD && d(`trying to reconnect to ${e}...`, {
+		key: `${e}-reconnecting`,
+		variant: "info",
+		preventDuplicate: !0
+	});
+}, P = () => JSON.stringify({
+	method: "post",
+	uri: "ping",
+	body: Date.now(),
+	correlation: f()
+}), F = (e) => e?.readyState === WebSocket.OPEN || e?.readyState === WebSocket.CONNECTING, I = (e) => e !== y.NORMAL_CLOSURE, L = class e {
+	static setCustomLogger(t) {
+		e._logger = t;
+	}
+	constructor(t) {
+		this._listeners = /* @__PURE__ */ new Map(), this.reconnectTries = 0, this._isReconnecting = !1, this._maxRetriesExceeded = !1, this.cachedMessages = [], this.getSocket = () => this._socket, this.getUriApiByKey = (e) => {
+			let t = this._listeners.get(e);
+			if (t && "uri" in t) return t;
+		}, this.addListener = (e) => (e.setSendToConnection(this.handleSendMessage), this.connect(), this._listeners.set(e.key, e), clearTimeout(this.closeConnectionTimeOut), this._socket?.readyState === WebSocket.OPEN && e.onOpen && e.onOpen(), e), this.removeListener = (e) => {
+			let t = this._listeners.get(e.key);
+			t && (t.setSendToConnection(null), this._listeners.delete(t.key)), clearTimeout(this.closeConnectionTimeOut), this.scheduleConnectionCleanup();
+		}, this.scheduleConnectionCleanup = () => {
+			this.closeConnectionTimeOut = setTimeout(() => {
+				this._listeners.size === 0 && this._socket?.close();
+			}, x.PRODUCTION_MS);
+		}, this.replaceUrl = async (e) => {
+			this._url !== e && (this._url = e, await this.teardownAndReconnect());
+		}, this.reconnect = async () => {
+			await this.teardownAndReconnect();
+		}, this.resetRetriesAndReconnect = () => {
+			this.reconnectTries = 0, this._maxRetriesExceeded = !1, u(`${this._name}-max-retries`), this.connect();
+		}, this.connect = () => {
+			let t = Array.from(this._listeners.values()).some((e) => e.isEnabled);
+			F(this._socket) || !t || (e._logger?.log?.("info", "ws-connect", {
+				url: this._url,
+				uriApis: Array.from(this._listeners).filter(([e, t]) => "uri" in t).map(([e, t]) => t.uri)
+			}), this._socket = new WebSocket(this._url), this._socket.addEventListener("close", this.handleClose), this._socket.addEventListener("message", this.handleMessage), this._socket.addEventListener("open", this.handleOpen), this._socket.addEventListener("error", this.handleError));
+		}, this.teardownSocket = () => {
+			this.clearAllTimers(), this.removeListeners(), this._socket?.close(), this._socket = void 0;
+		}, this.teardownAndReconnect = async () => {
+			if (!this._isReconnecting) {
+				this._isReconnecting = !0;
+				try {
+					this.teardownSocket(), this._listeners.forEach((e) => e.reset()), this.reconnectTries = 0, this._maxRetriesExceeded = !1, u(`${this._name}-max-retries`), await v(1e3), this.connect();
+				} finally {
+					this._isReconnecting = !1;
+				}
+			}
+		}, this.cleanupConnection = () => {
+			this._listeners.size === 0 && (e._logger?.log?.("info", "ws-closed", {
+				url: this._url,
+				subscriptions: this._listeners.size
+			}), this.removeListeners(), this._socket = void 0);
+		}, this.clearAllTimers = () => {
+			clearTimeout(this.pingTimeOut), clearTimeout(this.pongTimeOut), clearTimeout(this.closeConnectionTimeOut);
+		}, this.removeListeners = () => {
+			this._socket?.removeEventListener("message", this.handleMessage), this._socket?.removeEventListener("close", this.handleClose), this._socket?.removeEventListener("open", this.handleOpen), this._socket?.removeEventListener("error", this.handleError), typeof window < "u" && (window.removeEventListener("online", this.handleOnline), window.removeEventListener("online", this.handleOnlineForReconnection), window.removeEventListener("offline", this.handleOffline));
+		}, this.attemptReconnection = async (t) => {
+			if (this.reconnectTries >= b.MAX_RETRY_ATTEMPTS) {
+				this._maxRetriesExceeded = !0, e._logger?.connectionFailed?.(this._url, this.reconnectTries, this._listeners.size), M(this._name, this.resetRetriesAndReconnect);
+				return;
+			}
+			if (this.deferReconnectionUntilOnline() || t === y.TRY_AGAIN_LATER && (j(this._name, this.reconnectTries, b.TRY_AGAIN_LATER_DELAY_MS), await v(b.TRY_AGAIN_LATER_DELAY_MS), this.deferReconnectionUntilOnline())) return;
+			this.reconnectTries++, e._logger?.log?.("info", "ws-reconnect", {
+				url: this._url,
+				uriApis: Array.from(this._listeners).filter(([e, t]) => "uri" in t).map(([e, t]) => t.uri),
+				retries: this.reconnectTries
+			});
+			let n = T(this.reconnectTries);
+			j(this._name, this.reconnectTries, n), await v(n), !this.deferReconnectionUntilOnline() && (N(this._name, this.reconnectTries), this.connect());
+		}, this.deferReconnectionUntilOnline = () => k() ? !1 : (typeof window < "u" && window.addEventListener("online", this.handleOnlineForReconnection, { once: !0 }), !0), this.handleClose = async (t) => {
+			this.clearAllTimers(), e._logger?.log?.("info", "ws-close", {
+				url: this._url,
+				uriApis: Array.from(this._listeners).filter(([e, t]) => "uri" in t).map(([e, t]) => t.uri),
+				code: t.code,
+				reason: t.reason,
+				wasClean: t.wasClean,
+				online: typeof window < "u" && window.navigator.onLine
+			});
+			let n = I(t.code), r = this._listeners.size > 0;
+			n && r && await this.attemptReconnection(t.code), this.cleanupConnection();
+		}, this.handleOpen = () => {
+			typeof window < "u" && window.addEventListener("offline", this.handleOffline), u(`${this._name}-offline`), u(`${this._name}-reconnecting`), this.reconnectTries > b.NOTIFICATION_THRESHOLD && d(`reconnected to ${this._name}.`, {
+				key: `${this._name}-online`,
+				variant: "success",
+				preventDuplicate: !0
+			}), this.reconnectTries = 0;
+			let t = this._socket;
+			t && (this._listeners.forEach((e) => e.onOpen?.()), e._logger?.log?.("info", "ws-on-open", {
+				url: this._url,
+				uriApis: Array.from(this._listeners).filter(([e, t]) => "uri" in t).map(([e, t]) => t.uri)
+			}), this.cachedMessages.forEach((e) => t.send(this.serializeMessage(e)))), this.cachedMessages = [], this.schedulePing();
+		}, this.handleMessage = (t) => {
+			try {
+				let n = JSON.parse(t.data);
+				if (!D(n)) {
+					e._logger?.log?.("error", "ws-invalid-message", {
+						url: this._url,
+						uriApis: Array.from(this._listeners).filter(([e, t]) => "uri" in t).map(([e, t]) => t.uri),
+						message: n
+					}), this._listeners.forEach((e) => e.onError({
+						type: "transport",
+						event: t
+					}));
+					return;
+				}
+				if (n.uri === "ping") {
+					this.clearPongTimeout(), this.schedulePing();
+					return;
+				}
+				if (O(n.method)) {
+					e._logger?.log?.("error", "ws-message-error", {
+						url: this._url,
+						uriApis: Array.from(this._listeners).filter(([e, t]) => "uri" in t).map(([e, t]) => t.uri),
+						message: n
+					}), this.forEachMatchingListener(n.uri, (e) => e.onMessageError({
+						type: "server",
+						message: n
+					}));
+					return;
+				}
+				this.forEachMatchingListener(n.uri, (e) => {
+					e.uri === n.uri ? e.onMessage?.(n.body) : e.deliverMessage?.(n.uri, n.body);
+				});
+			} catch (n) {
+				e._logger?.log?.("error", "ws-message-parse-error", {
+					url: this._url,
+					uriApis: Array.from(this._listeners).filter(([e, t]) => "uri" in t).map(([e, t]) => t.uri),
+					message: t.data,
+					error: n
+				}), this._listeners.forEach((e) => e.onError({
+					type: "transport",
+					event: t
+				}));
+			}
+		}, this.handleError = (t) => {
+			this._listeners.forEach((e) => e.onError({
+				type: "transport",
+				event: t
+			})), e._logger?.log?.("error", "ws-error", {
+				url: this._url,
+				uriApis: Array.from(this._listeners).filter(([e, t]) => "uri" in t).map(([e, t]) => t.uri),
+				event: t
+			});
+		}, this.handleOnline = () => {
+			typeof window < "u" && window.removeEventListener("online", this.handleOnline), this.connect();
+		}, this.handleOnlineForReconnection = () => {
+			typeof window < "u" && window.removeEventListener("online", this.handleOnlineForReconnection), this.reconnectTries--, this.attemptReconnection();
+		}, this.handleOffline = () => {
+			typeof window < "u" && window.removeEventListener("offline", this.handleOffline), this._socket && this._listeners.forEach((e) => e.onClose(new CloseEvent("offline"))), this.teardownSocket(), typeof window < "u" && window.addEventListener("online", this.handleOnline);
+		}, this.handleSendMessage = (t) => {
+			if (this._socket?.readyState === WebSocket.OPEN) {
+				e._logger?.log?.("info", `ws-${t.method}: ${t.uri}`, {
+					url: this._url,
+					message: t.body
+				}), this._socket.send(this.serializeMessage(t));
+				return;
+			}
+			t.method !== "subscribe" && this.cachedMessages.push(t), this.connect();
+		}, this.sendPing = () => {
+			A(this._socket) && (this._socket?.send(P()), this.schedulePongTimeout());
+		}, this.clearPongTimeout = () => {
+			clearTimeout(this.pongTimeOut), this.pongTimeOut = void 0;
+		}, this.schedulePongTimeout = () => {
+			this.clearPongTimeout(), this.pongTimeOut = setTimeout(() => {
+				e._logger?.log?.("info", "ws-pong-timeout", {
+					url: this._url,
+					uriApis: Array.from(this._listeners).filter(([e, t]) => "uri" in t).map(([e, t]) => t.uri)
+				}), this.teardownSocket(), this.attemptReconnection();
+			}, S.PONG_TIMEOUT_MS);
+		}, this.schedulePing = () => {
+			this.pingTimeOut = setTimeout(() => {
+				this.sendPing();
+			}, E());
+		}, this.serializeMessage = (e) => JSON.stringify({
+			...e,
+			correlation: f()
+		}), this.forEachMatchingListener = (e, t) => {
+			this._listeners.forEach((n) => {
+				(n.uri === e || n.hasWaitingUri?.(e)) && t(n);
+			});
+		}, this._url = t, this._name = new URL(t).pathname;
+	}
+	get readyState() {
+		return this._socket?.readyState;
+	}
+	get url() {
+		return this._url;
+	}
+}, R = class {
+	constructor(e) {
+		this._sendToConnection = null, this._pendingByUri = /* @__PURE__ */ new Map(), this._pendingMessages = [], this._registeredHooks = /* @__PURE__ */ new Set(), this.hasWaitingUri = (e) => this._pendingByUri.has(e), this.registerHook = (e) => {
+			this._clearHookRemovalTimeout(), this._registeredHooks.add(e);
+		}, this.unregisterHook = (e, t) => {
+			this._registeredHooks.delete(e), this._scheduleHookRemoval(t);
+		}, this.disconnect = (e) => {
+			this._clearHookRemovalTimeout(), this._hookRemovalTimeout = setTimeout(() => {
+				this._hookRemovalTimeout = void 0, e();
+			}, 200);
+		}, this.setSendToConnection = (e) => {
+			this._sendToConnection = e, e ? this._flushPendingMessages(e) : (this._clearHookRemovalTimeout(), this._pendingMessages = [], this._cancelAllPending());
+		}, this.deliverMessage = (e, t) => {
+			let n = this._pendingByUri.get(e);
+			n && (clearTimeout(n.timeoutId), this._pendingByUri.delete(e), n.resolve(t));
+		}, this.onError = (e) => {
+			this._options.onError?.(e);
+		}, this.onMessageError = (e) => {
+			this._options.onMessageError?.(e);
+		}, this.onClose = (e) => {
+			this._cancelAllPending(), this._options.onClose?.(e);
+		}, this.reset = () => {
+			this._clearHookRemovalTimeout(), this._cancelAllPending();
+		}, this._options = {
+			enabled: !0,
+			responseTimeoutMs: w,
+			...e
+		};
+	}
+	get key() {
+		return this._options.key;
+	}
+	get url() {
+		return this._options.url;
+	}
+	get isEnabled() {
+		return this._options.enabled ?? !0;
+	}
+	sendMessage(e, t, n, r) {
+		if (!this.isEnabled) return Promise.reject(/* @__PURE__ */ Error("WebsocketMessageApi is disabled"));
+		this._cancelPendingForUri(e);
+		let i = r?.timeout ?? this._options.responseTimeoutMs ?? 1e4;
+		return new Promise((r, a) => {
+			let o = setTimeout(() => {
+				this._pendingByUri.get(e)?.timeoutId === o && (this._pendingByUri.delete(e), a(/* @__PURE__ */ Error(`WebSocket response timeout for URI: ${e}`)));
+			}, i);
+			this._pendingByUri.set(e, {
+				resolve: (e) => r(e),
+				reject: a,
+				timeoutId: o
+			});
+			let s = {
+				uri: e,
+				method: t,
+				body: n,
+				correlation: f()
+			};
+			this._sendOrQueue(s);
+		});
+	}
+	sendMessageNoWait(e, t, n) {
+		if (!this.isEnabled) return;
+		let r = {
+			uri: e,
+			method: t,
+			body: n,
+			correlation: f()
+		};
+		this._sendOrQueue(r);
+	}
+	_clearHookRemovalTimeout() {
+		this._hookRemovalTimeout !== void 0 && (clearTimeout(this._hookRemovalTimeout), this._hookRemovalTimeout = void 0);
+	}
+	_scheduleHookRemoval(e) {
+		this._clearHookRemovalTimeout(), this._hookRemovalTimeout = setTimeout(() => {
+			this._hookRemovalTimeout = void 0, this._registeredHooks.size === 0 && e();
+		}, 200);
+	}
+	_flushPendingMessages(e) {
+		this._pendingMessages.length !== 0 && (this._pendingMessages.forEach((t) => e(t)), this._pendingMessages = []);
+	}
+	_sendOrQueue(e) {
+		this._sendToConnection ? this._sendToConnection(e) : this._pendingMessages.push(e);
+	}
+	_cancelPendingForUri(e) {
+		let t = this._pendingByUri.get(e);
+		t && (clearTimeout(t.timeoutId), this._pendingByUri.delete(e), t.reject(/* @__PURE__ */ Error(`WebSocket request overwritten for URI: ${e}`)));
+	}
+	_cancelAllPending() {
+		this._pendingByUri.forEach((e) => {
+			clearTimeout(e.timeoutId), e.reject(/* @__PURE__ */ Error("WebSocket connection closed"));
+		}), this._pendingByUri.clear();
+	}
+}, z = class {
+	constructor(t) {
+		this._state = new e(m()), this._registeredHooks = /* @__PURE__ */ new Set(), this._sendToConnection = null, this._pendingMessages = [], this.setSendToConnection = (e) => {
+			this._sendToConnection = e, e ? this._flushPendingMessages(e) : (this._clearPendingTimeouts(), this._pendingMessages = []);
+		}, this.registerHook = (e) => {
+			this._clearPendingTimeouts(), this._registeredHooks.add(e), this._registeredHooks.size > 1 && console.warn(`the uri ${this.uri} has more than one initiator, multiple initiators could cause unexpected behavior`);
+		}, this.unregisterHook = (e, t) => {
+			this._registeredHooks.delete(e), this._scheduleHookRemoval(t);
+		}, this.disconnect = (e) => {
+			this._clearPendingTimeouts(), this.unsubscribe(), this._disconnectTimeout = setTimeout(() => {
+				this._disconnectTimeout = void 0, this._state.setState((e) => ({
+					...e,
+					connected: !1,
+					subscribed: !1,
+					pendingSubscription: !1
+				})), e();
+			}, 200);
+		}, this.reset = () => {
+			this._state.state.connected && (this._state.setState((e) => ({
+				...e,
+				connected: !1,
+				subscribed: !1,
+				pendingSubscription: !1,
+				message: void 0
+			})), this._clearPendingTimeouts());
+		}, this.sendMessage = (e) => {
+			if (!this.isEnabled) return;
+			this._clearPendingTimeouts();
+			let t = {
+				...e,
+				uri: this.uri,
+				method: e.method ?? this._options.method ?? "post"
+			};
+			this._sendOrQueue(t);
+		}, this.subscribe = (e) => {
+			this.isEnabled && (this._clearPendingTimeouts(), this._state.setState((e) => ({
+				...e,
+				subscribed: !0,
+				pendingSubscription: !0,
+				subscribedAt: Date.now()
+			})), this._sendOrQueue({
+				body: e,
+				uri: this.uri,
+				method: "subscribe"
+			}), this._options.onSubscribe?.({
+				uri: this.uri,
+				body: this._options.body,
+				uriApi: this
+			}));
+		}, this.unsubscribe = () => {
+			this._state.state.subscribed && (this._state.setState((e) => ({
+				...e,
+				subscribed: !1,
+				pendingSubscription: !1,
+				message: void 0
+			})), this._sendOrQueue({
+				uri: this.uri,
+				method: "unsubscribe"
+			}));
+		}, this.onOpen = () => {
+			this._state.state.connected || (this._state.setState((e) => ({
+				...e,
+				connected: !0
+			})), this.subscribe(this._options.body));
+		}, this.onMessage = (e) => {
+			this._state.setState((t) => ({
+				...t,
+				message: e,
+				pendingSubscription: !1,
+				receivedAt: Date.now()
+			})), this._options.onMessage?.({
+				data: e,
+				uriApi: this
+			});
+		}, this.onError = (e) => {
+			this._state.setState((e) => ({
+				...e,
+				pendingSubscription: !1
+			})), this._options.onError?.(e);
+		}, this.onMessageError = (e) => {
+			this._state.setState((e) => ({
+				...e,
+				pendingSubscription: !1
+			})), this._options.onMessageError?.(e);
+		}, this.onClose = (e) => {
+			this._state.setState((e) => ({
+				...e,
+				subscribed: !1,
+				pendingSubscription: !1
+			})), this._options.onClose?.(e);
+		}, this._options = {
+			...C,
+			...t
+		};
+	}
+	get key() {
+		return this._options.key;
+	}
+	get uri() {
+		return this._options.uri;
+	}
+	get url() {
+		return this._options.url;
+	}
+	get options() {
+		return this._options;
+	}
+	get data() {
+		return this._state.state.message;
+	}
+	get store() {
+		return this._state;
+	}
+	get isEnabled() {
+		return this._options.enabled ?? !0;
+	}
+	set options(e) {
+		let t = {
+			...C,
+			...this._options,
+			...e
+		};
+		if (r(this._options, t)) return;
+		let n = this._options;
+		this._options = t, this._handleSubscriptionUpdates(n, t), this._handleUnsubscribeOnDisable(n, t);
+	}
+	_clearPendingTimeouts() {
+		this._disconnectTimeout !== void 0 && (clearTimeout(this._disconnectTimeout), this._disconnectTimeout = void 0), this._hookRemovalTimeout !== void 0 && (clearTimeout(this._hookRemovalTimeout), this._hookRemovalTimeout = void 0);
+	}
+	_scheduleHookRemoval(e) {
+		this._clearPendingTimeouts(), this._hookRemovalTimeout = setTimeout(() => {
+			this._hookRemovalTimeout = void 0, this._registeredHooks.size === 0 && (this._state.setState((e) => ({
+				...e,
+				connected: !1
+			})), this.unsubscribe(), e());
+		}, 200);
+	}
+	_flushPendingMessages(e) {
+		this._pendingMessages.length !== 0 && (this._pendingMessages.forEach((t) => e({
+			...t,
+			uri: this.uri,
+			method: t.method ?? this._options.method ?? "post"
+		})), this._pendingMessages = []);
+	}
+	_sendOrQueue(e) {
+		this._sendToConnection ? this._sendToConnection(e) : this._pendingMessages.push(e);
+	}
+	_handleSubscriptionUpdates(e, t) {
+		let n = !r(e.body, t.body), i = !e.enabled && t.enabled;
+		(n || i) && this.subscribe(t.body);
+	}
+	_handleUnsubscribeOnDisable(e, t) {
+		let n = !t.enabled, r = e.enabled;
+		n && r && this._state.state.subscribed && this.unsubscribe();
+	}
+}, B = (e, t) => {
+	let n = V(e);
+	if (n) return n;
+	let r = new L(t);
+	return h.setState((t) => new Map(t).set(e, r)), r;
+}, V = (e) => h.state.get(e), H = (e) => {
+	let t = g.state.get(e);
+	if (t && "uri" in t) return t;
+}, U = (e, t) => {
+	let n = H(e);
+	if (n) return n;
+	let r = new z(t);
+	return g.setState((t) => new Map(t).set(e, r)), r;
+}, W = (e) => {
+	let t = g.state.get(e);
+	if (t && "hasWaitingUri" in t) return t;
+}, G = (e, t) => {
+	let n = W(e);
+	if (n) return n;
+	let r = new R(t);
+	return g.setState((t) => new Map(t).set(e, r)), r;
+}, K = (e) => {
+	V(e.url)?.removeListener(e), g.setState((t) => {
+		let n = new Map(t);
+		return n.delete(e.key), n;
+	});
+};
+//#endregion
+//#region src/lib/WebsocketHook.ts
+function q(e) {
+	let t = s(e);
+	return r(t.current, e) || (t.current = e), t.current;
+}
+function J(e, t, n) {
+	let r = o();
+	l(() => {
+		n === !1 ? e.disconnect(() => K(e)) : B(e.url, t).addListener(e);
+	}, [n, e]), l(() => {
+		V(t)?.replaceUrl(t);
+	}, [t, t]), a(() => {
+		let t = r;
+		return n !== !1 && e.registerHook(r), () => {
+			e.unregisterHook(t, () => K(e));
+		};
+	}, [
+		n,
+		r,
+		e
+	]);
+}
+function Y(e) {
+	let [t] = c(() => U(e.key, e));
+	J(t, e.url, e.enabled);
+	let n = q(e);
+	return l(() => {
+		t.options = n;
+	}, [n, t]), t;
+}
+var X = (e) => {
+	let r = t(g, (t) => {
+		let n = t.get(e);
+		if (n && "uri" in n) return n;
+	}), [i] = c(() => new n(m()));
+	return r?.store ?? i;
+}, Z = (e) => {
+	let [t] = c(() => G(e.key, e));
+	return J(t, e.url, e.enabled), t;
+};
+//#endregion
+export { p as ReadyState, L as WebsocketConnection, R as WebsocketMessageApi, z as WebsocketSubscriptionApi, m as createInitialWebsocketSubscriptionStore, Z as useWebsocketMessage, Y as useWebsocketSubscription, X as useWebsocketSubscriptionByKey, _ as websocketConnectionsReconnect };
+
+//# sourceMappingURL=index.js.map