@therealtinhtute/baroiplayer 1.0.5 → 1.0.7

package/src/core/performance/performance-testing.js

@@ -1,314 +0,0 @@
-import { PerformanceRegressionDetector } from './performance-monitor';
-// Performance benchmark suite
-export class PerformanceBenchmark {
-    results = [];
-    regressionDetector = new PerformanceRegressionDetector();
-    async runTest(config, testFunction) {
-        const renderTimes = [];
-        let memoryBefore = 0;
-        let memoryAfter = 0;
-        let error;
-        try {
-            // Warmup iterations
-            for (let i = 0; i < config.warmupIterations; i++) {
-                await testFunction();
-            }
-            // Force garbage collection if available
-            if (global.gc) {
-                global.gc();
-            }
-            memoryBefore = this.getMemoryUsage();
-            // Main test iterations
-            for (let i = 0; i < config.iterations; i++) {
-                const startTime = performance.now();
-                await testFunction();
-                const endTime = performance.now();
-                renderTimes.push(endTime - startTime);
-            }
-            memoryAfter = this.getMemoryUsage();
-        }
-        catch (err) {
-            error = err instanceof Error ? err.message : String(err);
-        }
-        const averageRenderTime = renderTimes.reduce((sum, time) => sum + time, 0) / renderTimes.length;
-        const minRenderTime = Math.min(...renderTimes);
-        const maxRenderTime = Math.max(...renderTimes);
-        const memoryUsage = memoryAfter - memoryBefore;
-        const passed = !error &&
-            averageRenderTime <= config.expectedThreshold.renderTime &&
-            memoryUsage <= config.expectedThreshold.memoryUsage;
-        const result = {
-            testName: config.name,
-            passed,
-            metrics: {
-                averageRenderTime,
-                minRenderTime: isFinite(minRenderTime) ? minRenderTime : 0,
-                maxRenderTime: isFinite(maxRenderTime) ? maxRenderTime : 0,
-                memoryUsage,
-                iterations: config.iterations
-            },
-            threshold: config.expectedThreshold,
-            error
-        };
-        this.results.push(result);
-        return result;
-    }
-    getMemoryUsage() {
-        if ('memory' in performance) {
-            return performance.memory.usedJSHeapSize || 0;
-        }
-        return 0;
-    }
-    // Component rendering performance test
-    async testComponentRender(componentName, renderFunction, expectedRenderTime = 16 // 60fps target
-    ) {
-        const config = {
-            name: `${componentName} Render Performance`,
-            iterations: 100,
-            warmupIterations: 10,
-            timeout: 5000,
-            expectedThreshold: {
-                renderTime: expectedRenderTime,
-                memoryUsage: 1024 * 1024 // 1MB
-            }
-        };
-        return this.runTest(config, renderFunction);
-    }
-    // Bundle loading performance test
-    async testBundleLoading(bundlePath, expectedLoadTime = 1000 // 1 second
-    ) {
-        const config = {
-            name: `Bundle Loading: ${bundlePath}`,
-            iterations: 5,
-            warmupIterations: 1,
-            timeout: 10000,
-            expectedThreshold: {
-                renderTime: expectedLoadTime,
-                memoryUsage: 5 * 1024 * 1024 // 5MB
-            }
-        };
-        return this.runTest(config, async () => {
-            // Simulate bundle loading
-            const startTime = performance.now();
-            try {
-                // Use fetch instead of dynamic import to avoid bundler issues
-                const response = await fetch(bundlePath);
-                if (!response.ok) {
-                    throw new Error(`Failed to load bundle: ${response.status}`);
-                }
-                await response.blob(); // Consume the response
-            }
-            catch (error) {
-                console.warn(`Bundle loading test failed for ${bundlePath}:`, error);
-                // Return a mock time for testing purposes
-            }
-            const endTime = performance.now();
-            return endTime - startTime;
-        });
-    }
-    // Memory leak detection test
-    async testMemoryLeaks(testFunction, iterations = 1000) {
-        const config = {
-            name: 'Memory Leak Detection',
-            iterations,
-            warmupIterations: 100,
-            timeout: 30000,
-            expectedThreshold: {
-                renderTime: Infinity, // Not testing render time
-                memoryUsage: 10 * 1024 * 1024 // 10MB max increase
-            }
-        };
-        const memoryBefore = this.getMemoryUsage();
-        const result = await this.runTest(config, testFunction);
-        const memoryAfter = this.getMemoryUsage();
-        const memoryIncrease = memoryAfter - memoryBefore;
-        // Check for memory leaks (memory should not increase significantly)
-        const hasMemoryLeak = memoryIncrease > config.expectedThreshold.memoryUsage;
-        return {
-            ...result,
-            passed: result.passed && !hasMemoryLeak,
-            error: hasMemoryLeak ? `Potential memory leak detected: ${Math.round(memoryIncrease / 1024 / 1024)}MB increase` : result.error
-        };
-    }
-    // Interaction delay test
-    async testInteractionDelay(interactionFunction, expectedDelay = 100 // 100ms
-    ) {
-        const config = {
-            name: 'Interaction Delay',
-            iterations: 50,
-            warmupIterations: 5,
-            timeout: 5000,
-            expectedThreshold: {
-                renderTime: expectedDelay,
-                memoryUsage: 1024 * 1024 // 1MB
-            }
-        };
-        return this.runTest(config, interactionFunction);
-    }
-    // Regression testing
-    async runRegressionTests(currentMetrics, baselineMetrics) {
-        if (baselineMetrics) {
-            this.regressionDetector.setBaseline(baselineMetrics);
-        }
-        const regressions = this.regressionDetector.detectRegression(currentMetrics);
-        const passed = regressions.length === 0;
-        return { passed, regressions };
-    }
-    // Get all test results
-    getResults() {
-        return [...this.results];
-    }
-    // Get test summary
-    getSummary() {
-        const totalTests = this.results.length;
-        const passedTests = this.results.filter(result => result.passed).length;
-        const failedTests = totalTests - passedTests;
-        const passRate = totalTests > 0 ? (passedTests / totalTests) * 100 : 0;
-        return { totalTests, passedTests, failedTests, passRate };
-    }
-    // Clear test results
-    clearResults() {
-        this.results = [];
-    }
-    // Generate performance report
-    generateReport() {
-        const summary = this.getSummary();
-        let report = `Performance Test Report\n`;
-        report += `========================\n\n`;
-        report += `Total Tests: ${summary.totalTests}\n`;
-        report += `Passed: ${summary.passedTests}\n`;
-        report += `Failed: ${summary.failedTests}\n`;
-        report += `Pass Rate: ${summary.passRate.toFixed(1)}%\n\n`;
-        if (this.results.length > 0) {
-            report += `Detailed Results:\n`;
-            report += `-----------------\n\n`;
-            this.results.forEach((result, index) => {
-                report += `${index + 1}. ${result.testName}\n`;
-                report += `   Status: ${result.passed ? 'PASS' : 'FAIL'}\n`;
-                report += `   Average Render Time: ${result.metrics.averageRenderTime.toFixed(2)}ms\n`;
-                report += `   Min/Max Render Time: ${result.metrics.minRenderTime.toFixed(2)}ms / ${result.metrics.maxRenderTime.toFixed(2)}ms\n`;
-                report += `   Memory Usage: ${Math.round(result.metrics.memoryUsage / 1024)} KB\n`;
-                report += `   Iterations: ${result.metrics.iterations}\n`;
-                if (result.error) {
-                    report += `   Error: ${result.error}\n`;
-                }
-                report += `\n`;
-            });
-        }
-        return report;
-    }
-}
-// Global performance benchmark instance
-export const performanceBenchmark = new PerformanceBenchmark();
-// Utility functions for common performance tests
-export const performanceTestUtils = {
-    // Test component rendering performance
-    async testComponent(Component, props = {}, expectedRenderTime = 16) {
-        return performanceBenchmark.testComponentRender(Component.displayName || Component.name || 'Component', () => {
-            // This would need React Testing Library in a real test environment
-            // For now, we'll simulate component rendering
-            return { type: Component, props }; // Mock element
-        }, expectedRenderTime);
-    },
-    // Test hook performance
-    async testHook(hookFunction, hookName, expectedExecutionTime = 1) {
-        const config = {
-            name: `Hook Performance: ${hookName}`,
-            iterations: 1000,
-            warmupIterations: 100,
-            timeout: 5000,
-            expectedThreshold: {
-                renderTime: expectedExecutionTime,
-                memoryUsage: 1024 * 1024 // 1MB
-            }
-        };
-        return performanceBenchmark.runTest(config, hookFunction);
-    },
-    // Test async operation performance
-    async testAsyncOperation(operation, operationName, expectedTime = 1000) {
-        const config = {
-            name: `Async Operation: ${operationName}`,
-            iterations: 10,
-            warmupIterations: 2,
-            timeout: 30000,
-            expectedThreshold: {
-                renderTime: expectedTime,
-                memoryUsage: 2 * 1024 * 1024 // 2MB
-            }
-        };
-        return performanceBenchmark.runTest(config, operation);
-    },
-    // Test bundle size impact
-    async measureBundleImpact(beforeFunction, afterFunction, featureName) {
-        const beforeMemory = performance.memory?.usedJSHeapSize || 0;
-        const beforeTime = performance.now();
-        beforeFunction();
-        const midMemory = performance.memory?.usedJSHeapSize || 0;
-        const midTime = performance.now();
-        afterFunction();
-        const afterMemory = performance.memory?.usedJSHeapSize || 0;
-        const afterTime = performance.now();
-        return {
-            bundleIncrease: afterMemory - beforeMemory,
-            memoryIncrease: midMemory - beforeMemory,
-            renderTimeImpact: (afterTime - midTime) - (midTime - beforeTime)
-        };
-    }
-};
-// Performance testing framework
-export class PerformanceTestFramework {
-    benchmark = new PerformanceBenchmark();
-    suites = new Map();
-    // Register a test suite
-    registerSuite(suiteName, tests) {
-        this.suites.set(suiteName, tests);
-    }
-    // Run all tests in a suite
-    async runSuite(suiteName, testImplementations) {
-        const tests = this.suites.get(suiteName);
-        if (!tests) {
-            throw new Error(`Test suite '${suiteName}' not found`);
-        }
-        const results = [];
-        for (const test of tests) {
-            const implementation = testImplementations.get(test.name);
-            if (!implementation) {
-                console.warn(`No implementation found for test '${test.name}'`);
-                continue;
-            }
-            const result = await this.benchmark.runTest(test, implementation);
-            results.push(result);
-        }
-        return results;
-    }
-    // Run all registered test suites
-    async runAllSuites(implementations) {
-        const allResults = new Map();
-        for (const [suiteName] of this.suites) {
-            const suiteImplementations = implementations.get(suiteName);
-            if (!suiteImplementations) {
-                console.warn(`No implementations found for suite '${suiteName}'`);
-                continue;
-            }
-            const results = await this.runSuite(suiteName, suiteImplementations);
-            allResults.set(suiteName, results);
-        }
-        return allResults;
-    }
-    // Generate comprehensive report
-    generateComprehensiveReport() {
-        const summary = this.benchmark.getSummary();
-        let report = this.benchmark.generateReport();
-        // Add suite breakdown if available
-        if (this.suites.size > 0) {
-            report += `\nTest Suites:\n`;
-            report += `============\n\n`;
-            for (const [suiteName, tests] of this.suites) {
-                report += `Suite: ${suiteName}\n`;
-                report += `Tests: ${tests.length}\n\n`;
-            }
-        }
-        return report;
-    }
-}
-export const performanceTestFramework = new PerformanceTestFramework();

