react-native-event-logger/dist/context/EventTrackerContext.js

A React Native event tracking library with debug capabilities

import { jsx as _jsx } from "react/jsx-runtime";
import { createContext, useContext, useReducer, useRef, useEffect } from 'react';
import { setGlobalEventLogger } from '../utils/eventLogger';
import { validateFirebaseEvent } from '../utils/eventValidation';
// Initial state
const initialState = {
    events: [],
};
// Reducer function
function eventReducer(state, action) {
    switch (action.type) {
        case 'ADD_EVENT':
            return Object.assign(Object.assign({}, state), { events: [action.payload, ...state.events] });
        case 'CLEAR_EVENTS':
            return Object.assign(Object.assign({}, state), { events: [] });
        default:
            return state;
    }
}
// Create context
const EventTrackerContext = createContext(undefined);
// Provider component
export const EventTrackerProvider = ({ children }) => {
    const [state, dispatch] = useReducer(eventReducer, initialState);
    const isDebugMode = useRef(__DEV__);
    // Log event function
    const logEvent = (eventName, params, eventType) => {
        // Validate the event before logging
        const validation = validateFirebaseEvent(eventName, params);
        const eventData = {
            id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
            eventName: validation.validName,
            params: validation.validParams,
            timestamp: Date.now(),
            eventType,
            validationError: validation.errorMsg || undefined, // Store validation error if any
        };
        // Add to local state for debugging (including invalid events)
        dispatch({ type: 'ADD_EVENT', payload: eventData });
        // Log to console in development
        if (__DEV__) {
            if (validation.errorMsg) {
                console.warn('⚠️ Event Validation Failed:', {
                    eventName,
                    params,
                    error: validation.errorMsg,
                });
            }
            else {
                console.log('📊 Event Logged:', {
                    eventName: validation.validName,
                    params: validation.validParams,
                    eventType,
                    timestamp: new Date(eventData.timestamp).toISOString(),
                });
            }
        }
    };
    // Clear events function
    const clearEvents = () => {
        dispatch({ type: 'CLEAR_EVENTS' });
    };
    const contextValue = {
        events: state.events,
        logEvent,
        clearEvents,
        isDebugMode: isDebugMode.current,
    };
    // Set up global event logger
    useEffect(() => {
        setGlobalEventLogger(contextValue);
    }, [contextValue]);
    return (_jsx(EventTrackerContext.Provider, Object.assign({ value: contextValue }, { children: children })));
};
// Custom hook to use the context
export const useEventTracker = () => {
    const context = useContext(EventTrackerContext);
    if (context === undefined) {
        throw new Error('useEventTracker must be used within an EventTrackerProvider');
    }
    return context;
};
//# sourceMappingURL=EventTrackerContext.js.map