@wildo-ai/saas-frontend-lib 1.0.1

package/dist/esm/core/requests/websockets/WebSocketContext.js

@@ -0,0 +1,812 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useState, useEffect, useRef, useCallback, useMemo } from 'react';
+import { io } from 'socket.io-client';
+import axios from 'axios';
+import { errorManagement } from '../../../core/errors/error-management.frontend.service.js';
+import { ResourceOperationRiskLevel, WildoHeaderKeys } from '@wildo-ai/saas-models';
+import { CoreWebSocketEvent, buildResourceRoomName, buildScopeRoomName, safeValidateWebSocketPayload, WebSocketEventSchemas, } from '@wildo-ai/saas-models';
+/**
+ * WebSocket Context
+ * Manages Socket.IO connections and real-time communication
+ * Integrates with the EventBus for event-driven architecture
+ */
+export var WebSocketStatus;
+(function (WebSocketStatus) {
+    WebSocketStatus["DISCONNECTED"] = "disconnected";
+    WebSocketStatus["CONNECTING"] = "connecting";
+    WebSocketStatus["CONNECTED"] = "connected";
+    WebSocketStatus["ERROR"] = "error";
+    WebSocketStatus["RECONNECTING"] = "reconnecting";
+})(WebSocketStatus || (WebSocketStatus = {}));
+function roomMatchesOrganization(room, organizationId) {
+    if (!organizationId) {
+        return false;
+    }
+    if (room.scopeId === organizationId) {
+        return true;
+    }
+    return Object.values(room.contextResourceIdentifiers).includes(organizationId);
+}
+/**
+ * WebSocket Context
+ * Exported for use in separate hook file (Fast Refresh compatibility)
+ * @internal - Use useWebSocket() hook instead of accessing this directly
+ */
+export const WebSocketContext = createContext(undefined);
+export const WebSocketProvider = ({ children }) => {
+    const [status, setStatus] = useState(WebSocketStatus.DISCONNECTED);
+    const [connectionCount, setConnectionCount] = useState(0);
+    const [error, setError] = useState(null);
+    const [subscribedRooms, setSubscribedRooms] = useState([]);
+    const socketRef = useRef(null);
+    const configRef = useRef(null);
+    const reconnectTimeoutRef = useRef(null);
+    const reconnectAttemptsRef = useRef(0);
+    const connectedAtRef = useRef(null);
+    const roomClaimsRef = useRef(new Map());
+    const eventListenersRef = useRef(new Map());
+    const eventListenerWrappersRef = useRef(new Map());
+    const connectRequestIdRef = useRef(0);
+    const connectKeyRef = useRef(null);
+    const connectInFlightRef = useRef(false);
+    /**
+     * Build room name from parameters
+     */
+    const buildRoomName = useCallback((params) => {
+        if (params.resourceId) {
+            return buildResourceRoomName(params.resourceType, params.resourceId);
+        }
+        if (params.scopeKey && params.scopeId) {
+            return buildScopeRoomName(params.resourceType, params.scopeKey, params.scopeId);
+        }
+        throw new Error('Must provide either resourceId or both scopeKey and scopeId');
+    }, []);
+    const syncSubscribedRoomsFromClaims = useCallback(() => {
+        setSubscribedRooms(Array.from(roomClaimsRef.current.values(), (room) => ({
+            roomName: room.roomName,
+            resourceType: room.resourceType,
+            resourceId: room.resourceId,
+            scopeKey: room.scopeKey,
+            scopeId: room.scopeId,
+            contextResourceIdentifiers: room.contextResourceIdentifiers,
+        })));
+    }, []);
+    const getSocketListener = useCallback((event, handler) => {
+        const wrappers = eventListenerWrappersRef.current.get(event) ?? new Map();
+        eventListenerWrappersRef.current.set(event, wrappers);
+        const existingWrapper = wrappers.get(handler);
+        if (existingWrapper) {
+            return existingWrapper;
+        }
+        const wrappedHandler = (payload) => {
+            if (event in WebSocketEventSchemas) {
+                const validationResult = safeValidateWebSocketPayload(event, payload);
+                if ('data' in validationResult) {
+                    handler(validationResult.data);
+                    return;
+                }
+                console.warn('Dropped invalid websocket payload at client ingress boundary', {
+                    event,
+                    issues: validationResult.error.issues,
+                });
+                return;
+            }
+            handler(payload);
+        };
+        wrappers.set(handler, wrappedHandler);
+        return wrappedHandler;
+    }, []);
+    const attachRegisteredEventListeners = useCallback((socket) => {
+        for (const [event, handlers] of eventListenersRef.current.entries()) {
+            for (const handler of handlers) {
+                socket.on(event, getSocketListener(event, handler));
+            }
+        }
+    }, [getSocketListener]);
+    const buildConnectKey = useCallback((config) => JSON.stringify({
+        url: config.url,
+        token: config.token ?? null,
+        organizationId: config.organizationId ?? null,
+        consumableToken: config.consumableToken ?? null,
+    }), []);
+    /**
+     * Convert WebSocket URL to HTTP URL for readiness check
+     * ws:// -> http://, wss:// -> https://
+     */
+    const wsUrlToHttpUrl = useCallback((wsUrl) => {
+        return wsUrl.replace(/^ws/, 'http');
+    }, []);
+    /**
+     * Wait for API readiness before WebSocket connection
+     * Uses exponential backoff: 2^attempts * 100ms, capped at 10s
+     * Has a maximum wait time of 30s before proceeding anyway
+     * @returns true if API is ready, false if we timed out (still proceeds with connection)
+     */
+    const waitForApiReadiness = useCallback(async (wsUrl) => {
+        const httpUrl = wsUrlToHttpUrl(wsUrl);
+        const healthUrl = `${httpUrl}/health/ready`;
+        const BASE_DELAY_MS = 100;
+        const MAX_DELAY_MS = 10000;
+        const MAX_WAIT_TIME_MS = 30000; // Maximum time to wait before proceeding anyway
+        const startTime = Date.now();
+        let attempt = 0;
+        console.log('WebSocket: Waiting for API readiness...', { healthUrl });
+        while (true) {
+            try {
+                const response = await axios.get(healthUrl, {
+                    timeout: 5000,
+                    validateStatus: () => true, // Don't throw on non-2xx
+                });
+                if (response.status === 200 && response.data?.status === 'healthy') {
+                    console.log('WebSocket: API is ready', { healthUrl, attempts: attempt + 1 });
+                    return true;
+                }
+            }
+            catch (error) {
+                // Network error, CORS error, timeout - all treated the same
+            }
+            // Check if we've exceeded maximum wait time
+            const elapsedTime = Date.now() - startTime;
+            if (elapsedTime >= MAX_WAIT_TIME_MS) {
+                console.warn('WebSocket: API readiness check timed out, proceeding with connection anyway', {
+                    healthUrl,
+                    elapsedMs: elapsedTime,
+                    attempts: attempt + 1,
+                });
+                return false;
+            }
+            // Calculate delay with exponential backoff
+            const delay = Math.min(Math.pow(2, attempt) * BASE_DELAY_MS, MAX_DELAY_MS);
+            console.warn(`WebSocket: API not ready (attempt ${attempt + 1}), retrying in ${delay}ms...`, {
+                healthUrl,
+                elapsedMs: elapsedTime,
+            });
+            await new Promise(resolve => setTimeout(resolve, delay));
+            attempt++;
+        }
+    }, [wsUrlToHttpUrl]);
+    /**
+     * Perform the Socket.IO connection
+     */
+    const performActualConnect = useCallback((config) => {
+        // Socket.IO configuration optimized for Kubernetes/Traefik environments
+        // - Start with polling, then upgrade to websocket (more reliable through proxies)
+        // - Include token in both auth object and extraHeaders as fallback
+        // - Longer timeout for initial connection through ingress
+        const socketOptions = {
+            auth: config.token ? {
+                token: config.token,
+                ...(config.consumableToken ? { consumableToken: config.consumableToken } : {}),
+            } : undefined,
+            // Start with polling, then upgrade to websocket (better for Traefik/proxies)
+            transports: ['polling', 'websocket'],
+            reconnection: config.autoReconnect ?? true,
+            reconnectionDelay: config.reconnectInterval ?? 5000,
+            reconnectionAttempts: config.maxReconnectAttempts ?? 5,
+            // Longer timeout for Kubernetes ingress (Traefik may take time to upgrade)
+            timeout: 30000,
+            // Force new connection (don't reuse existing) - important for hot reload
+            forceNew: true,
+            // Upgrade timeout for polling -> websocket upgrade
+            upgradeTimeout: 10000,
+        };
+        // Add headers as fallback (some proxies prefer headers over auth object)
+        if (config.token || config.consumableToken) {
+            socketOptions.extraHeaders = {
+                ...(config.token ? { [WildoHeaderKeys.AUTHORIZATION]: `Bearer ${config.token}` } : {}),
+                ...(config.consumableToken ? { [WildoHeaderKeys.CONSUMABLE_TOKEN]: config.consumableToken } : {}),
+            };
+        }
+        const socket = io(config.url, socketOptions);
+        socketRef.current = socket;
+        attachRegisteredEventListeners(socket);
+        socket.on('connect', () => {
+            connectInFlightRef.current = false;
+            setStatus(WebSocketStatus.CONNECTED);
+            setConnectionCount(prev => prev + 1);
+            setError(null);
+            reconnectAttemptsRef.current = 0;
+            connectedAtRef.current = new Date();
+            console.log('Socket.IO connected');
+            for (const room of roomClaimsRef.current.values()) {
+                socket.emit(CoreWebSocketEvent.RESOURCE_SUBSCRIBE, {
+                    resourceType: room.resourceType,
+                    resourceId: room.resourceId,
+                    scopeKey: room.scopeKey,
+                    scopeId: room.scopeId,
+                    contextResourceIdentifiers: room.contextResourceIdentifiers,
+                });
+            }
+        });
+        socket.on('disconnect', (reason) => {
+            connectInFlightRef.current = false;
+            setStatus(WebSocketStatus.DISCONNECTED);
+            console.log('Socket.IO disconnected:', reason);
+            // Check if we should attempt reconnection
+            if (reason === 'io server disconnect') {
+                // Server initiated disconnect - notify user
+                const errorMessage = 'Server disconnected the connection';
+                setError(errorMessage);
+                errorManagement.handleError(new Error(`WebSocket server disconnected: ${reason}`), {
+                    source: 'websocket',
+                    riskLevel: ResourceOperationRiskLevel.MEDIUM,
+                    additionalContext: {
+                        reason,
+                        wasConnected: true,
+                    },
+                });
+            }
+        });
+        socket.on('connect_error', (err) => {
+            connectInFlightRef.current = false;
+            console.error('Socket.IO connection error:', err.message);
+            setError(err.message);
+            setStatus(WebSocketStatus.ERROR);
+            // Integrate with error management system
+            errorManagement.handleError(err, {
+                source: 'websocket',
+                riskLevel: ResourceOperationRiskLevel.MEDIUM,
+                additionalContext: {
+                    errorCode: err.code,
+                    errorType: err.type,
+                },
+            });
+        });
+        socket.io.on('reconnect_attempt', (attempt) => {
+            reconnectAttemptsRef.current = attempt;
+            setStatus(WebSocketStatus.RECONNECTING);
+            console.log(`Socket.IO reconnection attempt ${attempt}`);
+        });
+        socket.io.on('reconnect', (attempt) => {
+            console.log(`Socket.IO reconnected after ${attempt} attempts`);
+            setStatus(WebSocketStatus.CONNECTED);
+            setError(null);
+            reconnectAttemptsRef.current = 0;
+        });
+        socket.io.on('reconnect_failed', () => {
+            console.error('Socket.IO reconnection failed');
+            const errorMessage = 'Failed to reconnect after maximum attempts';
+            setError(errorMessage);
+            setStatus(WebSocketStatus.ERROR);
+            // Integrate with error management system
+            errorManagement.handleError(new Error(errorMessage), {
+                source: 'websocket',
+                riskLevel: ResourceOperationRiskLevel.HIGH,
+                additionalContext: {
+                    reconnectAttempts: reconnectAttemptsRef.current,
+                },
+            });
+        });
+    }, [attachRegisteredEventListeners]);
+    /**
+     * Perform readiness check and then connect to WebSocket
+     */
+    const performConnectWithReadinessCheck = useCallback(async (config, requestId, connectKey) => {
+        // Wait for API to be ready (with timeout - will proceed anyway after 30s)
+        await waitForApiReadiness(config.url);
+        if (connectRequestIdRef.current !== requestId || connectKeyRef.current !== connectKey) {
+            console.log('WebSocket: Skipping stale connect attempt after readiness check');
+            return;
+        }
+        // Connect to WebSocket
+        performActualConnect(config);
+    }, [waitForApiReadiness, performActualConnect]);
+    /**
+     * Connect to WebSocket server using Socket.IO
+     */
+    const connect = useCallback((config) => {
+        // Validate URL before attempting connection
+        if (!config.url) {
+            setError('WebSocket URL is not available');
+            setStatus(WebSocketStatus.ERROR);
+            console.error('WebSocket: Cannot connect - URL is required');
+            return;
+        }
+        const connectKey = buildConnectKey(config);
+        const sameConnectionRequest = (connectKeyRef.current === connectKey
+            && (connectInFlightRef.current
+                || status === WebSocketStatus.CONNECTING
+                || status === WebSocketStatus.CONNECTED
+                || status === WebSocketStatus.RECONNECTING));
+        if (sameConnectionRequest) {
+            console.log('WebSocket: Reusing active connect lifecycle for identical config');
+            return;
+        }
+        // Disconnect any existing socket before connecting (handles hot reload scenario)
+        // This ensures we don't have stale connections or duplicate connections
+        if (socketRef.current) {
+            if (socketRef.current.connected) {
+                console.log('Disconnecting existing WebSocket connection before reconnecting');
+            }
+            socketRef.current.disconnect();
+            socketRef.current.removeAllListeners();
+            socketRef.current = null;
+        }
+        connectRequestIdRef.current += 1;
+        connectKeyRef.current = connectKey;
+        connectInFlightRef.current = true;
+        configRef.current = config;
+        setStatus(WebSocketStatus.CONNECTING);
+        setError(null);
+        // Perform readiness check then connect (async, fires and forgets)
+        performConnectWithReadinessCheck(config, connectRequestIdRef.current, connectKey).catch((err) => {
+            console.error('WebSocket: Connection setup failed', err);
+            setError('WebSocket connection setup failed');
+            setStatus(WebSocketStatus.ERROR);
+        });
+    }, [buildConnectKey, performConnectWithReadinessCheck, status]);
+    /**
+     * Disconnect from WebSocket server
+     */
+    const disconnect = useCallback(() => {
+        connectRequestIdRef.current += 1;
+        connectKeyRef.current = null;
+        connectInFlightRef.current = false;
+        reconnectAttemptsRef.current = 0;
+        if (reconnectTimeoutRef.current) {
+            clearTimeout(reconnectTimeoutRef.current);
+            reconnectTimeoutRef.current = null;
+        }
+        if (socketRef.current) {
+            socketRef.current.disconnect();
+            socketRef.current = null;
+        }
+        setStatus(WebSocketStatus.DISCONNECTED);
+        roomClaimsRef.current.clear();
+        setSubscribedRooms([]);
+        connectedAtRef.current = null;
+    }, []);
+    /**
+     * Refresh authentication token
+     */
+    const refreshAuth = useCallback((token) => {
+        if (!socketRef.current?.connected) {
+            console.warn('Cannot refresh auth: not connected');
+            return;
+        }
+        socketRef.current.emit(CoreWebSocketEvent.AUTH_REFRESH, { token });
+    }, []);
+    /**
+     * Listen to socket events directly
+     */
+    const on = useCallback((event, handler) => {
+        const typedHandler = handler;
+        const handlers = eventListenersRef.current.get(event) ?? new Set();
+        const hadHandler = handlers.has(typedHandler);
+        handlers.add(typedHandler);
+        eventListenersRef.current.set(event, handlers);
+        if (!hadHandler && socketRef.current) {
+            socketRef.current.on(event, getSocketListener(event, typedHandler));
+        }
+        return () => {
+            eventListenersRef.current.get(event)?.delete(typedHandler);
+            if (eventListenersRef.current.get(event)?.size === 0) {
+                eventListenersRef.current.delete(event);
+            }
+            const wrappedHandler = eventListenerWrappersRef.current.get(event)?.get(typedHandler);
+            if (wrappedHandler) {
+                socketRef.current?.off(event, wrappedHandler);
+                eventListenerWrappersRef.current.get(event)?.delete(typedHandler);
+            }
+            if (eventListenerWrappersRef.current.get(event)?.size === 0) {
+                eventListenerWrappersRef.current.delete(event);
+            }
+        };
+    }, [getSocketListener]);
+    /**
+     * Remove event listener
+     */
+    const off = useCallback((event, handler) => {
+        eventListenersRef.current.get(event)?.delete(handler);
+        if (eventListenersRef.current.get(event)?.size === 0) {
+            eventListenersRef.current.delete(event);
+        }
+        const wrappedHandler = eventListenerWrappersRef.current.get(event)?.get(handler);
+        if (wrappedHandler) {
+            socketRef.current?.off(event, wrappedHandler);
+            eventListenerWrappersRef.current.get(event)?.delete(handler);
+        }
+        if (eventListenerWrappersRef.current.get(event)?.size === 0) {
+            eventListenerWrappersRef.current.delete(event);
+        }
+    }, []);
+    /**
+     * Emit event to server
+     */
+    const emit = useCallback((event, payload) => {
+        if (!socketRef.current?.connected) {
+            console.warn('Cannot emit: not connected');
+            return;
+        }
+        socketRef.current.emit(event, payload);
+    }, []);
+    const requestResourceRoomSubscription = useCallback(async (params) => {
+        if (!socketRef.current?.connected) {
+            console.warn('Cannot subscribe: not connected');
+            return { success: false };
+        }
+        return new Promise((resolve) => {
+            const roomName = buildRoomName(params);
+            let resolved = false;
+            socketRef.current.emit(CoreWebSocketEvent.RESOURCE_SUBSCRIBE, {
+                resourceType: params.resourceType,
+                resourceId: params.resourceId,
+                scopeKey: params.scopeKey,
+                scopeId: params.scopeId,
+                contextResourceIdentifiers: params.contextResourceIdentifiers,
+            });
+            const handleSubscribed = (response) => {
+                if (response.roomName === roomName && !resolved) {
+                    resolved = true;
+                    socketRef.current.off(CoreWebSocketEvent.RESOURCE_SUBSCRIBED, handleSubscribed);
+                    resolve({
+                        success: response.success,
+                        editingUsers: response.editingUsers,
+                    });
+                }
+            };
+            socketRef.current.on(CoreWebSocketEvent.RESOURCE_SUBSCRIBED, handleSubscribed);
+            setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    socketRef.current?.off(CoreWebSocketEvent.RESOURCE_SUBSCRIBED, handleSubscribed);
+                    resolve({ success: false });
+                }
+            }, 10000);
+        });
+    }, [buildRoomName]);
+    /**
+     * Subscribe to a resource room
+     * Returns success status and current editing users (for single resource subscriptions)
+     */
+    const claimResourceRoom = useCallback(async (params) => {
+        const roomName = buildRoomName(params);
+        const existing = roomClaimsRef.current.get(roomName);
+        if (existing) {
+            const hadOwner = existing.ownerKeys.has(params.ownerKey);
+            const previousOwnerContext = existing.ownerContexts.get(params.ownerKey);
+            const previousSharedContext = existing.contextResourceIdentifiers;
+            existing.ownerKeys.add(params.ownerKey);
+            existing.ownerContexts.set(params.ownerKey, params.contextResourceIdentifiers);
+            existing.contextResourceIdentifiers = params.contextResourceIdentifiers;
+            if (socketRef.current?.connected) {
+                const refreshedSubscription = await requestResourceRoomSubscription({
+                    resourceType: existing.resourceType,
+                    resourceId: existing.resourceId,
+                    scopeKey: existing.scopeKey,
+                    scopeId: existing.scopeId,
+                    contextResourceIdentifiers: params.contextResourceIdentifiers,
+                });
+                if (refreshedSubscription.success) {
+                    existing.editingUsers = refreshedSubscription.editingUsers;
+                    syncSubscribedRoomsFromClaims();
+                    return {
+                        success: true,
+                        editingUsers: existing.editingUsers,
+                    };
+                }
+                if (hadOwner && previousOwnerContext) {
+                    existing.ownerContexts.set(params.ownerKey, previousOwnerContext);
+                }
+                else {
+                    existing.ownerKeys.delete(params.ownerKey);
+                    existing.ownerContexts.delete(params.ownerKey);
+                }
+                existing.contextResourceIdentifiers = previousSharedContext;
+                syncSubscribedRoomsFromClaims();
+                return refreshedSubscription;
+            }
+            syncSubscribedRoomsFromClaims();
+            return { success: true, editingUsers: existing.editingUsers };
+        }
+        if (!socketRef.current?.connected) {
+            roomClaimsRef.current.set(roomName, {
+                roomName,
+                resourceType: params.resourceType,
+                resourceId: params.resourceId,
+                scopeKey: params.scopeKey,
+                scopeId: params.scopeId,
+                contextResourceIdentifiers: params.contextResourceIdentifiers,
+                ownerKeys: new Set([params.ownerKey]),
+                ownerContexts: new Map([[params.ownerKey, params.contextResourceIdentifiers]]),
+            });
+            syncSubscribedRoomsFromClaims();
+            return { success: false };
+        }
+        const result = await requestResourceRoomSubscription(params);
+        if (!result.success) {
+            return result;
+        }
+        roomClaimsRef.current.set(roomName, {
+            roomName,
+            resourceType: params.resourceType,
+            resourceId: params.resourceId,
+            scopeKey: params.scopeKey,
+            scopeId: params.scopeId,
+            contextResourceIdentifiers: params.contextResourceIdentifiers,
+            ownerKeys: new Set([params.ownerKey]),
+            ownerContexts: new Map([[params.ownerKey, params.contextResourceIdentifiers]]),
+            editingUsers: result.editingUsers,
+        });
+        syncSubscribedRoomsFromClaims();
+        return result;
+    }, [buildRoomName, requestResourceRoomSubscription, syncSubscribedRoomsFromClaims]);
+    const subscribeToResource = useCallback(async (params) => {
+        const roomName = buildRoomName(params);
+        return claimResourceRoom({
+            ...params,
+            ownerKey: `legacy:${roomName}`,
+        });
+    }, [buildRoomName, claimResourceRoom]);
+    /**
+     * Unsubscribe from a resource room
+     */
+    const releaseResourceRoom = useCallback(async (params) => {
+        const roomName = buildRoomName(params);
+        const existing = roomClaimsRef.current.get(roomName);
+        if (!existing) {
+            return;
+        }
+        existing.ownerKeys.delete(params.ownerKey);
+        existing.ownerContexts.delete(params.ownerKey);
+        if (existing.ownerKeys.size > 0) {
+            const survivingContext = existing.ownerContexts.values().next().value;
+            if (survivingContext) {
+                existing.contextResourceIdentifiers = survivingContext;
+                if (socketRef.current?.connected) {
+                    const refreshedSubscription = await requestResourceRoomSubscription({
+                        resourceType: existing.resourceType,
+                        resourceId: existing.resourceId,
+                        scopeKey: existing.scopeKey,
+                        scopeId: existing.scopeId,
+                        contextResourceIdentifiers: survivingContext,
+                    });
+                    if (refreshedSubscription.success) {
+                        existing.editingUsers = refreshedSubscription.editingUsers;
+                    }
+                }
+            }
+            syncSubscribedRoomsFromClaims();
+            return;
+        }
+        roomClaimsRef.current.delete(roomName);
+        syncSubscribedRoomsFromClaims();
+        if (!socketRef.current?.connected) {
+            return;
+        }
+        socketRef.current.emit(CoreWebSocketEvent.RESOURCE_UNSUBSCRIBE, {
+            resourceType: params.resourceType,
+            resourceId: params.resourceId,
+            scopeKey: params.scopeKey,
+            scopeId: params.scopeId,
+            contextResourceIdentifiers: params.contextResourceIdentifiers,
+        });
+    }, [buildRoomName, syncSubscribedRoomsFromClaims]);
+    const unsubscribeFromResource = useCallback(async (params) => {
+        const roomName = buildRoomName(params);
+        await releaseResourceRoom({
+            ...params,
+            ownerKey: `legacy:${roomName}`,
+        });
+    }, [buildRoomName, releaseResourceRoom]);
+    /**
+     * Switch organization context
+     */
+    const switchOrganization = useCallback((organizationId, previousOrganizationId) => {
+        if (!socketRef.current?.connected) {
+            console.warn('Cannot switch organization: not connected');
+            return;
+        }
+        socketRef.current.emit(CoreWebSocketEvent.ORGANIZATION_SWITCH, {
+            organizationId,
+            previousOrganizationId,
+        });
+        if (!previousOrganizationId) {
+            return;
+        }
+        const roomsToRelease = Array.from(roomClaimsRef.current.values())
+            .filter((room) => roomMatchesOrganization(room, previousOrganizationId))
+            .flatMap((room) => Array.from(room.ownerKeys).map((ownerKey) => ({
+            ownerKey,
+            resourceType: room.resourceType,
+            resourceId: room.resourceId,
+            scopeKey: room.scopeKey,
+            scopeId: room.scopeId,
+            contextResourceIdentifiers: room.ownerContexts.get(ownerKey) ?? room.contextResourceIdentifiers,
+        })));
+        void Promise.all(roomsToRelease.map((room) => releaseResourceRoom(room)));
+    }, [releaseResourceRoom]);
+    /**
+     * Start editing a resource (acquire lock)
+     */
+    const startEditing = useCallback(async (params) => {
+        if (!socketRef.current?.connected) {
+            console.warn('Cannot start editing: not connected');
+            return false;
+        }
+        return new Promise((resolve) => {
+            let resolved = false;
+            socketRef.current.emit(CoreWebSocketEvent.RESOURCE_EDITING_START, {
+                resourceType: params.resourceType,
+                resourceId: params.resourceId,
+                contextResourceIdentifiers: params.contextResourceIdentifiers,
+                timestamp: new Date(),
+            });
+            const handleResult = (response) => {
+                if (response.resourceType === params.resourceType && response.resourceId === params.resourceId && !resolved) {
+                    resolved = true;
+                    socketRef.current.off(CoreWebSocketEvent.RESOURCE_EDITING_STARTED, handleResult);
+                    socketRef.current.off(CoreWebSocketEvent.RESOURCE_EDITING_ERROR, handleResult);
+                    resolve(response.success);
+                }
+            };
+            socketRef.current.on(CoreWebSocketEvent.RESOURCE_EDITING_STARTED, handleResult);
+            socketRef.current.on(CoreWebSocketEvent.RESOURCE_EDITING_ERROR, handleResult);
+            // Timeout after 10 seconds
+            setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    socketRef.current?.off(CoreWebSocketEvent.RESOURCE_EDITING_STARTED, handleResult);
+                    socketRef.current?.off(CoreWebSocketEvent.RESOURCE_EDITING_ERROR, handleResult);
+                    resolve(false);
+                }
+            }, 10000);
+        });
+    }, []);
+    /**
+     * Stop editing a resource (release lock)
+     */
+    const stopEditing = useCallback((params) => {
+        if (!socketRef.current?.connected) {
+            return;
+        }
+        socketRef.current.emit(CoreWebSocketEvent.RESOURCE_EDITING_END, {
+            resourceType: params.resourceType,
+            resourceId: params.resourceId,
+            timestamp: new Date(),
+        });
+    }, []);
+    /**
+     * Send custom collaboration event
+     */
+    const sendCustomEvent = useCallback((params) => {
+        if (!socketRef.current?.connected) {
+            console.warn('Cannot send custom event: not connected');
+            return;
+        }
+        socketRef.current.emit(CoreWebSocketEvent.RESOURCE_CUSTOM, {
+            resourceType: params.resourceType,
+            resourceId: params.resourceId,
+            eventName: params.eventName,
+            data: params.data,
+            contextResourceIdentifiers: params.contextResourceIdentifiers,
+            includeSelf: params.includeSelf,
+            timestamp: new Date(),
+        });
+    }, []);
+    /**
+     * Get a specific badge count
+     */
+    const getBadge = useCallback(async (identifier, scope, scopeId) => {
+        if (!socketRef.current?.connected) {
+            return 0;
+        }
+        return new Promise((resolve) => {
+            let resolved = false;
+            const timeoutId = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    resolve(0);
+                }
+            }, 5000);
+            socketRef.current.emit(CoreWebSocketEvent.BADGE_GET, {
+                identifier,
+                scope,
+                scopeId,
+            }, (response) => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeoutId);
+                    resolve(response?.count ?? 0);
+                }
+            });
+        });
+    }, []);
+    /**
+     * Get all badges for a scope
+     */
+    const getAllBadges = useCallback(async (scope, scopeId) => {
+        if (!socketRef.current?.connected) {
+            return [];
+        }
+        return new Promise((resolve) => {
+            let resolved = false;
+            const timeoutId = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    resolve([]);
+                }
+            }, 5000);
+            socketRef.current.emit(CoreWebSocketEvent.BADGE_GET_ALL, {
+                scope,
+                scopeId,
+            }, (response) => {
+                if (!resolved) {
+                    resolved = true;
+                    clearTimeout(timeoutId);
+                    resolve(response ?? []);
+                }
+            });
+        });
+    }, []);
+    /**
+     * Get connection information
+     */
+    const getConnectionInfo = useCallback(() => ({
+        status,
+        url: configRef.current?.url || null,
+        connectedAt: connectedAtRef.current
+    }), [status]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            disconnect();
+        };
+    }, [disconnect]);
+    const value = useMemo(() => ({
+        // State
+        status,
+        connectionCount,
+        isConnected: status === WebSocketStatus.CONNECTED,
+        error,
+        subscribedRooms,
+        // Connection Actions
+        connect,
+        disconnect,
+        refreshAuth,
+        switchOrganization,
+        // Event Subscription
+        on,
+        off,
+        emit,
+        // Resource Room Actions
+        subscribeToResource,
+        claimResourceRoom,
+        unsubscribeFromResource,
+        releaseResourceRoom,
+        // Editing State Actions
+        startEditing,
+        stopEditing,
+        // Custom Collaboration Events
+        sendCustomEvent,
+        // Badge Actions
+        getBadge,
+        getAllBadges,
+        // Helpers
+        getConnectionInfo
+    }), [
+        status,
+        connectionCount,
+        error,
+        subscribedRooms,
+        connect,
+        disconnect,
+        refreshAuth,
+        switchOrganization,
+        on,
+        off,
+        emit,
+        subscribeToResource,
+        claimResourceRoom,
+        unsubscribeFromResource,
+        releaseResourceRoom,
+        startEditing,
+        stopEditing,
+        sendCustomEvent,
+        getBadge,
+        getAllBadges,
+        getConnectionInfo,
+    ]);
+    return _jsx(WebSocketContext.Provider, { value: value, children: children });
+};
+//# sourceMappingURL=WebSocketContext.js.map