package/src/core/plugins/base-plugin.js

@@ -1,151 +0,0 @@
-// Abstract base plugin class
-export class BasePlugin {
-    metadata;
-    context;
-    config = {};
-    initialized = false;
-    active = false;
-    constructor(metadata) {
-        this.metadata = {
-            version: '1.0.0',
-            ...metadata
-        };
-    }
-    // Plugin lifecycle methods - can be overridden by subclasses
-    async initialize(context, config = {}) {
-        if (this.initialized) {
-            context.logger.warn('Plugin already initialized');
-            return;
-        }
-        this.context = context;
-        this.config = { ...this.config, ...config };
-        try {
-            await this.onInitialize();
-            this.initialized = true;
-            context.logger.info(`Plugin initialized`);
-        }
-        catch (error) {
-            context.logger.error('Failed to initialize plugin', error);
-            throw error;
-        }
-    }
-    async activate(context) {
-        if (!this.initialized) {
-            throw new Error('Plugin must be initialized before activation');
-        }
-        if (this.active) {
-            context.logger.warn('Plugin already active');
-            return;
-        }
-        try {
-            await this.onActivate();
-            this.active = true;
-            context.logger.info(`Plugin activated`);
-        }
-        catch (error) {
-            context.logger.error('Failed to activate plugin', error);
-            throw error;
-        }
-    }
-    async deactivate(context) {
-        if (!this.active) {
-            context.logger.warn('Plugin already inactive');
-            return;
-        }
-        try {
-            await this.onDeactivate();
-            this.active = false;
-            context.logger.info(`Plugin deactivated`);
-        }
-        catch (error) {
-            context.logger.error('Failed to deactivate plugin', error);
-            throw error;
-        }
-    }
-    async destroy(context) {
-        if (this.active) {
-            await this.deactivate(context);
-        }
-        try {
-            await this.onDestroy();
-            this.initialized = false;
-            context.logger.info(`Plugin destroyed`);
-        }
-        catch (error) {
-            context.logger.error('Failed to destroy plugin', error);
-            throw error;
-        }
-    }
-    async configure(config) {
-        const oldConfig = { ...this.config };
-        this.config = { ...this.config, ...config };
-        try {
-            await this.onConfigure(config, oldConfig);
-            this.context?.logger.info('Plugin configured');
-        }
-        catch (error) {
-            // Rollback configuration on error
-            this.config = oldConfig;
-            this.context?.logger.error('Failed to configure plugin', error);
-            throw error;
-        }
-    }
-    healthCheck() {
-        return this.initialized && this.onHealthCheck();
-    }
-    onDestroy() {
-        // Default implementation - subclasses can override
-    }
-    onConfigure(newConfig, oldConfig) {
-        // Default implementation - subclasses can override
-    }
-    onHealthCheck() {
-        // Default implementation - subclasses can override
-        return true;
-    }
-    // Utility methods for plugins
-    get state() {
-        return this.context?.state;
-    }
-    get controls() {
-        return this.context?.controls;
-    }
-    get element() {
-        return this.context?.element;
-    }
-    get logger() {
-        return this.context?.logger;
-    }
-    emit(event, data) {
-        this.context?.emit(event, data);
-    }
-    on(event, handler) {
-        return this.context?.on(event, handler) || (() => { });
-    }
-    // Helper methods for common plugin patterns
-    addEventListeners(element, events) {
-        Object.entries(events).forEach(([event, handler]) => {
-            element.addEventListener(event, handler);
-        });
-        // Return cleanup function
-        return () => {
-            Object.entries(events).forEach(([event, handler]) => {
-                element.removeEventListener(event, handler);
-            });
-        };
-    }
-    createConfig(defaults) {
-        return { ...defaults, ...this.config };
-    }
-    // Plugin status
-    get isInitialized() {
-        return this.initialized;
-    }
-    get isActive() {
-        return this.active;
-    }
-}
-// Simple plugin factory helper
-export function createPlugin(PluginClass) {
-    return (config) => new PluginClass(config);
-}