feat(performance): implement comprehensive performance improvements for Worklenz frontend

- Introduced a new document summarizing performance optimizations across the application.
- Applied React.memo(), useMemo(), and useCallback() to key components to minimize unnecessary re-renders and optimize rendering performance.
- Implemented a route preloading system to enhance navigation speed and user experience.
- Added performance monitoring utilities for development to track component render times and function execution.
- Enhanced lazy loading and suspense boundaries for better loading states.
- Conducted production optimizations, including TypeScript error fixes and memory management improvements.
- Memoized style and configuration objects to reduce garbage collection pressure and improve memory usage.

worklenz-frontend/src/App.tsx

@@ -1,5 +1,5 @@
 // Core dependencies
-import React, { Suspense, useEffect } from 'react';
+import React, { Suspense, useEffect, memo, useMemo, useCallback } from 'react';
 import { RouterProvider } from 'react-router-dom';
 import i18next from 'i18next';
 
@@ -14,33 +14,82 @@ import router from './app/routes';
 import { useAppSelector } from './hooks/useAppSelector';
 import { initMixpanel } from './utils/mixpanelInit';
 import { initializeCsrfToken } from './api/api-client';
+import { useRoutePreloader } from './utils/routePreloader';
 
 // Types & Constants
 import { Language } from './features/i18n/localesSlice';
 import logger from './utils/errorLogger';
 import { SuspenseFallback } from './components/suspense-fallback/suspense-fallback';
 
-const App: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+/**
+ * Main App Component - Performance Optimized
+ * 
+ * Performance optimizations applied:
+ * 1. React.memo() - Prevents unnecessary re-renders
+ * 2. useMemo() - Memoizes expensive computations
+ * 3. useCallback() - Memoizes event handlers
+ * 4. Route preloading - Preloads critical routes
+ * 5. Lazy loading - Components loaded on demand
+ * 6. Suspense boundaries - Better loading states
+ */
+const App: React.FC = memo(() => {
   const themeMode = useAppSelector(state => state.themeReducer.mode);
   const language = useAppSelector(state => state.localesReducer.lng);
 
-  initMixpanel(import.meta.env.VITE_MIXPANEL_TOKEN as string);
+  // Memoize mixpanel initialization to prevent re-initialization
+  const mixpanelToken = useMemo(() => import.meta.env.VITE_MIXPANEL_TOKEN as string, []);
+  
+  // Preload critical routes for better navigation performance
+  useRoutePreloader([
+    {
+      path: '/worklenz/home',
+      loader: () => import('./pages/home/home-page'),
+      priority: 'high'
+    },
+    {
+      path: '/worklenz/projects',
+      loader: () => import('./pages/projects/project-list'),
+      priority: 'high'
+    },
+    {
+      path: '/worklenz/schedule',
+      loader: () => import('./pages/schedule/schedule'),
+      priority: 'medium'
+    }
+  ]);
+  
+  useEffect(() => {
+    initMixpanel(mixpanelToken);
+  }, [mixpanelToken]);
+
+  // Memoize language change handler
+  const handleLanguageChange = useCallback((lng: string) => {
+    i18next.changeLanguage(lng, err => {
+      if (err) return logger.error('Error changing language', err);
+    });
+  }, []);
 
   useEffect(() => {
     document.documentElement.setAttribute('data-theme', themeMode);
   }, [themeMode]);
 
   useEffect(() => {
-    i18next.changeLanguage(language || Language.EN, err => {
+    handleLanguageChange(language || Language.EN);
-      if (err) return logger.error('Error changing language', err);
+  }, [language, handleLanguageChange]);
-    });
-  }, [language]);
 
