@voidhash/mimic 0.0.2 → 0.0.3

package/dist/client/WebSocketTransport.cjs

@@ -0,0 +1,396 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_Transaction = require('../Transaction.cjs');
+const require_errors = require('./errors.cjs');
+
+//#region src/client/WebSocketTransport.ts
+var WebSocketTransport_exports = /* @__PURE__ */ require_rolldown_runtime.__export({ make: () => make });
+/**
+* Creates a WebSocket-based transport for real-time server communication.
+*/
+/**
+* Build the WebSocket URL with optional document ID path.
+*/
+const buildWebSocketUrl = (baseUrl, documentId) => {
+	if (!documentId) return baseUrl;
+	return `${baseUrl.replace(/\/+$/, "")}/doc/${encodeURIComponent(documentId)}`;
+};
+const make = (options) => {
+	const { url: baseUrl, documentId, protocols, authToken, onEvent, connectionTimeout = 1e4, autoReconnect = true, maxReconnectAttempts = 10, reconnectDelay = 1e3, maxReconnectDelay = 3e4, heartbeatInterval = 3e4, heartbeatTimeout = 1e4 } = options;
+	const url = buildWebSocketUrl(baseUrl, documentId);
+	let _state = { type: "disconnected" };
+	let _ws = null;
+	let _messageHandlers = /* @__PURE__ */ new Set();
+	let _connectionTimeoutHandle = null;
+	let _heartbeatIntervalHandle = null;
+	let _heartbeatTimeoutHandle = null;
+	let _reconnectTimeoutHandle = null;
+	let _messageQueue = [];
+	let _connectResolver = null;
+	let _connectRejecter = null;
+	let _reconnectAttempt = 0;
+	const emit = (handler, event) => {
+		handler === null || handler === void 0 || handler(event);
+	};
+	/**
+	* Encodes a client message for network transport.
+	*/
+	const encodeClientMessage = (message) => {
+		if (message.type === "submit") return {
+			type: "submit",
+			transaction: require_Transaction.encode(message.transaction)
+		};
+		return message;
+	};
+	/**
+	* Decodes a server message from network transport.
+	*/
+	const decodeServerMessage = (encoded) => {
+		if (encoded.type === "transaction") return {
+			type: "transaction",
+			transaction: require_Transaction.decode(encoded.transaction),
+			version: encoded.version
+		};
+		return encoded;
+	};
+	/**
+	* Sends a raw message over the WebSocket.
+	*/
+	const sendRaw = (message) => {
+		if (_ws && _ws.readyState === WebSocket.OPEN) _ws.send(JSON.stringify(encodeClientMessage(message)));
+	};
+	/**
+	* Clears all active timers.
+	*/
+	const clearTimers = () => {
+		if (_connectionTimeoutHandle) {
+			clearTimeout(_connectionTimeoutHandle);
+			_connectionTimeoutHandle = null;
+		}
+		if (_heartbeatIntervalHandle) {
+			clearInterval(_heartbeatIntervalHandle);
+			_heartbeatIntervalHandle = null;
+		}
+		if (_heartbeatTimeoutHandle) {
+			clearTimeout(_heartbeatTimeoutHandle);
+			_heartbeatTimeoutHandle = null;
+		}
+		if (_reconnectTimeoutHandle) {
+			clearTimeout(_reconnectTimeoutHandle);
+			_reconnectTimeoutHandle = null;
+		}
+	};
+	/**
+	* Starts the heartbeat mechanism.
+	*/
+	const startHeartbeat = () => {
+		stopHeartbeat();
+		_heartbeatIntervalHandle = setInterval(() => {
+			if (_state.type !== "connected") return;
+			sendRaw({ type: "ping" });
+			_heartbeatTimeoutHandle = setTimeout(() => {
+				handleConnectionLost("Heartbeat timeout");
+			}, heartbeatTimeout);
+		}, heartbeatInterval);
+	};
+	/**
+	* Stops the heartbeat mechanism.
+	*/
+	const stopHeartbeat = () => {
+		if (_heartbeatIntervalHandle) {
+			clearInterval(_heartbeatIntervalHandle);
+			_heartbeatIntervalHandle = null;
+		}
+		if (_heartbeatTimeoutHandle) {
+			clearTimeout(_heartbeatTimeoutHandle);
+			_heartbeatTimeoutHandle = null;
+		}
+	};
+	/**
+	* Handles pong response - clears the heartbeat timeout.
+	*/
+	const handlePong = () => {
+		if (_heartbeatTimeoutHandle) {
+			clearTimeout(_heartbeatTimeoutHandle);
+			_heartbeatTimeoutHandle = null;
+		}
+	};
+	/**
+	* Flushes the message queue after reconnection.
+	*/
+	const flushMessageQueue = () => {
+		const queue = _messageQueue;
+		_messageQueue = [];
+		for (const message of queue) sendRaw(message);
+	};
+	/**
+	* Calculates reconnection delay with exponential backoff.
+	*/
+	const getReconnectDelay = (attempt) => {
+		const delay = reconnectDelay * Math.pow(2, attempt);
+		return Math.min(delay, maxReconnectDelay);
+	};
+	/**
+	* Resolves the auth token (handles both string and function).
+	* Returns empty string if no token is configured.
+	*/
+	const resolveAuthToken = async () => {
+		if (!authToken) return "";
+		if (typeof authToken === "string") return authToken;
+		return authToken();
+	};
+	/**
+	* Performs authentication after connection.
+	* Always sends an auth message (even with empty token) to trigger server auth flow.
+	*/
+	const authenticate = async () => {
+		const token = await resolveAuthToken();
+		_state = { type: "authenticating" };
+		sendRaw({
+			type: "auth",
+			token
+		});
+	};
+	/**
+	* Handles authentication result from server.
+	*/
+	const handleAuthResult = (success, error) => {
+		if (!success) {
+			const authError = new require_errors.AuthenticationError(error || "Authentication failed");
+			cleanup();
+			_connectRejecter === null || _connectRejecter === void 0 || _connectRejecter(authError);
+			_connectResolver = null;
+			_connectRejecter = null;
+			emit(onEvent, {
+				type: "error",
+				error: authError
+			});
+			return;
+		}
+		completeConnection();
+	};
+	/**
+	* Completes the connection process.
+	*/
+	const completeConnection = () => {
+		_state = { type: "connected" };
+		_reconnectAttempt = 0;
+		if (_connectionTimeoutHandle) {
+			clearTimeout(_connectionTimeoutHandle);
+			_connectionTimeoutHandle = null;
+		}
+		startHeartbeat();
+		flushMessageQueue();
+		_connectResolver === null || _connectResolver === void 0 || _connectResolver();
+		_connectResolver = null;
+		_connectRejecter = null;
+		emit(onEvent, { type: "connected" });
+	};
+	/**
+	* Cleans up WebSocket and related state.
+	*/
+	const cleanup = () => {
+		clearTimers();
+		if (_ws) {
+			_ws.onopen = null;
+			_ws.onclose = null;
+			_ws.onerror = null;
+			_ws.onmessage = null;
+			if (_ws.readyState === WebSocket.OPEN || _ws.readyState === WebSocket.CONNECTING) _ws.close();
+			_ws = null;
+		}
+	};
+	/**
+	* Handles connection lost - initiates reconnection if enabled.
+	*/
+	const handleConnectionLost = (reason) => {
+		cleanup();
+		if (_state.type === "disconnected") return;
+		if (_connectRejecter !== null) {
+			_state = { type: "disconnected" };
+			_reconnectAttempt = 0;
+			_connectRejecter(new require_errors.WebSocketError("Connection failed", void 0, reason));
+			_connectResolver = null;
+			_connectRejecter = null;
+			emit(onEvent, {
+				type: "disconnected",
+				reason
+			});
+			return;
+		}
+		if (!autoReconnect) {
+			_state = { type: "disconnected" };
+			_reconnectAttempt = 0;
+			emit(onEvent, {
+				type: "disconnected",
+				reason
+			});
+			return;
+		}
+		_reconnectAttempt++;
+		if (_reconnectAttempt > maxReconnectAttempts) {
+			_state = { type: "disconnected" };
+			_reconnectAttempt = 0;
+			emit(onEvent, {
+				type: "disconnected",
+				reason: "Max reconnection attempts reached"
+			});
+			return;
+		}
+		_state = {
+			type: "reconnecting",
+			attempt: _reconnectAttempt
+		};
+		emit(onEvent, {
+			type: "reconnecting",
+			attempt: _reconnectAttempt
+		});
+		const delay = getReconnectDelay(_reconnectAttempt - 1);
+		_reconnectTimeoutHandle = setTimeout(() => {
+			_reconnectTimeoutHandle = null;
+			attemptConnection();
+		}, delay);
+	};
+	/**
+	* Attempts to establish WebSocket connection.
+	*/
+	const attemptConnection = () => {
+		if (_state.type === "connected") return;
+		_state = { type: "connecting" };
+		try {
+			_ws = new WebSocket(url, protocols);
+		} catch (error) {
+			handleConnectionLost(error.message);
+			return;
+		}
+		_connectionTimeoutHandle = setTimeout(() => {
+			_connectionTimeoutHandle = null;
+			handleConnectionLost("Connection timeout");
+		}, connectionTimeout);
+		_ws.onopen = async () => {
+			if (_connectionTimeoutHandle) {
+				clearTimeout(_connectionTimeoutHandle);
+				_connectionTimeoutHandle = null;
+			}
+			try {
+				await authenticate();
+			} catch (error) {
+				handleConnectionLost(error.message);
+			}
+		};
+		_ws.onclose = (event) => {
+			handleConnectionLost(event.reason || `Connection closed (code: ${event.code})`);
+		};
+		_ws.onerror = () => {};
+		_ws.onmessage = (event) => {
+			try {
+				handleMessage(decodeServerMessage(JSON.parse(event.data)));
+			} catch (_unused) {}
+		};
+	};
+	/**
+	* Handles incoming server messages.
+	*/
+	const handleMessage = (message) => {
+		if (message.type === "pong") {
+			handlePong();
+			return;
+		}
+		if (message.type === "auth_result") {
+			handleAuthResult(message.success, message.error);
+			return;
+		}
+		for (const handler of _messageHandlers) try {
+			handler(message);
+		} catch (_unused2) {}
+	};
+	return {
+		send: (transaction) => {
+			const message = {
+				type: "submit",
+				transaction
+			};
+			if (_state.type === "connected") sendRaw(message);
+			else if (_state.type === "reconnecting") _messageQueue.push(message);
+		},
+		requestSnapshot: () => {
+			const message = { type: "request_snapshot" };
+			if (_state.type === "connected") sendRaw(message);
+			else if (_state.type === "reconnecting") _messageQueue.push(message);
+		},
+		subscribe: (handler) => {
+			_messageHandlers.add(handler);
+			return () => {
+				_messageHandlers.delete(handler);
+			};
+		},
+		connect: async () => {
+			if (_state.type === "connected") return;
+			if (_state.type === "connecting" || _state.type === "authenticating") return new Promise((resolve, reject) => {
+				const existingResolver = _connectResolver;
+				const existingRejecter = _connectRejecter;
+				_connectResolver = () => {
+					existingResolver === null || existingResolver === void 0 || existingResolver();
+					resolve();
+				};
+				_connectRejecter = (error) => {
+					existingRejecter === null || existingRejecter === void 0 || existingRejecter(error);
+					reject(error);
+				};
+			});
+			return new Promise((resolve, reject) => {
+				_connectResolver = resolve;
+				_connectRejecter = reject;
+				attemptConnection();
+			});
+		},
+		disconnect: () => {
+			if (_reconnectTimeoutHandle) {
+				clearTimeout(_reconnectTimeoutHandle);
+				_reconnectTimeoutHandle = null;
+			}
+			if (_connectRejecter) {
+				_connectRejecter(new require_errors.WebSocketError("Disconnected by user"));
+				_connectResolver = null;
+				_connectRejecter = null;
+			}
+			cleanup();
+			_state = { type: "disconnected" };
+			_reconnectAttempt = 0;
+			_messageQueue = [];
+			emit(onEvent, {
+				type: "disconnected",
+				reason: "User disconnected"
+			});
+		},
+		isConnected: () => {
+			return _state.type === "connected";
+		},
+		sendPresenceSet: (data) => {
+			const message = {
+				type: "presence_set",
+				data
+			};
+			if (_state.type === "connected") sendRaw(message);
+			else if (_state.type === "reconnecting") {
+				_messageQueue = _messageQueue.filter((message$1) => message$1.type !== "presence_set");
+				_messageQueue.push(message);
+			}
+		},
+		sendPresenceClear: () => {
+			const message = { type: "presence_clear" };
+			if (_state.type === "connected") sendRaw(message);
+			else if (_state.type === "reconnecting") {
+				_messageQueue = _messageQueue.filter((message$1) => message$1.type !== "presence_clear");
+				_messageQueue.push(message);
+			}
+		}
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, 'WebSocketTransport_exports', {
+  enumerable: true,
+  get: function () {
+    return WebSocketTransport_exports;
+  }
+});

package/dist/client/WebSocketTransport.d.cts

@@ -0,0 +1,29 @@
+import { Transport, TransportOptions } from "./Transport.cjs";
+
+//#region src/client/WebSocketTransport.d.ts
+declare namespace WebSocketTransport_d_exports {
+  export { WebSocketTransportOptions, make };
+}
+/**
+ * Options for creating a WebSocket transport.
+ */
+interface WebSocketTransportOptions extends TransportOptions {
+  /** WebSocket URL (ws:// or wss://) - base URL without document path */
+  readonly url: string;
+  /** Document ID to connect to. Will be appended to URL as /doc/{documentId} */
+  readonly documentId?: string;
+  /** WebSocket subprotocols */
+  readonly protocols?: string[];
+  /** Authentication token or function that returns a token */
+  readonly authToken?: string | (() => string | Promise<string>);
+  /** Interval between heartbeat pings (ms). Default: 30000 */
+  readonly heartbeatInterval?: number;
+  /** Timeout to wait for pong response (ms). Default: 10000 */
+  readonly heartbeatTimeout?: number;
+  /** Maximum delay between reconnection attempts (ms). Default: 30000 */
+  readonly maxReconnectDelay?: number;
+}
+declare const make: (options: WebSocketTransportOptions) => Transport;
+//#endregion
+export { WebSocketTransport_d_exports };
+//# sourceMappingURL=WebSocketTransport.d.cts.map

package/dist/client/WebSocketTransport.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketTransport.d.cts","names":[],"sources":["../../src/client/WebSocketTransport.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAYiB,yBAAA,SAAkC;;;;EAAlC,SAAA,UAAA,CAAA,EAAA,MAA0B;EAiD9B;;;gDAzCmC;;;;;;;;cAyCnC,gBAAiB,8BAA4B"}

package/dist/client/WebSocketTransport.d.mts

@@ -0,0 +1,29 @@
+import { Transport, TransportOptions } from "./Transport.mjs";
+
+//#region src/client/WebSocketTransport.d.ts
+declare namespace WebSocketTransport_d_exports {
+  export { WebSocketTransportOptions, make };
+}
+/**
+ * Options for creating a WebSocket transport.
+ */
+interface WebSocketTransportOptions extends TransportOptions {
+  /** WebSocket URL (ws:// or wss://) - base URL without document path */
+  readonly url: string;
+  /** Document ID to connect to. Will be appended to URL as /doc/{documentId} */
+  readonly documentId?: string;
+  /** WebSocket subprotocols */
+  readonly protocols?: string[];
+  /** Authentication token or function that returns a token */
+  readonly authToken?: string | (() => string | Promise<string>);
+  /** Interval between heartbeat pings (ms). Default: 30000 */
+  readonly heartbeatInterval?: number;
+  /** Timeout to wait for pong response (ms). Default: 10000 */
+  readonly heartbeatTimeout?: number;
+  /** Maximum delay between reconnection attempts (ms). Default: 30000 */
+  readonly maxReconnectDelay?: number;
+}
+declare const make: (options: WebSocketTransportOptions) => Transport;
+//#endregion
+export { WebSocketTransport_d_exports };
+//# sourceMappingURL=WebSocketTransport.d.mts.map

package/dist/client/WebSocketTransport.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketTransport.d.mts","names":[],"sources":["../../src/client/WebSocketTransport.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UAYiB,yBAAA,SAAkC;;;;EAAlC,SAAA,UAAA,CAAA,EAAA,MAA0B;EAiD9B;;;gDAzCmC;;;;;;;;cAyCnC,gBAAiB,8BAA4B"}