indas-ui 0.0.1 → 0.1.0

package/dist/cjs/contexts/EmailContext.js

@@ -0,0 +1,727 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailProvider = EmailProvider;
+exports.useEmail = useEmail;
+exports.useEmailState = useEmailState;
+exports.useEmailActions = useEmailActions;
+exports.useEmailAPI = useEmailAPI;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_2 = require("next-auth/react");
+const email_1 = require("../lib/api/activity/email/index.js");
+const FOLDER_CACHE_MAX_AGE = 5 * 60 * 1000; // 5 minutes
+// Initial State
+const initialState = {
+    emails: [],
+    threads: [],
+    folders: [],
+    categories: [],
+    templates: [],
+    drafts: [],
+    contacts: [],
+    folderCache: {},
+    folderCounts: {},
+    selectedEmailId: null,
+    selectedThreadId: null,
+    selectedFolderId: 'inbox',
+    selectedCategory: null,
+    currentView: 'inbox',
+    loading: false,
+    loadingMore: false,
+    sendingEmail: false,
+    savingDraft: false,
+    currentPage: 1,
+    hasMore: true,
+    totalCount: 0,
+    unreadCount: 0,
+    searchQuery: '',
+    searchFilters: {},
+    composeOpen: false,
+    replyToEmail: null,
+    initialDraftData: null,
+    error: null,
+    isConnected: false,
+    lastSyncTime: null
+};
+// Email Reducer
+function emailReducer(state, action) {
+    switch (action.type) {
+        case 'SET_LOADING':
+            return { ...state, loading: action.payload };
+        case 'SET_LOADING_MORE':
+            return { ...state, loadingMore: action.payload };
+        case 'SET_SENDING_EMAIL':
+            return { ...state, sendingEmail: action.payload };
+        case 'SET_SAVING_DRAFT':
+            return { ...state, savingDraft: action.payload };
+        case 'SET_ERROR':
+            return { ...state, error: action.payload };
+        case 'SET_EMAILS':
+            return {
+                ...state,
+                emails: action.payload.emails,
+                totalCount: action.payload.totalCount,
+                hasMore: action.payload.hasMore,
+                currentPage: action.payload.page || 1
+            };
+        case 'SET_THREADS':
+            return { ...state, threads: action.payload };
+        case 'SET_FOLDERS':
+            return { ...state, folders: action.payload };
+        case 'SET_CATEGORIES':
+            return { ...state, categories: action.payload };
+        case 'SET_TEMPLATES':
+            return { ...state, templates: action.payload };
+        case 'SET_DRAFTS':
+            return { ...state, drafts: action.payload };
+        case 'SET_CONTACTS':
+            return { ...state, contacts: action.payload };
+        case 'SET_SELECTED_EMAIL':
+            return { ...state, selectedEmailId: action.payload };
+        case 'SET_SELECTED_THREAD':
+            return { ...state, selectedThreadId: action.payload };
+        case 'SET_SELECTED_FOLDER':
+            return { ...state, selectedFolderId: action.payload };
+        case 'SET_SELECTED_CATEGORY':
+            return { ...state, selectedCategory: action.payload };
+        case 'SET_CURRENT_VIEW':
+            return { ...state, currentView: action.payload };
+        case 'SET_SEARCH_QUERY':
+            return { ...state, searchQuery: action.payload };
+        case 'SET_SEARCH_FILTERS':
+            return { ...state, searchFilters: action.payload };
+        case 'SET_COMPOSE_OPEN':
+            return { ...state, composeOpen: action.payload };
+        case 'SET_REPLY_TO_EMAIL':
+            return { ...state, replyToEmail: action.payload };
+        case 'SET_INITIAL_DRAFT_DATA':
+            return { ...state, initialDraftData: action.payload };
+        case 'UPDATE_EMAIL':
+            return {
+                ...state,
+                emails: state.emails.map(email => email.id === action.payload.emailId
+                    ? { ...email, ...action.payload.updates }
+                    : email)
+            };
+        case 'DELETE_EMAIL':
+            return {
+                ...state,
+                emails: state.emails.filter(email => email.id !== action.payload),
+                totalCount: Math.max(0, state.totalCount - 1)
+            };
+        case 'ADD_DRAFT':
+            return {
+                ...state,
+                drafts: [action.payload, ...state.drafts]
+            };
+        case 'UPDATE_DRAFT':
+            return {
+                ...state,
+                drafts: state.drafts.map(draft => draft.id === action.payload.draftId
+                    ? { ...draft, ...action.payload.updates }
+                    : draft)
+            };
+        case 'DELETE_DRAFT':
+            return {
+                ...state,
+                drafts: state.drafts.filter(draft => draft.id !== action.payload)
+            };
+        case 'SET_UNREAD_COUNT':
+            return { ...state, unreadCount: action.payload };
+        case 'SET_CONNECTED':
+            return { ...state, isConnected: action.payload };
+        case 'SET_LAST_SYNC_TIME':
+            return { ...state, lastSyncTime: action.payload };
+        case 'SET_FOLDER_CACHE':
+            return {
+                ...state,
+                folderCache: {
+                    ...state.folderCache,
+                    [action.payload.folderId]: action.payload.data
+                }
+            };
+        case 'SET_FOLDER_COUNTS':
+            return { ...state, folderCounts: { ...state.folderCounts, ...action.payload } };
+        case 'RESET_STATE':
+            return { ...initialState };
+        default:
+            return state;
+    }
+}
+const EmailContext = (0, react_1.createContext)(undefined);
+// Email Provider Component
+function EmailProvider({ children }) {
+    const { data: session } = (0, react_2.useSession)();
+    const [state, dispatch] = (0, react_1.useReducer)(emailReducer, initialState);
+    // Memoize on stable identity — useSession() returns a new object each render, so an
+    // unmemoized api would churn every useCallback([api]) and trigger repeated fetches.
+    const sessionIdentity = `${session?.user?.CompanyID ?? ''}:${session?.user?.UserID ?? ''}`;
+    const api = (0, react_1.useMemo)(() => (0, email_1.createEmailAPI)(session), [sessionIdentity]); // eslint-disable-line react-hooks/exhaustive-deps
+    // Initialize email system when session is available
+    // NOTE: Initialization is now manual - call actions.fetchEmails() when needed
+    // This prevents unnecessary API calls on non-email pages
+    // useEffect(() => {
+    //   if (session) {
+    //     initializeEmailSystem()
+    //   }
+    // }, [session])
+    const initializeEmailSystem = async () => {
+        try {
+            dispatch({ type: 'SET_LOADING', payload: true });
+            // Initialize with default folders and categories
+            dispatch({ type: 'SET_FOLDERS', payload: email_1.DEFAULT_FOLDERS });
+            dispatch({ type: 'SET_CATEGORIES', payload: email_1.DEFAULT_CATEGORIES });
+            // Fetch initial data in parallel
+            await Promise.all([
+                fetchFolders(),
+                fetchCategories(),
+                fetchUnreadCount()
+            ]);
+            // Fetch initial emails
+            await fetchEmails();
+            dispatch({ type: 'SET_CONNECTED', payload: true });
+            dispatch({ type: 'SET_LAST_SYNC_TIME', payload: new Date() });
+        }
+        catch (error) {
+            console.error('Error initializing email system:', error);
+            dispatch({ type: 'SET_ERROR', payload: 'Failed to initialize email system' });
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING', payload: false });
+        }
+    };
+    // Fetch all folders in parallel (inbox, sent, starred, archive, trash)
+    // Called once on mount — populates folderCache + folderCounts for instant switching
+    const fetchAllFolders = (0, react_1.useCallback)(async () => {
+        const folderIds = ['inbox', 'sent', 'starred', 'archive', 'trash'];
+        try {
+            dispatch({ type: 'SET_LOADING', payload: true });
+            // Initialize default folders/categories
+            dispatch({ type: 'SET_FOLDERS', payload: email_1.DEFAULT_FOLDERS });
+            dispatch({ type: 'SET_CATEGORIES', payload: email_1.DEFAULT_CATEGORIES });
+            const results = await Promise.allSettled(folderIds.map(folderId => {
+                const filters = folderId === 'starred'
+                    ? { isStarred: true }
+                    : { folder: folderId };
+                return api.getEmails(filters, 1, 50);
+            }));
+            const counts = {};
+            results.forEach((result, index) => {
+                const folderId = folderIds[index];
+                if (result.status === 'fulfilled' && result.value.success && result.value.data) {
+                    const data = result.value.data;
+                    dispatch({
+                        type: 'SET_FOLDER_CACHE',
+                        payload: {
+                            folderId,
+                            data: {
+                                emails: data.emails,
+                                totalCount: data.totalCount,
+                                hasMore: data.hasMore,
+                                fetchedAt: Date.now()
+                            }
+                        }
+                    });
+                    // Inbox: show unread count, other folders: show total count
+                    counts[folderId] = folderId === 'inbox' ? data.unreadCount : data.totalCount;
+                }
+                else {
+                    counts[folderId] = 0;
+                }
+            });
+            dispatch({ type: 'SET_FOLDER_COUNTS', payload: counts });
+            // Set current view emails from the selected folder (default: inbox)
+            const currentFolder = state.selectedFolderId || 'inbox';
+            const currentIdx = folderIds.indexOf(currentFolder);
+            if (currentIdx >= 0) {
+                const currentResult = results[currentIdx];
+                if (currentResult.status === 'fulfilled' && currentResult.value.success && currentResult.value.data) {
+                    dispatch({
+                        type: 'SET_EMAILS',
+                        payload: {
+                            emails: currentResult.value.data.emails,
+                            totalCount: currentResult.value.data.totalCount,
+                            hasMore: currentResult.value.data.hasMore
+                        }
+                    });
+                    dispatch({ type: 'SET_UNREAD_COUNT', payload: currentResult.value.data.unreadCount });
+                }
+            }
+            dispatch({ type: 'SET_CONNECTED', payload: true });
+            dispatch({ type: 'SET_LAST_SYNC_TIME', payload: new Date() });
+        }
+        catch (error) {
+            dispatch({ type: 'SET_ERROR', payload: error instanceof Error ? error.message : 'Failed to fetch emails' });
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING', payload: false });
+        }
+    }, [api, state.selectedFolderId]);
+    // Fetch emails for a specific page (always replaces, never appends)
+    const fetchEmails = (0, react_1.useCallback)(async (filters, page = 1) => {
+        try {
+            dispatch({ type: 'SET_LOADING', payload: true });
+            const response = await api.getEmails(filters, page, 50);
+            if (response.success && response.data) {
+                dispatch({
+                    type: 'SET_EMAILS',
+                    payload: {
+                        emails: response.data.emails,
+                        totalCount: response.data.totalCount,
+                        hasMore: response.data.hasMore,
+                        page
+                    }
+                });
+                dispatch({ type: 'SET_UNREAD_COUNT', payload: response.data.unreadCount });
+                // Write to folder cache + update count (only for page 1 / initial loads)
+                if (page === 1) {
+                    const folderId = filters?.isStarred ? 'starred' : (filters?.folder || 'inbox');
+                    dispatch({
+                        type: 'SET_FOLDER_CACHE',
+                        payload: {
+                            folderId,
+                            data: {
+                                emails: response.data.emails,
+                                totalCount: response.data.totalCount,
+                                hasMore: response.data.hasMore,
+                                fetchedAt: Date.now()
+                            }
+                        }
+                    });
+                    // Inbox: show unread count, other folders: show total count
+                    const countValue = folderId === 'inbox' ? response.data.unreadCount : response.data.totalCount;
+                    dispatch({ type: 'SET_FOLDER_COUNTS', payload: { [folderId]: countValue } });
+                }
+            }
+            else {
+                dispatch({
+                    type: 'SET_EMAILS',
+                    payload: { emails: [], totalCount: 0, hasMore: false, page: 1 }
+                });
+                dispatch({ type: 'SET_UNREAD_COUNT', payload: 0 });
+                dispatch({ type: 'SET_ERROR', payload: response.error || 'Failed to fetch emails. Please check your email settings.' });
+            }
+        }
+        catch (error) {
+            dispatch({
+                type: 'SET_EMAILS',
+                payload: { emails: [], totalCount: 0, hasMore: false, page: 1 }
+            });
+            dispatch({ type: 'SET_UNREAD_COUNT', payload: 0 });
+            dispatch({ type: 'SET_ERROR', payload: error instanceof Error ? error.message : 'Failed to fetch emails' });
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING', payload: false });
+        }
+    }, [api]);
+    // Navigate to a specific page
+    const fetchPage = (0, react_1.useCallback)(async (page) => {
+        if (state.loading || page < 1)
+            return;
+        await fetchEmails(state.searchFilters, page);
+    }, [state.loading, state.searchFilters, fetchEmails]);
+    // Fetch more emails — kept for backward compat, navigates to next page
+    const fetchMoreEmails = (0, react_1.useCallback)(async () => {
+        if (state.loading || !state.hasMore)
+            return;
+        await fetchEmails(state.searchFilters, state.currentPage + 1);
+    }, [state.loading, state.hasMore, state.currentPage, state.searchFilters, fetchEmails]);
+    // Fetch email by ID
+    const fetchEmailById = (0, react_1.useCallback)(async (emailId) => {
+        try {
+            const response = await api.getEmailById(emailId);
+            if (response.success && response.data) {
+                // Update email in state
+                dispatch({
+                    type: 'UPDATE_EMAIL',
+                    payload: { emailId, updates: response.data }
+                });
+                return response.data;
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Error fetching email:', error);
+            return null;
+        }
+    }, [api]);
+    // Fetch thread
+    const fetchThread = (0, react_1.useCallback)(async (threadId) => {
+        try {
+            const response = await api.getThread(threadId);
+            if (response.success && response.data) {
+                dispatch({ type: 'SET_THREADS', payload: [...state.threads, response.data] });
+                return response.data;
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Error fetching thread:', error);
+            return null;
+        }
+    }, [api, state.threads]);
+    // Fetch folders
+    const fetchFolders = (0, react_1.useCallback)(async () => {
+        try {
+            const response = await api.getFolders();
+            if (response.success && response.data) {
+                dispatch({ type: 'SET_FOLDERS', payload: response.data });
+            }
+        }
+        catch (error) {
+            console.error('Error fetching folders:', error);
+        }
+    }, [api]);
+    // Fetch categories
+    const fetchCategories = (0, react_1.useCallback)(async () => {
+        try {
+            const response = await api.getCategories();
+            if (response.success && response.data) {
+                dispatch({ type: 'SET_CATEGORIES', payload: response.data });
+            }
+        }
+        catch (error) {
+            console.error('Error fetching categories:', error);
+        }
+    }, [api]);
+    // Fetch templates
+    const fetchTemplates = (0, react_1.useCallback)(async () => {
+        try {
+            const response = await api.getTemplates();
+            if (response.success && response.data) {
+                dispatch({ type: 'SET_TEMPLATES', payload: response.data });
+            }
+        }
+        catch (error) {
+            console.error('Error fetching templates:', error);
+        }
+    }, [api]);
+    // Fetch drafts
+    const fetchDrafts = (0, react_1.useCallback)(async () => {
+        try {
+            const response = await api.getDrafts();
+            if (response.success && response.data) {
+                dispatch({ type: 'SET_DRAFTS', payload: response.data });
+            }
+        }
+        catch (error) {
+            console.error('Error fetching drafts:', error);
+        }
+    }, [api]);
+    // Fetch contacts
+    const fetchContacts = (0, react_1.useCallback)(async (search) => {
+        try {
+            const response = await api.getContacts(search);
+            if (response.success && response.data) {
+                dispatch({ type: 'SET_CONTACTS', payload: response.data });
+            }
+        }
+        catch (error) {
+            console.error('Error fetching contacts:', error);
+        }
+    }, [api]);
+    // Fetch unread count
+    const fetchUnreadCount = (0, react_1.useCallback)(async () => {
+        try {
+            const response = await api.getUnreadCount();
+            if (response.success && response.data !== undefined) {
+                dispatch({ type: 'SET_UNREAD_COUNT', payload: response.data });
+            }
+        }
+        catch (error) {
+            console.error('Error fetching unread count:', error);
+        }
+    }, [api]);
+    // Send email
+    const sendEmail = (0, react_1.useCallback)(async (emailData) => {
+        try {
+            dispatch({ type: 'SET_SENDING_EMAIL', payload: true });
+            dispatch({ type: 'SET_ERROR', payload: null });
+            const response = await api.sendEmail(emailData);
+            if (response.success) {
+                // Close compose and refresh emails
+                dispatch({ type: 'SET_COMPOSE_OPEN', payload: false });
+                dispatch({ type: 'SET_REPLY_TO_EMAIL', payload: null });
+                dispatch({ type: 'SET_INITIAL_DRAFT_DATA', payload: null });
+                // Refresh emails from current view
+                await fetchEmails(state.searchFilters);
+            }
+            else {
+                dispatch({ type: 'SET_ERROR', payload: response.error || null });
+            }
+        }
+        catch (error) {
+            console.error('Error sending email:', error);
+            dispatch({ type: 'SET_ERROR', payload: 'Failed to send email' });
+        }
+        finally {
+            dispatch({ type: 'SET_SENDING_EMAIL', payload: false });
+        }
+    }, [api, state.searchFilters, fetchEmails]);
+    // Save draft
+    const saveDraft = (0, react_1.useCallback)(async (draft) => {
+        try {
+            dispatch({ type: 'SET_SAVING_DRAFT', payload: true });
+            dispatch({ type: 'SET_ERROR', payload: null });
+            const response = await api.saveDraft(draft);
+            if (response.success && response.data) {
+                if (draft.id) {
+                    // Update existing draft
+                    dispatch({
+                        type: 'UPDATE_DRAFT',
+                        payload: { draftId: draft.id, updates: response.data }
+                    });
+                }
+                else {
+                    // Add new draft
+                    dispatch({ type: 'ADD_DRAFT', payload: response.data });
+                }
+            }
+            else {
+                dispatch({ type: 'SET_ERROR', payload: response.error || null });
+            }
+        }
+        catch (error) {
+            console.error('Error saving draft:', error);
+            dispatch({ type: 'SET_ERROR', payload: 'Failed to save draft' });
+        }
+        finally {
+            dispatch({ type: 'SET_SAVING_DRAFT', payload: false });
+        }
+    }, [api]);
+    // Update email status - optimistic update
+    const updateEmailStatus = (0, react_1.useCallback)(async (emailId, updates) => {
+        // Optimistic update - update local state immediately
+        dispatch({
+            type: 'UPDATE_EMAIL',
+            payload: { emailId, updates }
+        });
+        // Update unread count if read status changed
+        if (updates.isRead !== undefined) {
+            const currentEmail = state.emails.find(e => e.id === emailId);
+            if (currentEmail && currentEmail.isRead !== updates.isRead) {
+                const unreadCountChange = updates.isRead ? -1 : 1;
+                dispatch({ type: 'SET_UNREAD_COUNT', payload: Math.max(0, state.unreadCount + unreadCountChange) });
+            }
+        }
+        // Then call API in background (don't wait)
+        try {
+            await api.updateEmailStatus(emailId, updates);
+        }
+        catch (error) {
+            console.error('Error updating email status on server:', error);
+            // Keep local state as-is for offline mode
+        }
+    }, [api, state.emails, state.unreadCount]);
+    // Delete email - optimistic update
+    const deleteEmail = (0, react_1.useCallback)(async (emailId) => {
+        // Get email info before deleting for unread count
+        const deletedEmail = state.emails.find(e => e.id === emailId);
+        // Optimistic update - remove from local state immediately
+        dispatch({ type: 'DELETE_EMAIL', payload: emailId });
+        // Update unread count if email was unread
+        if (deletedEmail && !deletedEmail.isRead) {
+            dispatch({ type: 'SET_UNREAD_COUNT', payload: Math.max(0, state.unreadCount - 1) });
+        }
+        // Then call API in background
+        try {
+            await api.deleteEmail(emailId);
+        }
+        catch (error) {
+            console.error('Error deleting email on server:', error);
+            // Keep local state as-is for offline mode
+        }
+    }, [api, state.emails, state.unreadCount]);
+    // Compose operations
+    const openCompose = (0, react_1.useCallback)((replyToEmail, initialData) => {
+        dispatch({ type: 'SET_COMPOSE_OPEN', payload: true });
+        dispatch({ type: 'SET_REPLY_TO_EMAIL', payload: replyToEmail || null });
+        dispatch({ type: 'SET_INITIAL_DRAFT_DATA', payload: initialData || null });
+    }, []);
+    const closeCompose = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'SET_COMPOSE_OPEN', payload: false });
+        dispatch({ type: 'SET_REPLY_TO_EMAIL', payload: null });
+        dispatch({ type: 'SET_INITIAL_DRAFT_DATA', payload: null });
+    }, []);
+    // Navigation operations
+    const selectEmail = (0, react_1.useCallback)((emailId) => {
+        dispatch({ type: 'SET_SELECTED_EMAIL', payload: emailId });
+        // Mark as read if unread
+        const email = state.emails.find(e => e.id === emailId);
+        if (email && !email.isRead) {
+            updateEmailStatus(emailId, { isRead: true });
+        }
+    }, [state.emails, updateEmailStatus]);
+    const selectFolder = (0, react_1.useCallback)((folderId) => {
+        dispatch({ type: 'SET_SELECTED_FOLDER', payload: folderId });
+        dispatch({ type: 'SET_SELECTED_CATEGORY', payload: null });
+        dispatch({ type: 'SET_CURRENT_VIEW', payload: folderId });
+        dispatch({ type: 'SET_SEARCH_QUERY', payload: '' });
+        const filters = folderId === 'starred'
+            ? { isStarred: true }
+            : { folder: folderId };
+        dispatch({ type: 'SET_SEARCH_FILTERS', payload: filters });
+        // Check folder cache first
+        const cached = state.folderCache[folderId];
+        if (cached) {
+            // Immediately show cached data (no loading spinner)
+            dispatch({
+                type: 'SET_EMAILS',
+                payload: {
+                    emails: cached.emails,
+                    totalCount: cached.totalCount,
+                    hasMore: cached.hasMore
+                }
+            });
+            // If cache is stale (>5min), background refresh without spinner
+            const isStale = Date.now() - cached.fetchedAt > FOLDER_CACHE_MAX_AGE;
+            if (isStale) {
+                fetchEmails(filters);
+            }
+        }
+        else {
+            // No cache — fetch with loading spinner
+            fetchEmails(filters);
+        }
+    }, [fetchEmails, state.folderCache]);
+    const selectCategory = (0, react_1.useCallback)((category) => {
+        dispatch({ type: 'SET_SELECTED_CATEGORY', payload: category });
+        dispatch({ type: 'SET_SELECTED_FOLDER', payload: null });
+        dispatch({ type: 'SET_CURRENT_VIEW', payload: 'inbox' });
+        dispatch({ type: 'SET_SEARCH_QUERY', payload: '' });
+        dispatch({ type: 'SET_SEARCH_FILTERS', payload: {} });
+        // Fetch emails for selected category
+        fetchEmails({ category });
+    }, [fetchEmails]);
+    const setCurrentView = (0, react_1.useCallback)((view) => {
+        dispatch({ type: 'SET_CURRENT_VIEW', payload: view });
+        dispatch({ type: 'SET_SELECTED_FOLDER', payload: null });
+        dispatch({ type: 'SET_SELECTED_CATEGORY', payload: null });
+        dispatch({ type: 'SET_SEARCH_QUERY', payload: '' });
+        dispatch({ type: 'SET_SEARCH_FILTERS', payload: {} });
+        // Fetch emails for selected view
+        const filters = {};
+        switch (view) {
+            case 'sent':
+                filters.folder = 'sent';
+                break;
+            case 'drafts':
+                filters.folder = 'drafts';
+                break;
+            case 'starred':
+                filters.isStarred = true;
+                break;
+            case 'archive':
+                filters.folder = 'archive';
+                break;
+            case 'spam':
+                filters.folder = 'spam';
+                break;
+            case 'trash':
+                filters.folder = 'trash';
+                break;
+            default:
+                filters.folder = 'inbox';
+        }
+        fetchEmails(filters);
+    }, [fetchEmails]);
+    // Search operations
+    const setSearchQuery = (0, react_1.useCallback)((query) => {
+        dispatch({ type: 'SET_SEARCH_QUERY', payload: query });
+    }, []);
+    const setSearchFilters = (0, react_1.useCallback)((filters) => {
+        dispatch({ type: 'SET_SEARCH_FILTERS', payload: filters });
+    }, []);
+    const performSearch = (0, react_1.useCallback)(async (query, filters) => {
+        dispatch({ type: 'SET_SEARCH_QUERY', payload: query });
+        dispatch({ type: 'SET_SEARCH_FILTERS', payload: filters || {} });
+        dispatch({ type: 'SET_CURRENT_VIEW', payload: 'search' });
+        await fetchEmails({ ...filters, query });
+    }, [fetchEmails]);
+    // Utility operations — force refresh always fetches from API (updates cache via fetchEmails)
+    const refreshEmails = (0, react_1.useCallback)(async () => {
+        dispatch({ type: 'SET_LAST_SYNC_TIME', payload: new Date() });
+        const folder = state.selectedFolderId || 'inbox';
+        const filters = folder === 'starred'
+            ? { isStarred: true }
+            : { folder };
+        await fetchEmails(filters);
+    }, [fetchEmails, state.selectedFolderId]);
+    const clearError = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'SET_ERROR', payload: null });
+    }, []);
+    const resetState = (0, react_1.useCallback)(() => {
+        dispatch({ type: 'RESET_STATE' });
+    }, []);
+    const actions = (0, react_1.useMemo)(() => ({
+        fetchAllFolders,
+        fetchEmails,
+        fetchPage,
+        fetchMoreEmails,
+        fetchEmailById,
+        fetchThread,
+        fetchFolders,
+        fetchCategories,
+        fetchTemplates,
+        fetchDrafts,
+        fetchContacts,
+        fetchUnreadCount,
+        sendEmail,
+        saveDraft,
+        updateEmailStatus,
+        deleteEmail,
+        openCompose,
+        closeCompose,
+        selectEmail,
+        selectFolder,
+        selectCategory,
+        setCurrentView,
+        setSearchQuery,
+        setSearchFilters,
+        performSearch,
+        refreshEmails,
+        clearError,
+        resetState
+    }), [
+        fetchAllFolders, fetchEmails, fetchPage, fetchMoreEmails, fetchEmailById, fetchThread,
+        fetchFolders, fetchCategories, fetchTemplates, fetchDrafts, fetchContacts, fetchUnreadCount,
+        sendEmail, saveDraft, updateEmailStatus, deleteEmail, openCompose, closeCompose, selectEmail,
+        selectFolder, selectCategory, setCurrentView, setSearchQuery, setSearchFilters, performSearch,
+        refreshEmails, clearError, resetState
+    ]);
+    const value = (0, react_1.useMemo)(() => ({ state, api, actions }), [state, api, actions]);
+    // Auto-fetch ALL folders on mount — populates cache + counts for instant switching
+    (0, react_1.useEffect)(() => {
+        if (!state.loading && state.emails.length === 0) {
+            // Fetch in background without blocking UI
+            setTimeout(() => {
+                fetchAllFolders().catch(() => { });
+            }, 1000); // 1 second delay after login to not disturb user experience
+        }
+    }, []); // Only run once on mount
+    return ((0, jsx_runtime_1.jsx)(EmailContext.Provider, { value: value, children: children }));
+}
+// Hook to use email context
+function useEmail() {
+    const context = (0, react_1.useContext)(EmailContext);
+    if (context === undefined) {
+        throw new Error('useEmail must be used within an EmailProvider');
+    }
+    return context;
+}
+// Export hook for specific email data
+function useEmailState() {
+    const { state } = useEmail();
+    return state;
+}
+// Export hook for email actions
+function useEmailActions() {
+    const { actions } = useEmail();
+    return actions;
+}
+// Export hook for email API
+function useEmailAPI() {
+    const { api } = useEmail();
+    return api;
+}