-  // Initialize CSRF token on app startup
+  // Initialize CSRF token on app startup - memoize to prevent re-initialization
   useEffect(() => {
+    let isMounted = true;
+    
     initializeCsrfToken().catch(error => {
-      logger.error('Failed to initialize CSRF token:', error);
+      if (isMounted) {
+        logger.error('Failed to initialize CSRF token:', error);
+      }
     });
+
+    return () => {
+      isMounted = false;
+    };
   }, []);
 
   return (
@@ -50,6 +99,8 @@ const App: React.FC<{ children: React.ReactNode }> = ({ children }) => {
       </ThemeWrapper>
     </Suspense>
   );
-};
+});
+
+App.displayName = 'App';
 
 export default App;

worklenz-frontend/src/components/suspense-fallback/suspense-fallback.tsx

@@ -1,46 +1,50 @@
+import React, { memo } from 'react';
 import { colors } from '@/styles/colors';
 import { getInitialTheme } from '@/utils/get-initial-theme';
 import { ConfigProvider, theme, Layout, Spin } from 'antd';
 
-// Loading component with theme awareness
+// Memoized loading component with theme awareness
-export const SuspenseFallback = () => {
+export const SuspenseFallback = memo(() => {
   const currentTheme = getInitialTheme();
   const isDark = currentTheme === 'dark';
 
+  // Memoize theme configuration to prevent unnecessary re-renders
+  const themeConfig = React.useMemo(() => ({
+    algorithm: isDark ? theme.darkAlgorithm : theme.defaultAlgorithm,
+    components: {
+      Layout: {
+        colorBgLayout: isDark ? colors.darkGray : '#fafafa',
+      },
+      Spin: {
+        colorPrimary: isDark ? '#fff' : '#1890ff',
+      },
+    },
+  }), [isDark]);
+
+  // Memoize layout style to prevent object recreation
+  const layoutStyle = React.useMemo(() => ({
+    position: 'fixed' as const,
+    width: '100vw',
+    height: '100vh',
+    background: 'transparent',
+    transition: 'none',
+  }), []);
+
+  // Memoize spin style to prevent object recreation
+  const spinStyle = React.useMemo(() => ({
+    position: 'absolute' as const,
+    top: '50%',
+    left: '50%',
+    transform: 'translate(-50%, -50%)',
+  }), []);
+
   return (
-    <ConfigProvider
+    <ConfigProvider theme={themeConfig}>
-      theme={{
+      <Layout className="app-loading-container" style={layoutStyle}>
-        algorithm: isDark ? theme.darkAlgorithm : theme.defaultAlgorithm,
+        <Spin size="large" style={spinStyle} />
-        components: {
-          Layout: {
-            colorBgLayout: isDark ? colors.darkGray : '#fafafa',
-          },
-          Spin: {
-            colorPrimary: isDark ? '#fff' : '#1890ff',
-          },
-        },
-      }}
-    >
-      <Layout
-        className="app-loading-container"
-        style={{
-          position: 'fixed',
-          width: '100vw',
-          height: '100vh',
-          background: 'transparent',
-          transition: 'none',
-        }}
-      >
-        <Spin
-          size="large"
-          style={{
-            position: 'absolute',
-            top: '50%',
-            left: '50%',
-            transform: 'translate(-50%, -50%)',
-          }}
-        />
       </Layout>
     </ConfigProvider>
   );
-};
+});
+
+SuspenseFallback.displayName = 'SuspenseFallback';

worklenz-frontend/src/features/theme/ThemeWrapper.tsx

@@ -1,5 +1,5 @@
 import { ConfigProvider, theme } from 'antd';
-import React, { useEffect, useRef } from 'react';
+import React, { useEffect, useRef, memo, useMemo, useCallback } from 'react';
 import { useAppSelector } from '@/hooks/useAppSelector';
 import { useAppDispatch } from '@/hooks/useAppDispatch';
 import { initializeTheme } from './themeSlice';
@@ -9,12 +9,45 @@ type ChildrenProp = {
   children: React.ReactNode;
 };
 
