phx-react/dist/esm/components/MainWrapV4/hooks/use-mainwrap-realtime-counts.js

PHX REACT

import { useEffect } from 'react';
import { io } from 'socket.io-client';
import { parseRequiredActionPayload } from '../components/require-action/required-action-api';
import PHXGetEnvPublicV3 from '../../Func/getEnvPublic';
const INAPP_NOTI_SOCKET_CONFIG = {
    namespace: '/core-socket',
    path: '/core-socket',
    joinRoomEvent: 'join_room',
    realtimeEvent: 'inapp-noti-count',
};
const INAPP_NOTI_ROOM_ID = {
    realtime: 'inapp-noti-count',
};
const isRecord = (value) => typeof value === 'object' && value !== null;
const getPublicHostname = async () => {
    const response = await PHXGetEnvPublicV3();
    return isRecord(response) && typeof response.HOSTNAME === 'string' ? response.HOSTNAME : undefined;
};
const getDashboardCountPayload = (payload) => {
    if (!isRecord(payload) || !isRecord(payload.data))
        return undefined;
    return isRecord(payload.data.dashboard) ? payload.data.dashboard : undefined;
};
const getUnreadCount = (payload) => {
    const dashboardPayload = getDashboardCountPayload(payload);
    return dashboardPayload && typeof dashboardPayload.unread_count === 'number'
        ? dashboardPayload.unread_count
        : undefined;
};
const parseDashboardRequiredActionPayload = (payload) => {
    const dashboardPayload = getDashboardCountPayload(payload);
    const counts = dashboardPayload && isRecord(dashboardPayload.required_action_count) ? dashboardPayload.required_action_count : {};
    return parseRequiredActionPayload({ counts });
};
const getPayloadUserId = (payload) => {
    if (!isRecord(payload))
        return undefined;
    const userId = Number(payload.user_id);
    return Number.isFinite(userId) ? userId : undefined;
};
const isPayloadForCurrentUser = (payload, currentUserId) => {
    const payloadUserId = getPayloadUserId(payload);
    if (!payloadUserId)
        return true;
    return payloadUserId === currentUserId;
};
const getSocketHeaders = (accessToken, hostname) => ({
    authorization: `Bearer ${accessToken}`,
    ...(hostname ? { hostname } : {}),
    module: 'inapp-noti',
});
const joinRealtimeRooms = (socket) => {
    socket.emit(INAPP_NOTI_SOCKET_CONFIG.joinRoomEvent, {
        roomId: INAPP_NOTI_ROOM_ID.realtime,
    });
};
const bindRealtimeSocketEvents = ({ currentUserId, onConnectionChange, onRequiredAction, onUnreadCount, socket, }) => {
    socket.on('connect', () => {
        onConnectionChange === null || onConnectionChange === void 0 ? void 0 : onConnectionChange(true);
        joinRealtimeRooms(socket);
    });
    socket.on('connect_error', () => {
        onConnectionChange === null || onConnectionChange === void 0 ? void 0 : onConnectionChange(false);
    });
    socket.on('disconnect', () => {
        onConnectionChange === null || onConnectionChange === void 0 ? void 0 : onConnectionChange(false);
    });
    socket.io.on('reconnect', () => {
        onConnectionChange === null || onConnectionChange === void 0 ? void 0 : onConnectionChange(true);
    });
    socket.on(INAPP_NOTI_SOCKET_CONFIG.realtimeEvent, (payload) => {
        if (!isPayloadForCurrentUser(payload, currentUserId)) {
            return;
        }
        onUnreadCount(getUnreadCount(payload));
        onRequiredAction(parseDashboardRequiredActionPayload(payload));
    });
};
const setupRealtimeSocket = async ({ accessToken, currentUserId, onConnectionChange, onRequiredAction, onUnreadCount, }) => {
    const socketUrl = `${process.env.NEXT_PUBLIC_API_GATEWAY}${INAPP_NOTI_SOCKET_CONFIG.namespace}`;
    const hostname = await getPublicHostname();
    const socket = io(socketUrl, {
        path: INAPP_NOTI_SOCKET_CONFIG.path,
        extraHeaders: getSocketHeaders(accessToken, hostname),
    });
    bindRealtimeSocketEvents({
        currentUserId,
        onConnectionChange,
        onRequiredAction,
        onUnreadCount,
        socket,
    });
    return socket;
};
export const useMainwrapRealtimeCounts = ({ accessToken, currentUserId, enabled, onConnectionChange, onRequiredAction, onUnreadCount, }) => {
    useEffect(() => {
        if (!enabled || !accessToken || !currentUserId) {
            onConnectionChange === null || onConnectionChange === void 0 ? void 0 : onConnectionChange(false);
            return;
        }
        let socket = null;
        let isDisposed = false;
        const connectSocket = async () => {
            try {
                if (isDisposed)
                    return;
                const nextSocket = await setupRealtimeSocket({
                    accessToken,
                    currentUserId,
                    onConnectionChange,
                    onRequiredAction,
                    onUnreadCount,
                });
                if (isDisposed) {
                    nextSocket.disconnect();
                    return;
                }
                socket = nextSocket;
            }
            catch (_a) {
                onConnectionChange === null || onConnectionChange === void 0 ? void 0 : onConnectionChange(false);
            }
        };
        void connectSocket();
        return () => {
            isDisposed = true;
            onConnectionChange === null || onConnectionChange === void 0 ? void 0 : onConnectionChange(false);
            socket === null || socket === void 0 ? void 0 : socket.disconnect();
        };
    }, [enabled, accessToken, currentUserId, onConnectionChange, onRequiredAction, onUnreadCount]);
};
//# sourceMappingURL=use-mainwrap-realtime-counts.js.map