mcp-quiz-server/public/dist/services/AppInitializer.js

🧠 AI-Powered Quiz Management via Model Context Protocol (MCP) - Create, manage, and take quizzes directly from VS Code, Claude, and other AI agents.

import { AppStore } from '../store/AppStore';
import { DemoConfigService } from './DemoConfigService';
import { SettingsManager } from './SettingsManager';
export class AppInitializer {
    static async initialize() {
        if (this.initialized) {
            console.log('⚡ Application already initialized');
            return;
        }
        console.log('🚀 Initializing Quiz Platform application...');
        try {
            await this.initializeSettings();
            await this.initializeDemoConfigs();
            await this.initializeAppState();
            this.setupGlobalErrorHandling();
            this.setupPerformanceMonitoring();
            this.initialized = true;
            console.log('✅ Quiz Platform application initialized successfully');
            window.dispatchEvent(new CustomEvent('app:initialized'));
        }
        catch (error) {
            console.error('❌ Failed to initialize application:', error);
            throw error;
        }
    }
    static async initializeSettings() {
        console.log('⚙️ Initializing settings management...');
        const settingsManager = SettingsManager.getInstance();
        settingsManager.subscribe(settings => {
            console.log('⚙️ Settings updated globally:', settings);
            if (settings.ui.theme) {
                document.documentElement.setAttribute('data-theme', settings.ui.theme);
            }
            if (settings.ui.reducedMotion) {
                document.documentElement.style.setProperty('--animation-duration', '0ms');
            }
            else {
                document.documentElement.style.removeProperty('--animation-duration');
            }
            document.documentElement.setAttribute('data-font-size', settings.ui.fontSize);
        });
        console.log('✅ Settings management initialized');
    }
    static async initializeDemoConfigs() {
        console.log('🎬 Initializing demo configuration system...');
        await DemoConfigService.initialize();
        console.log('✅ Demo configuration system initialized');
    }
    static async initializeAppState() {
        console.log('🏪 Initializing application state...');
        const appStore = AppStore.getInstance();
        appStore.subscribe(state => {
            if (state.currentQuiz || state.ui.showWelcome || state.ui.showResults) {
                appStore.updateSubmitBarVisibility();
            }
        });
        console.log('✅ Application state initialized');
    }
    static setupGlobalErrorHandling() {
        console.log('🛡️ Setting up global error handling...');
        window.addEventListener('error', event => {
            console.error('🚨 Global error:', event.error);
            if (event.error?.name === 'ChunkLoadError') {
                this.showReloadPrompt('A new version is available. Please reload the page.');
            }
        });
        window.addEventListener('unhandledrejection', event => {
            console.error('🚨 Unhandled promise rejection:', event.reason);
            if (event.reason?.name === 'NetworkError') {
                event.preventDefault();
                console.warn('⚠️ Network error handled gracefully');
            }
        });
        console.log('✅ Global error handling set up');
    }
    static setupPerformanceMonitoring() {
        console.log('📊 Setting up performance monitoring...');
        if ('PerformanceObserver' in window) {
            const observer = new PerformanceObserver(list => {
                list.getEntries().forEach(entry => {
                    if (entry.duration > 50) {
                        console.warn('⚠️ Long task detected:', entry.duration, 'ms');
                    }
                });
            });
            try {
                observer.observe({ entryTypes: ['longtask'] });
            }
            catch (error) {
                console.warn('Performance monitoring not fully supported:', error);
            }
        }
        window.addEventListener('load', () => {
            setTimeout(() => {
                const navigation = performance.getEntriesByType('navigation')[0];
                if (navigation) {
                    const loadTime = navigation.loadEventEnd - navigation.loadEventStart;
                    console.log(`📊 Page load time: ${loadTime}ms`);
                    if (loadTime > 3000) {
                        console.warn('⚠️ Slow page load detected');
                    }
                }
            }, 0);
        });
        console.log('✅ Performance monitoring set up');
    }
    static showReloadPrompt(message) {
        const shouldReload = confirm(`${message}\n\nReload now?`);
        if (shouldReload) {
            window.location.reload();
        }
    }
    static isInitialized() {
        return this.initialized;
    }
    static reset() {
        this.initialized = false;
        console.log('🔄 Application initialization reset');
    }
    static async initializeWithConfig(config = {}) {
        if (this.initialized)
            return;
        console.log('🚀 Initializing with custom configuration...', config);
        try {
            await this.initializeSettings();
            if (!config.skipDemos) {
                await this.initializeDemoConfigs();
            }
            await this.initializeAppState();
            if (!config.skipErrorHandling) {
                this.setupGlobalErrorHandling();
            }
            if (!config.skipPerformanceMonitoring) {
                this.setupPerformanceMonitoring();
            }
            this.initialized = true;
            console.log('✅ Custom initialization complete');
        }
        catch (error) {
            console.error('❌ Custom initialization failed:', error);
            throw error;
        }
    }
}
AppInitializer.initialized = false;
//# sourceMappingURL=AppInitializer.js.map