@voidhash/mimic 0.0.1 → 0.0.3

package/dist/client/ClientDocument.cjs

@@ -0,0 +1,590 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_objectSpread2 = require('../_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.cjs');
+const require_Transaction = require('../Transaction.cjs');
+const require_Document = require('../Document.cjs');
+const require_Presence = require('../Presence.cjs');
+const require_Rebase = require('./Rebase.cjs');
+const require_errors = require('./errors.cjs');
+
+//#region src/client/ClientDocument.ts
+var ClientDocument_exports = /* @__PURE__ */ require_rolldown_runtime.__export({ make: () => make });
+/**
+* Creates a new ClientDocument for the given schema.
+*/
+const make = (options) => {
+	const { schema, transport, initialState, initialVersion = 0, onRejection, onStateChange, onConnectionChange, onReady, transactionTimeout = 3e4, initTimeout = 1e4, debug = false, presence: presenceSchema, initialPresence } = options;
+	let _serverState = initialState;
+	let _serverVersion = initialVersion;
+	let _pending = [];
+	let _serverTransactionHistory = [];
+	const MAX_HISTORY_SIZE = 100;
+	let _optimisticDoc = require_Document.make(schema, { initial: _serverState });
+	let _unsubscribe = null;
+	const _timeoutHandles = /* @__PURE__ */ new Map();
+	let _initState = initialState !== void 0 ? { type: "ready" } : { type: "uninitialized" };
+	let _initTimeoutHandle = null;
+	let _initResolver = null;
+	let _initRejecter = null;
+	const _subscribers = /* @__PURE__ */ new Set();
+	let _presenceSelfId = void 0;
+	let _presenceSelfData = void 0;
+	const _presenceOthers = /* @__PURE__ */ new Map();
+	const _presenceSubscribers = /* @__PURE__ */ new Set();
+	/**
+	* Debug logging helper that only logs when debug is enabled.
+	*/
+	const debugLog = (...args) => {
+		if (debug) console.log("[ClientDocument]", ...args);
+	};
+	/**
+	* Notifies all listeners of a state change.
+	*/
+	const notifyStateChange = (state) => {
+		debugLog("notifyStateChange", {
+			state,
+			subscriberCount: _subscribers.size,
+			hasOnStateChange: !!onStateChange
+		});
+		onStateChange === null || onStateChange === void 0 || onStateChange(state);
+		for (const listener of _subscribers) {
+			var _listener$onStateChan;
+			(_listener$onStateChan = listener.onStateChange) === null || _listener$onStateChan === void 0 || _listener$onStateChan.call(listener, state);
+		}
+	};
+	/**
+	* Notifies all listeners of a connection change.
+	*/
+	const notifyConnectionChange = (connected) => {
+		debugLog("notifyConnectionChange", {
+			connected,
+			subscriberCount: _subscribers.size,
+			hasOnConnectionChange: !!onConnectionChange
+		});
+		onConnectionChange === null || onConnectionChange === void 0 || onConnectionChange(connected);
+		for (const listener of _subscribers) {
+			var _listener$onConnectio;
+			(_listener$onConnectio = listener.onConnectionChange) === null || _listener$onConnectio === void 0 || _listener$onConnectio.call(listener, connected);
+		}
+	};
+	/**
+	* Notifies all listeners when ready.
+	*/
+	const notifyReady = () => {
+		debugLog("notifyReady", {
+			subscriberCount: _subscribers.size,
+			hasOnReady: !!onReady
+		});
+		onReady === null || onReady === void 0 || onReady();
+		for (const listener of _subscribers) {
+			var _listener$onReady;
+			(_listener$onReady = listener.onReady) === null || _listener$onReady === void 0 || _listener$onReady.call(listener);
+		}
+	};
+	/**
+	* Notifies all presence listeners of a change.
+	*/
+	const notifyPresenceChange = () => {
+		debugLog("notifyPresenceChange", { subscriberCount: _presenceSubscribers.size });
+		for (const listener of _presenceSubscribers) try {
+			var _listener$onPresenceC;
+			(_listener$onPresenceC = listener.onPresenceChange) === null || _listener$onPresenceC === void 0 || _listener$onPresenceC.call(listener);
+		} catch (_unused) {}
+	};
+	/**
+	* Handles incoming presence snapshot from server.
+	*/
+	const handlePresenceSnapshot = (message) => {
+		if (!presenceSchema) return;
+		debugLog("handlePresenceSnapshot", {
+			selfId: message.selfId,
+			presenceCount: Object.keys(message.presences).length
+		});
+		_presenceSelfId = message.selfId;
+		_presenceOthers.clear();
+		for (const [id, entry] of Object.entries(message.presences)) if (id !== message.selfId) _presenceOthers.set(id, entry);
+		notifyPresenceChange();
+	};
+	/**
+	* Handles incoming presence update from server (another user).
+	*/
+	const handlePresenceUpdate = (message) => {
+		if (!presenceSchema) return;
+		debugLog("handlePresenceUpdate", {
+			id: message.id,
+			userId: message.userId
+		});
+		_presenceOthers.set(message.id, {
+			data: message.data,
+			userId: message.userId
+		});
+		notifyPresenceChange();
+	};
+	/**
+	* Handles incoming presence remove from server (user disconnected).
+	*/
+	const handlePresenceRemove = (message) => {
+		if (!presenceSchema) return;
+		debugLog("handlePresenceRemove", { id: message.id });
+		_presenceOthers.delete(message.id);
+		notifyPresenceChange();
+	};
+	/**
+	* Clears all presence state (on disconnect).
+	*/
+	const clearPresenceState = () => {
+		_presenceSelfId = void 0;
+		_presenceSelfData = void 0;
+		_presenceOthers.clear();
+		notifyPresenceChange();
+	};
+	/**
+	* Recomputes the optimistic document from server state + pending transactions.
+	*/
+	const recomputeOptimisticState = () => {
+		debugLog("recomputeOptimisticState", {
+			serverVersion: _serverVersion,
+			pendingCount: _pending.length,
+			serverState: _serverState
+		});
+		_optimisticDoc = require_Document.make(schema, { initial: _serverState });
+		for (const pending of _pending) _optimisticDoc.apply(pending.transaction.ops);
+		const newState = _optimisticDoc.get();
+		debugLog("recomputeOptimisticState: new optimistic state", newState);
+		notifyStateChange(newState);
+	};
+	/**
+	* Adds a transaction to pending queue and sends to server.
+	*/
+	const submitTransaction = (tx) => {
+		if (!transport.isConnected()) throw new require_errors.NotConnectedError();
+		debugLog("submitTransaction", {
+			txId: tx.id,
+			ops: tx.ops,
+			pendingCount: _pending.length + 1
+		});
+		const pending = {
+			transaction: tx,
+			original: tx,
+			sentAt: Date.now()
+		};
+		_pending.push(pending);
+		const timeoutHandle = setTimeout(() => {
+			handleTransactionTimeout(tx.id);
+		}, transactionTimeout);
+		_timeoutHandles.set(tx.id, timeoutHandle);
+		transport.send(tx);
+		debugLog("submitTransaction: sent to server", { txId: tx.id });
+	};
+	/**
+	* Handles a transaction timeout.
+	*/
+	const handleTransactionTimeout = (txId) => {
+		debugLog("handleTransactionTimeout", { txId });
+		const index = _pending.findIndex((p) => p.transaction.id === txId);
+		if (index === -1) {
+			debugLog("handleTransactionTimeout: transaction not found (already confirmed/rejected)", { txId });
+			return;
+		}
+		const [removed] = _pending.splice(index, 1);
+		_timeoutHandles.delete(txId);
+		debugLog("handleTransactionTimeout: removed from pending", {
+			txId,
+			remainingPending: _pending.length
+		});
+		recomputeOptimisticState();
+		onRejection === null || onRejection === void 0 || onRejection(removed.transaction, "Transaction timed out");
+	};
+	/**
+	* Handles an incoming server transaction.
+	*/
+	const handleServerTransaction = (serverTx, version) => {
+		debugLog("handleServerTransaction", {
+			txId: serverTx.id,
+			version,
+			ops: serverTx.ops,
+			currentServerVersion: _serverVersion,
+			pendingCount: _pending.length
+		});
+		_serverVersion = version;
+		const pendingIndex = _pending.findIndex((p) => p.transaction.id === serverTx.id);
+		if (pendingIndex !== -1) {
+			debugLog("handleServerTransaction: transaction confirmed (ACK)", {
+				txId: serverTx.id,
+				pendingIndex
+			});
+			_pending[pendingIndex];
+			const timeoutHandle = _timeoutHandles.get(serverTx.id);
+			if (timeoutHandle) {
+				clearTimeout(timeoutHandle);
+				_timeoutHandles.delete(serverTx.id);
+			}
+			_pending.splice(pendingIndex, 1);
+			const tempDoc = require_Document.make(schema, { initial: _serverState });
+			tempDoc.apply(serverTx.ops);
+			_serverState = tempDoc.get();
+			debugLog("handleServerTransaction: updated server state", {
+				txId: serverTx.id,
+				newServerState: _serverState,
+				remainingPending: _pending.length
+			});
+			recomputeOptimisticState();
+		} else {
+			debugLog("handleServerTransaction: remote transaction, rebasing pending", {
+				txId: serverTx.id,
+				pendingCount: _pending.length
+			});
+			const tempDoc = require_Document.make(schema, { initial: _serverState });
+			tempDoc.apply(serverTx.ops);
+			_serverState = tempDoc.get();
+			_serverTransactionHistory.push(serverTx);
+			if (_serverTransactionHistory.length > MAX_HISTORY_SIZE) _serverTransactionHistory.shift();
+			const rebasedPending = _pending.map((p) => require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, p), {}, { transaction: require_Rebase.transformTransactionWithPrimitive(p.transaction, serverTx, schema) }));
+			debugLog("handleServerTransaction: rebased pending transactions", {
+				txId: serverTx.id,
+				rebasedCount: rebasedPending.length,
+				originalPendingIds: _pending.map((p) => p.transaction.id),
+				rebasedPendingIds: rebasedPending.map((p) => p.transaction.id)
+			});
+			_pending = rebasedPending;
+			recomputeOptimisticState();
+		}
+	};
+	/**
+	* Handles a transaction rejection from the server.
+	*/
+	const handleRejection = (txId, reason) => {
+		debugLog("handleRejection", {
+			txId,
+			reason,
+			pendingCount: _pending.length
+		});
+		const index = _pending.findIndex((p) => p.transaction.id === txId);
+		if (index === -1) {
+			debugLog("handleRejection: transaction not found (already removed)", { txId });
+			return;
+		}
+		const rejected = _pending[index];
+		const timeoutHandle = _timeoutHandles.get(txId);
+		if (timeoutHandle) {
+			clearTimeout(timeoutHandle);
+			_timeoutHandles.delete(txId);
+		}
+		_pending.splice(index, 1);
+		debugLog("handleRejection: removed rejected transaction, rebasing remaining", {
+			txId,
+			remainingPending: _pending.length,
+			serverHistorySize: _serverTransactionHistory.length
+		});
+		const remainingOriginals = _pending.map((p) => p.original);
+		const retransformed = require_Rebase.rebaseAfterRejectionWithPrimitive([...remainingOriginals, rejected.original], txId, _serverTransactionHistory, schema);
+		_pending = _pending.map((p, i) => {
+			var _retransformed$i;
+			return require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, p), {}, { transaction: (_retransformed$i = retransformed[i]) !== null && _retransformed$i !== void 0 ? _retransformed$i : p.transaction });
+		});
+		debugLog("handleRejection: rebased remaining transactions", {
+			txId,
+			rebasedCount: _pending.length
+		});
+		recomputeOptimisticState();
+		onRejection === null || onRejection === void 0 || onRejection(rejected.original, reason);
+	};
+	/**
+	* Handles a snapshot from the server.
+	* @param isInitialSnapshot - If true, this is the initial sync snapshot
+	*/
+	const handleSnapshot = (state, version, isInitialSnapshot = false) => {
+		debugLog("handleSnapshot", {
+			isInitialSnapshot,
+			version,
+			currentServerVersion: _serverVersion,
+			pendingCount: _pending.length,
+			state
+		});
+		if (!isInitialSnapshot) {
+			debugLog("handleSnapshot: non-initial snapshot, clearing pending transactions", { clearedPendingCount: _pending.length });
+			for (const handle of _timeoutHandles.values()) clearTimeout(handle);
+			_timeoutHandles.clear();
+			for (const pending of _pending) onRejection === null || onRejection === void 0 || onRejection(pending.original, "State reset due to resync");
+			_pending = [];
+		}
+		_serverTransactionHistory = [];
+		_serverState = state;
+		_serverVersion = version;
+		debugLog("handleSnapshot: updated server state", {
+			newVersion: _serverVersion,
+			newState: _serverState
+		});
+		recomputeOptimisticState();
+	};
+	/**
+	* Processes buffered messages after receiving the initial snapshot.
+	* Filters out transactions already included in the snapshot (version <= snapshotVersion)
+	* and applies newer transactions in order.
+	*/
+	const processBufferedMessages = (bufferedMessages, snapshotVersion) => {
+		debugLog("processBufferedMessages", {
+			bufferedCount: bufferedMessages.length,
+			snapshotVersion
+		});
+		const sortedMessages = [...bufferedMessages].sort((a, b) => {
+			if (a.type === "transaction" && b.type === "transaction") return a.version - b.version;
+			return 0;
+		});
+		for (const message of sortedMessages) switch (message.type) {
+			case "transaction":
+				if (message.version > snapshotVersion) {
+					debugLog("processBufferedMessages: applying buffered transaction", {
+						txId: message.transaction.id,
+						version: message.version,
+						snapshotVersion
+					});
+					handleServerTransaction(message.transaction, message.version);
+				} else debugLog("processBufferedMessages: skipping buffered transaction (already in snapshot)", {
+					txId: message.transaction.id,
+					version: message.version,
+					snapshotVersion
+				});
+				break;
+			case "error":
+				debugLog("processBufferedMessages: processing buffered error", {
+					txId: message.transactionId,
+					reason: message.reason
+				});
+				handleRejection(message.transactionId, message.reason);
+				break;
+		}
+	};
+	/**
+	* Completes initialization and transitions to ready state.
+	*/
+	const completeInitialization = () => {
+		debugLog("completeInitialization");
+		if (_initTimeoutHandle !== null) {
+			clearTimeout(_initTimeoutHandle);
+			_initTimeoutHandle = null;
+		}
+		_initState = { type: "ready" };
+		if (_initResolver) {
+			_initResolver();
+			_initResolver = null;
+			_initRejecter = null;
+		}
+		debugLog("completeInitialization: ready", {
+			serverVersion: _serverVersion,
+			serverState: _serverState
+		});
+		notifyReady();
+	};
+	/**
+	* Handles initialization timeout.
+	*/
+	const handleInitTimeout = () => {
+		debugLog("handleInitTimeout: initialization timed out");
+		_initTimeoutHandle = null;
+		if (_initRejecter) {
+			_initRejecter(/* @__PURE__ */ new Error("Initialization timed out waiting for snapshot"));
+			_initResolver = null;
+			_initRejecter = null;
+		}
+		_initState = { type: "uninitialized" };
+	};
+	/**
+	* Handles incoming server messages.
+	* During initialization, messages are buffered until the snapshot arrives.
+	* Presence messages are always processed immediately (not buffered).
+	*/
+	const handleServerMessage = (message) => {
+		debugLog("handleServerMessage", {
+			messageType: message.type,
+			initState: _initState.type
+		});
+		if (message.type === "presence_snapshot") {
+			handlePresenceSnapshot(message);
+			return;
+		}
+		if (message.type === "presence_update") {
+			handlePresenceUpdate(message);
+			return;
+		}
+		if (message.type === "presence_remove") {
+			handlePresenceRemove(message);
+			return;
+		}
+		if (_initState.type === "initializing") {
+			if (message.type === "snapshot") {
+				debugLog("handleServerMessage: received snapshot during initialization", {
+					version: message.version,
+					bufferedCount: _initState.bufferedMessages.length
+				});
+				const buffered = _initState.bufferedMessages;
+				handleSnapshot(message.state, message.version, true);
+				processBufferedMessages(buffered, message.version);
+				completeInitialization();
+			} else {
+				debugLog("handleServerMessage: buffering message during initialization", {
+					messageType: message.type,
+					bufferedCount: _initState.bufferedMessages.length + 1
+				});
+				_initState.bufferedMessages.push(message);
+			}
+			return;
+		}
+		switch (message.type) {
+			case "transaction":
+				handleServerTransaction(message.transaction, message.version);
+				break;
+			case "snapshot":
+				handleSnapshot(message.state, message.version, false);
+				break;
+			case "error":
+				handleRejection(message.transactionId, message.reason);
+				break;
+		}
+	};
+	return {
+		schema,
+		get root() {
+			return _optimisticDoc.root;
+		},
+		get: () => _optimisticDoc.get(),
+		getServerState: () => _serverState,
+		getServerVersion: () => _serverVersion,
+		getPendingCount: () => _pending.length,
+		hasPendingChanges: () => _pending.length > 0,
+		transaction: (fn) => {
+			debugLog("transaction: starting", {
+				isConnected: transport.isConnected(),
+				isReady: _initState.type === "ready",
+				pendingCount: _pending.length
+			});
+			if (!transport.isConnected()) throw new require_errors.NotConnectedError();
+			if (_initState.type !== "ready") throw new require_errors.InvalidStateError("Client is not ready. Wait for initialization to complete.");
+			const result = _optimisticDoc.transaction(fn);
+			const tx = _optimisticDoc.flush();
+			if (!require_Transaction.isEmpty(tx)) {
+				debugLog("transaction: flushed, submitting", {
+					txId: tx.id,
+					opsCount: tx.ops.length
+				});
+				submitTransaction(tx);
+			} else debugLog("transaction: flushed, empty transaction (no ops)");
+			notifyStateChange(_optimisticDoc.get());
+			return result;
+		},
+		connect: async () => {
+			debugLog("connect: starting");
+			_unsubscribe = transport.subscribe(handleServerMessage);
+			await transport.connect();
+			debugLog("connect: transport connected");
+			notifyConnectionChange(true);
+			if (presenceSchema && initialPresence !== void 0) {
+				debugLog("connect: setting initial presence", { initialPresence });
+				const validated = require_Presence.validate(presenceSchema, initialPresence);
+				_presenceSelfData = validated;
+				transport.sendPresenceSet(validated);
+				notifyPresenceChange();
+			}
+			if (_initState.type === "ready") {
+				debugLog("connect: already ready (has initial state)");
+				notifyReady();
+				return;
+			}
+			_initState = {
+				type: "initializing",
+				bufferedMessages: []
+			};
+			debugLog("connect: entering initializing state", { initTimeout });
+			_initTimeoutHandle = setTimeout(handleInitTimeout, initTimeout);
+			const readyPromise = new Promise((resolve, reject) => {
+				_initResolver = resolve;
+				_initRejecter = reject;
+			});
+			debugLog("connect: requesting initial snapshot");
+			transport.requestSnapshot();
+			await readyPromise;
+			debugLog("connect: completed");
+		},
+		disconnect: () => {
+			debugLog("disconnect: starting", {
+				pendingCount: _pending.length,
+				initState: _initState.type
+			});
+			for (const handle of _timeoutHandles.values()) clearTimeout(handle);
+			_timeoutHandles.clear();
+			if (_initTimeoutHandle !== null) {
+				clearTimeout(_initTimeoutHandle);
+				_initTimeoutHandle = null;
+			}
+			if (_initRejecter) {
+				_initRejecter(/* @__PURE__ */ new Error("Disconnected during initialization"));
+				_initResolver = null;
+				_initRejecter = null;
+			}
+			if (_initState.type === "initializing") _initState = { type: "uninitialized" };
+			clearPresenceState();
+			if (_unsubscribe) {
+				_unsubscribe();
+				_unsubscribe = null;
+			}
+			transport.disconnect();
+			notifyConnectionChange(false);
+			debugLog("disconnect: completed");
+		},
+		isConnected: () => transport.isConnected(),
+		isReady: () => _initState.type === "ready",
+		resync: () => {
+			debugLog("resync: requesting snapshot", {
+				currentVersion: _serverVersion,
+				pendingCount: _pending.length
+			});
+			if (!transport.isConnected()) throw new require_errors.NotConnectedError();
+			transport.requestSnapshot();
+		},
+		subscribe: (listener) => {
+			_subscribers.add(listener);
+			return () => {
+				_subscribers.delete(listener);
+			};
+		},
+		presence: presenceSchema ? {
+			selfId: () => _presenceSelfId,
+			self: () => _presenceSelfData,
+			others: () => _presenceOthers,
+			all: () => {
+				const all = /* @__PURE__ */ new Map();
+				for (const [id, entry] of _presenceOthers) all.set(id, entry);
+				if (_presenceSelfId !== void 0 && _presenceSelfData !== void 0) all.set(_presenceSelfId, { data: _presenceSelfData });
+				return all;
+			},
+			set: (data) => {
+				if (!presenceSchema) return;
+				const validated = require_Presence.validate(presenceSchema, data);
+				debugLog("presence.set", { data: validated });
+				_presenceSelfData = validated;
+				transport.sendPresenceSet(validated);
+				notifyPresenceChange();
+			},
+			clear: () => {
+				if (!presenceSchema) return;
+				debugLog("presence.clear");
+				_presenceSelfData = void 0;
+				transport.sendPresenceClear();
+				notifyPresenceChange();
+			},
+			subscribe: (listener) => {
+				_presenceSubscribers.add(listener);
+				return () => {
+					_presenceSubscribers.delete(listener);
+				};
+			}
+		} : void 0
+	};
+};
+
+//#endregion
+Object.defineProperty(exports, 'ClientDocument_exports', {
+  enumerable: true,
+  get: function () {
+    return ClientDocument_exports;
+  }
+});