-const ThemeWrapper = ({ children }: ChildrenProp) => {
+const ThemeWrapper = memo(({ children }: ChildrenProp) => {
   const dispatch = useAppDispatch();
   const themeMode = useAppSelector(state => state.themeReducer.mode);
   const isInitialized = useAppSelector(state => state.themeReducer.isInitialized);
   const configRef = useRef<HTMLDivElement>(null);
 
+  // Memoize theme configuration to prevent unnecessary re-renders
+  const themeConfig = useMemo(() => ({
+    algorithm: themeMode === 'dark' ? theme.darkAlgorithm : theme.defaultAlgorithm,
+    components: {
+      Layout: {
+        colorBgLayout: themeMode === 'dark' ? colors.darkGray : colors.white,
+        headerBg: themeMode === 'dark' ? colors.darkGray : colors.white,
+      },
+      Menu: {
+        colorBgContainer: colors.transparent,
+      },
+      Table: {
+        rowHoverBg: themeMode === 'dark' ? '#000' : '#edebf0',
+      },
+      Select: {
+        controlHeight: 32,
+      },
+    },
+    token: {
+      borderRadius: 4,
+    },
+  }), [themeMode]);
+
+  // Memoize the theme class name
+  const themeClassName = useMemo(() => `theme-${themeMode}`, [themeMode]);
+
+  // Memoize the media query change handler
+  const handleMediaQueryChange = useCallback((e: MediaQueryListEvent) => {
+    if (!localStorage.getItem('theme')) {
+      dispatch(initializeTheme());
+    }
+  }, [dispatch]);
+
   // Initialize theme after mount
   useEffect(() => {
     if (!isInitialized) {
@@ -26,15 +59,9 @@ const ThemeWrapper = ({ children }: ChildrenProp) => {
   useEffect(() => {
     const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
 
-    const handleChange = (e: MediaQueryListEvent) => {
+    mediaQuery.addEventListener('change', handleMediaQueryChange);
-      if (!localStorage.getItem('theme')) {
+    return () => mediaQuery.removeEventListener('change', handleMediaQueryChange);
-        dispatch(initializeTheme());
+  }, [handleMediaQueryChange]);
-      }
-    };
-
-    mediaQuery.addEventListener('change', handleChange);
-    return () => mediaQuery.removeEventListener('change', handleChange);
-  }, [dispatch]);
 
   // Add CSS transition classes to prevent flash
   useEffect(() => {
@@ -44,34 +71,14 @@ const ThemeWrapper = ({ children }: ChildrenProp) => {
   }, []);
 
   return (
-    <div ref={configRef} className={`theme-${themeMode}`}>
+    <div ref={configRef} className={themeClassName}>
-      <ConfigProvider
+      <ConfigProvider theme={themeConfig}>
-        theme={{
-          algorithm: themeMode === 'dark' ? theme.darkAlgorithm : theme.defaultAlgorithm,
-          components: {
-            Layout: {
-              colorBgLayout: themeMode === 'dark' ? colors.darkGray : colors.white,
-              headerBg: themeMode === 'dark' ? colors.darkGray : colors.white,
-            },
-            Menu: {
-              colorBgContainer: colors.transparent,
-            },
-            Table: {
-              rowHoverBg: themeMode === 'dark' ? '#000' : '#edebf0',
-            },
-            Select: {
-              controlHeight: 32,
-            },
-          },
-          token: {
-            borderRadius: 4,
-          },
-        }}
-      >
         {children}
       </ConfigProvider>
     </div>
   );
-};
+});
+
+ThemeWrapper.displayName = 'ThemeWrapper';
 
 export default ThemeWrapper;

worklenz-frontend/src/layouts/MainLayout.tsx

@@ -1,60 +1,74 @@
 import { Col, ConfigProvider, Layout } from 'antd';
 import { Outlet, useNavigate } from 'react-router-dom';
+import { useEffect, memo, useMemo, useCallback } from 'react';
+import { useMediaQuery } from 'react-responsive';
+
 import Navbar from '../features/navbar/navbar';
 import { useAppSelector } from '../hooks/useAppSelector';
-import { useMediaQuery } from 'react-responsive';
+import { useAppDispatch } from '../hooks/useAppDispatch';
 import { colors } from '../styles/colors';
 import { verifyAuthentication } from '@/features/auth/authSlice';
-import { useEffect } from 'react';
+import { useRenderPerformance } from '@/utils/performance';
-import { useAppDispatch } from '@/hooks/useAppDispatch';
 import HubSpot from '@/components/HubSpot';
 
-const MainLayout = () => {
+const MainLayout = memo(() => {
   const themeMode = useAppSelector(state => state.themeReducer.mode);
   const isDesktop = useMediaQuery({ query: '(min-width: 1024px)' });
   const dispatch = useAppDispatch();
   const navigate = useNavigate();
 
-  const verifyAuthStatus = async () => {
+  // Performance monitoring in development
+  useRenderPerformance('MainLayout');
+
+  // Memoize auth verification function
+  const verifyAuthStatus = useCallback(async () => {
     const session = await dispatch(verifyAuthentication()).unwrap();
     if (!session.user.setup_completed) {
       navigate('/worklenz/setup');
     }
-  };
+  }, [dispatch, navigate]);
 
   useEffect(() => {
     void verifyAuthStatus();
-  }, [dispatch, navigate]);
+  }, [verifyAuthStatus]);
 
-  const headerStyles = {
+  // Memoize styles to prevent object recreation on every render
+  const headerStyles = useMemo(() => ({
     zIndex: 999,
-    position: 'fixed',
+    position: 'fixed' as const,
     width: '100%',
     display: 'flex',
     alignItems: 'center',
     padding: 0,
     borderBottom: themeMode === 'dark' ? '1px solid #303030' : 'none',
-  } as const;
+  }), [themeMode]);
 
-  const contentStyles = {
+  const contentStyles = useMemo(() => ({
     paddingInline: isDesktop ? 64 : 24,
-    overflowX: 'hidden',
+    overflowX: 'hidden' as const,
-  } as const;
+  }), [isDesktop]);
+
+  // Memoize theme configuration
+  const themeConfig = useMemo(() => ({
+    components: {
+      Layout: {
+        colorBgLayout: themeMode === 'dark' ? colors.darkGray : colors.white,
+        headerBg: themeMode === 'dark' ? colors.darkGray : colors.white,
+      },
+    },
+  }), [themeMode]);
+
+  // Memoize header className
+  const headerClassName = useMemo(() => 
+    `shadow-md ${themeMode === 'dark' ? '' : 'shadow-[#18181811]'}`,
+    [themeMode]
+  );
 
   return (
-    <ConfigProvider
+    <ConfigProvider theme={themeConfig}>
-      theme={{
-        components: {
-          Layout: {
-            colorBgLayout: themeMode === 'dark' ? colors.darkGray : colors.white,
-            headerBg: themeMode === 'dark' ? colors.darkGray : colors.white,
-          },
-        },
-      }}
-    >
       <Layout style={{ minHeight: '100vh' }}>
         <Layout.Header
-          className={`shadow-md ${themeMode === 'dark' ? '' : 'shadow-[#18181811]'}`}
+          className={headerClassName}
           style={headerStyles}
         >
           <Navbar />
@@ -71,6 +85,8 @@ const MainLayout = () => {
       </Layout>
     </ConfigProvider>
   );
-};
+});
+
+MainLayout.displayName = 'MainLayout';
 
 export default MainLayout;

worklenz-frontend/src/pages/home/home-page.tsx

@@ -1,4 +1,4 @@
-import { useEffect } from 'react';
+import { useEffect, memo, useMemo, useCallback } from 'react';
 import { useMediaQuery } from 'react-responsive';
 import Col from 'antd/es/col';
 import Flex from 'antd/es/flex';
@@ -19,48 +19,72 @@ import { fetchProjectCategories } from '@/features/projects/lookups/projectCateg
 import { fetchProjectHealth } from '@/features/projects/lookups/projectHealth/projectHealthSlice';
 import { fetchProjects } from '@/features/home-page/home-page.slice';
 import { createPortal } from 'react-dom';
-import React from 'react';
+import React, { Suspense } from 'react';
 
 const DESKTOP_MIN_WIDTH = 1024;
 const TASK_LIST_MIN_WIDTH = 500;
 const SIDEBAR_MAX_WIDTH = 400;
+
+// Lazy load heavy components
 const TaskDrawer = React.lazy(() => import('@components/task-drawer/task-drawer'));
-const HomePage = () => {
+
+const HomePage = memo(() => {
   const dispatch = useAppDispatch();
   const isDesktop = useMediaQuery({ query: `(min-width: ${DESKTOP_MIN_WIDTH}px)` });
   const isOwnerOrAdmin = useAuthService().isOwnerOrAdmin();
+  
   useDocumentTitle('Home');
 
-  useEffect(() => {
+  // Memoize fetch function to prevent recreation on every render
-    const fetchLookups = async () => {
+  const fetchLookups = useCallback(async () => {
-      const fetchPromises = [
+    const fetchPromises = [
-        dispatch(fetchProjectHealth()),
+      dispatch(fetchProjectHealth()),
-        dispatch(fetchProjectCategories()),
+      dispatch(fetchProjectCategories()),
-        dispatch(fetchProjectStatuses()),
+      dispatch(fetchProjectStatuses()),
-        dispatch(fetchProjects()),
+      dispatch(fetchProjects()),
-      ].filter(Boolean);
+    ].filter(Boolean);
 
-      await Promise.all(fetchPromises);
+    await Promise.all(fetchPromises);
-    };
-    fetchLookups();
   }, [dispatch]);
 
-  const CreateProjectButtonComponent = () =>
+  useEffect(() => {
-    isDesktop ? (
+    fetchLookups();
+  }, [fetchLookups]);
+
+  // Memoize project drawer close handler
+  const handleProjectDrawerClose = useCallback(() => {}, []);
+
+  // Memoize desktop flex styles to prevent object recreation
+  const desktopFlexStyle = useMemo(() => ({ 
+    minWidth: TASK_LIST_MIN_WIDTH, 
+    width: '100%' 
+  }), []);
+
+  const sidebarFlexStyle = useMemo(() => ({ 
+    width: '100%', 
+    maxWidth: SIDEBAR_MAX_WIDTH 
+  }), []);
+
+  // Memoize components to prevent unnecessary re-renders
+  const CreateProjectButtonComponent = useMemo(() => {
+    if (!isOwnerOrAdmin) return null;
+    
+    return isDesktop ? (
       <div className="absolute right-0 top-1/2 -translate-y-1/2">
-        {isOwnerOrAdmin && <CreateProjectButton />}
+        <CreateProjectButton />
       </div>
     ) : (
-      isOwnerOrAdmin && <CreateProjectButton />
+      <CreateProjectButton />
     );
+  }, [isDesktop, isOwnerOrAdmin]);
 
-  const MainContent = () =>
+  const MainContent = useMemo(() => {
-    isDesktop ? (
+    return isDesktop ? (
       <Flex gap={24} align="flex-start" className="w-full mt-12">
-        <Flex style={{ minWidth: TASK_LIST_MIN_WIDTH, width: '100%' }}>
+        <Flex style={desktopFlexStyle}>
           <TasksList />
         </Flex>
-        <Flex vertical gap={24} style={{ width: '100%', maxWidth: SIDEBAR_MAX_WIDTH }}>
+        <Flex vertical gap={24} style={sidebarFlexStyle}>
           <TodoList />
           <RecentAndFavouriteProjectList />
         </Flex>
@@ -72,19 +96,31 @@ const HomePage = () => {
         <RecentAndFavouriteProjectList />
       </Flex>
     );
+  }, [isDesktop, desktopFlexStyle, sidebarFlexStyle]);
 
   return (
     <div className="my-24 min-h-[90vh]">
       <Col className="flex flex-col gap-6">
         <GreetingWithTime />
-        <CreateProjectButtonComponent />
+        {CreateProjectButtonComponent}
       </Col>
 
-      <MainContent />
+      {MainContent}
-      {createPortal(<TaskDrawer />, document.body, 'home-task-drawer')}
+      
-      {createPortal(<ProjectDrawer onClose={() => {}} />, document.body, 'project-drawer')}
+      {/* Use Suspense for lazy-loaded components */}
+      <Suspense fallback={null}>
+        {createPortal(<TaskDrawer />, document.body, 'home-task-drawer')}
+      </Suspense>
+      
+      {createPortal(
+        <ProjectDrawer onClose={handleProjectDrawerClose} />, 
+        document.body, 
+        'project-drawer'
+      )}
     </div>
   );
-};
+});
+
+HomePage.displayName = 'HomePage';
 
 export default HomePage;

worklenz-frontend/src/utils/performance.ts

@@ -0,0 +1,182 @@
+import React from 'react';
+
+/**
+ * Performance monitoring utilities for development
+ */
+
+const isProduction = import.meta.env.PROD;
+const isDevelopment = !isProduction;
+
+interface PerformanceEntry {
+  name: string;
+  startTime: number;
+  duration?: number;
+}
+
+class PerformanceMonitor {
+  private timers: Map<string, number> = new Map();
+  private entries: PerformanceEntry[] = [];
+
+  /**
+   * Start timing a performance measurement
+   */
+  public startTimer(name: string): void {
+    if (isProduction) return;
+    
+    this.timers.set(name, performance.now());
+  }
+
+  /**
+   * End timing and log the result
+   */
+  public endTimer(name: string): number | null {
+    if (isProduction) return null;
+
+    const startTime = this.timers.get(name);
+    if (!startTime) {
+      console.warn(`Performance timer "${name}" was not started`);
+      return null;
+    }
+
+    const endTime = performance.now();
+    const duration = endTime - startTime;
+
+    this.timers.delete(name);
+    this.entries.push({ name, startTime, duration });
+
+    if (isDevelopment) {
+      const color = duration > 100 ? '#ff4d4f' : duration > 50 ? '#faad14' : '#52c41a';
+      console.log(
+        `%c⏱️ ${name}: ${duration.toFixed(2)}ms`,
+        `color: ${color}; font-weight: bold;`
+      );
+    }
+
+    return duration;
+  }
+
+  /**
+   * Measure the performance of a function
+   */
+  public measure<T>(name: string, fn: () => T): T {
+    if (isProduction) return fn();
+
+    this.startTimer(name);
+    const result = fn();
+    this.endTimer(name);
+    return result;
+  }
+
+  /**
+   * Measure the performance of an async function
+   */
+  public async measureAsync<T>(name: string, fn: () => Promise<T>): Promise<T> {
+    if (isProduction) return fn();
+
+    this.startTimer(name);
+    const result = await fn();
+    this.endTimer(name);
+    return result;
+  }
+
+  /**
+   * Get all performance entries
+   */
+  public getEntries(): PerformanceEntry[] {
+    return [...this.entries];
+  }
+
+  /**
+   * Clear all entries
+   */
+  public clearEntries(): void {
+    this.entries = [];
+  }
+
+  /**
+   * Log a summary of all performance entries
+   */
+  public logSummary(): void {
+    if (isProduction || this.entries.length === 0) return;
+
+    console.group('📊 Performance Summary');
+    
+    const sortedEntries = this.entries
+      .filter(entry => entry.duration !== undefined)
+      .sort((a, b) => (b.duration || 0) - (a.duration || 0));
+
+    console.table(
+      sortedEntries.map(entry => ({
+        Name: entry.name,
+        Duration: `${(entry.duration || 0).toFixed(2)}ms`,
+        'Start Time': `${entry.startTime.toFixed(2)}ms`
+      }))
+    );
+
+    const totalTime = sortedEntries.reduce((sum, entry) => sum + (entry.duration || 0), 0);
+    console.log(`%cTotal measured time: ${totalTime.toFixed(2)}ms`, 'font-weight: bold;');
+    
+    console.groupEnd();
+  }
+}
+
+// Create default instance
+export const performanceMonitor = new PerformanceMonitor();
+
+/**
+ * Higher-order component to measure component render performance
+ */
+export function withPerformanceMonitoring<P extends object>(
+  Component: React.ComponentType<P>,
+  componentName?: string
+): React.ComponentType<P> {
+  if (isProduction) return Component;
+
+  const name = componentName || Component.displayName || Component.name || 'Unknown';
+  
+  const WrappedComponent = (props: P) => {
+    React.useEffect(() => {
+      performanceMonitor.startTimer(`${name} mount`);
+      return () => {
+        performanceMonitor.endTimer(`${name} mount`);
+      };
+    }, []);
+
+    React.useEffect(() => {
+      performanceMonitor.endTimer(`${name} render`);
+    });
+
+    performanceMonitor.startTimer(`${name} render`);
+    return React.createElement(Component, props);
+  };
+
+  WrappedComponent.displayName = `withPerformanceMonitoring(${name})`;
+  return WrappedComponent;
+}
+
+/**
+ * Hook to measure render performance
+ */
+export function useRenderPerformance(componentName: string): void {
+  if (isProduction) return;
+
+  const renderCount = React.useRef(0);
+  const startTime = React.useRef<number>(0);
+
+  React.useEffect(() => {
+    renderCount.current += 1;
+    const endTime = performance.now();
+    const duration = endTime - startTime.current;
+
+    if (renderCount.current > 1) {
+      console.log(
+        `%c🔄 ${componentName} render #${renderCount.current}: ${duration.toFixed(2)}ms`,
+        'color: #1890ff; font-size: 11px;'
+      );
+    }
+  });
+
+  startTime.current = performance.now();
+}
+
+export default performanceMonitor; 

worklenz-frontend/src/utils/routePreloader.ts

@@ -0,0 +1,181 @@
+import React from 'react';
+
+/**
+ * Route preloader utility to prefetch components and improve navigation performance
+ */
+
+interface PreloadableRoute {
+  path: string;
+  loader: () => Promise<any>;
+  priority: 'high' | 'medium' | 'low';
+}
+
+class RoutePreloader {
+  private preloadedRoutes = new Set<string>();
+  private preloadQueue: PreloadableRoute[] = [];
+  private isPreloading = false;
+
+  /**
+   * Register a route for preloading
+   */
+  public registerRoute(path: string, loader: () => Promise<any>, priority: 'high' | 'medium' | 'low' = 'medium'): void {
+    if (this.preloadedRoutes.has(path)) return;
+
+    this.preloadQueue.push({ path, loader, priority });
+    this.sortQueue();
+  }
+
+  /**
+   * Preload a specific route immediately
+   */
+  public async preloadRoute(path: string, loader: () => Promise<any>): Promise<void> {
+    if (this.preloadedRoutes.has(path)) return;
+
+    try {
+      await loader();
+      this.preloadedRoutes.add(path);
+    } catch (error) {
+      console.warn(`Failed to preload route: ${path}`, error);
+    }
+  }
+
+  /**
+   * Start preloading routes in the queue
+   */
+  public async startPreloading(): Promise<void> {
+    if (this.isPreloading || this.preloadQueue.length === 0) return;
+
+    this.isPreloading = true;
+
+    // Use requestIdleCallback if available, otherwise setTimeout
+    const scheduleWork = (callback: () => void) => {
+      if ('requestIdleCallback' in window) {
+        requestIdleCallback(callback, { timeout: 1000 });
+      } else {
+        setTimeout(callback, 0);
+      }
+    };
+
+    const processQueue = async () => {
+      while (this.preloadQueue.length > 0) {
+        const route = this.preloadQueue.shift();
+        if (!route) break;
+
+        if (this.preloadedRoutes.has(route.path)) continue;
+
+        try {
+          await route.loader();
+          this.preloadedRoutes.add(route.path);
+        } catch (error) {
+          console.warn(`Failed to preload route: ${route.path}`, error);
+        }
+
+        // Yield control back to the browser
+        await new Promise<void>(resolve => scheduleWork(() => resolve()));
+      }
+
+      this.isPreloading = false;
+    };
+
+    scheduleWork(processQueue);
+  }
+
+  /**
+   * Preload routes on user interaction (hover, focus)
+   */
+  public preloadOnInteraction(element: HTMLElement, path: string, loader: () => Promise<any>): void {
+    if (this.preloadedRoutes.has(path)) return;
+
+    let preloadTriggered = false;
+
+    const handleInteraction = () => {
+      if (preloadTriggered) return;
+      preloadTriggered = true;
+
+      this.preloadRoute(path, loader);
+      
+      // Clean up listeners
+      element.removeEventListener('mouseenter', handleInteraction);
+      element.removeEventListener('focus', handleInteraction);
+      element.removeEventListener('touchstart', handleInteraction);
+    };
+
+    element.addEventListener('mouseenter', handleInteraction, { passive: true });
+    element.addEventListener('focus', handleInteraction, { passive: true });
+    element.addEventListener('touchstart', handleInteraction, { passive: true });
+  }
+
+  /**
+   * Preload routes when the browser is idle
+   */
+  public preloadOnIdle(): void {
+    if ('requestIdleCallback' in window) {
+      requestIdleCallback(() => {
+        this.startPreloading();
+      }, { timeout: 2000 });
+    } else {
+      setTimeout(() => {
+        this.startPreloading();
+      }, 1000);
+    }
+  }
+
+  /**
+   * Check if a route is already preloaded
+   */
+  public isRoutePreloaded(path: string): boolean {
+    return this.preloadedRoutes.has(path);
+  }
+
+  /**
+   * Clear all preloaded routes
+   */
+  public clearPreloaded(): void {
+    this.preloadedRoutes.clear();
+    this.preloadQueue = [];
+  }
+
+  private sortQueue(): void {
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    this.preloadQueue.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  }
+}
+
+// Create default instance
+export const routePreloader = new RoutePreloader();
+
+/**
+ * React hook to preload routes on component mount
+ */
+export function useRoutePreloader(routes: Array<{ path: string; loader: () => Promise<any>; priority?: 'high' | 'medium' | 'low' }>): void {
+  React.useEffect(() => {
+    routes.forEach(route => {
+      routePreloader.registerRoute(route.path, route.loader, route.priority);
+    });
+
+    // Start preloading after a short delay to not interfere with initial render
+    const timer = setTimeout(() => {
+      routePreloader.preloadOnIdle();
+    }, 100);
+
+    return () => clearTimeout(timer);
+  }, [routes]);
+}
+
+/**
+ * React hook to preload a route on element interaction
+ */
+export function usePreloadOnHover(path: string, loader: () => Promise<any>) {
+  const elementRef = React.useRef<HTMLElement>(null);
+
+  React.useEffect(() => {
+    const element = elementRef.current;
+    if (!element) return;
+
+    routePreloader.preloadOnInteraction(element, path, loader);
+  }, [path, loader]);
+
+  return elementRef;
+}
+
+export default routePreloader;