@therealtinhtute/baroiplayer 1.0.0 → 1.0.2

package/dist/src/core/performance/performance-testing.ts

@@ -0,0 +1,459 @@
+import { performanceMonitor, PerformanceRegressionDetector } from './performance-monitor';
+import type { PerformanceMetrics } from './performance-monitor';
+
+// Performance test configuration
+export interface PerformanceTestConfig {
+  name: string;
+  iterations: number;
+  warmupIterations: number;
+  timeout: number;
+  expectedThreshold: {
+    renderTime: number;
+    memoryUsage: number;
+  };
+}
+
+// Performance test result
+export interface PerformanceTestResult {
+  testName: string;
+  passed: boolean;
+  metrics: {
+    averageRenderTime: number;
+    minRenderTime: number;
+    maxRenderTime: number;
+    memoryUsage: number;
+    iterations: number;
+  };
+  threshold: PerformanceTestConfig['expectedThreshold'];
+  error?: string;
+}
+
+// Performance benchmark suite
+export class PerformanceBenchmark {
+  private results: PerformanceTestResult[] = [];
+  private regressionDetector = new PerformanceRegressionDetector();
+
+  async runTest(
+    config: PerformanceTestConfig,
+    testFunction: () => any | Promise<any>
+  ): Promise<PerformanceTestResult> {
+    const renderTimes: number[] = [];
+    let memoryBefore = 0;
+    let memoryAfter = 0;
+    let error: string | undefined;
+
+    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: PerformanceTestResult = {
+      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;
+  }
+
+  private getMemoryUsage(): number {
+    if ('memory' in performance) {
+      return (performance as any).memory.usedJSHeapSize || 0;
+    }
+    return 0;
+  }
+
+  // Component rendering performance test
+  async testComponentRender(
+    componentName: string,
+    renderFunction: () => any,
+    expectedRenderTime = 16 // 60fps target
+  ): Promise<PerformanceTestResult> {
+    const config: PerformanceTestConfig = {
+      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: string,
+    expectedLoadTime = 1000 // 1 second
+  ): Promise<PerformanceTestResult> {
+    const config: PerformanceTestConfig = {
+      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: () => any,
+    iterations = 1000
+  ): Promise<PerformanceTestResult> {
+    const config: PerformanceTestConfig = {
+      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: () => any,
+    expectedDelay = 100 // 100ms
+  ): Promise<PerformanceTestResult> {
+    const config: PerformanceTestConfig = {
+      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: PerformanceMetrics,
+    baselineMetrics?: PerformanceMetrics
+  ): Promise<{
+    passed: boolean;
+    regressions: ReturnType<PerformanceRegressionDetector['detectRegression']>;
+  }> {
+    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(): PerformanceTestResult[] {
+    return [...this.results];
+  }
+
+  // Get test summary
+  getSummary(): {
+    totalTests: number;
+    passedTests: number;
+    failedTests: number;
+    passRate: number;
+  } {
+    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(): void {
+    this.results = [];
+  }
+
+  // Generate performance report
+  generateReport(): string {
+    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: any,
+    props: any = {},
+    expectedRenderTime = 16
+  ): Promise<PerformanceTestResult> {
+    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: () => any,
+    hookName: string,
+    expectedExecutionTime = 1
+  ): Promise<PerformanceTestResult> {
+    const config: PerformanceTestConfig = {
+      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: () => Promise<any>,
+    operationName: string,
+    expectedTime = 1000
+  ): Promise<PerformanceTestResult> {
+    const config: PerformanceTestConfig = {
+      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: () => void,
+    afterFunction: () => void,
+    featureName: string
+  ): Promise<{
+    bundleIncrease: number;
+    memoryIncrease: number;
+    renderTimeImpact: number;
+  }> {
+    const beforeMemory = (performance as any).memory?.usedJSHeapSize || 0;
+    const beforeTime = performance.now();
+    
+    beforeFunction();
+    
+    const midMemory = (performance as any).memory?.usedJSHeapSize || 0;
+    const midTime = performance.now();
+    
+    afterFunction();
+    
+    const afterMemory = (performance as any).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 {
+  private benchmark = new PerformanceBenchmark();
+  private suites: Map<string, PerformanceTestConfig[]> = new Map();
+
+  // Register a test suite
+  registerSuite(suiteName: string, tests: PerformanceTestConfig[]) {
+    this.suites.set(suiteName, tests);
+  }
+
+  // Run all tests in a suite
+  async runSuite(
+    suiteName: string,
+    testImplementations: Map<string, () => any>
+  ): Promise<PerformanceTestResult[]> {
+    const tests = this.suites.get(suiteName);
+    if (!tests) {
+      throw new Error(`Test suite '${suiteName}' not found`);
+    }
+
+    const results: PerformanceTestResult[] = [];
+
+    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: Map<string, Map<string, () => any>>
+  ): Promise<Map<string, PerformanceTestResult[]>> {
+    const allResults = new Map<string, PerformanceTestResult[]>();
+
+    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(): string {
+    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/dist/src/core/plugins/base-plugin.d.ts

@@ -0,0 +1,52 @@
+import type { Plugin, PluginMetadata, PluginContext, PluginConfig } from './types';
+export declare abstract class BasePlugin implements Plugin {
+    readonly metadata: PluginMetadata;
+    protected context?: PluginContext;
+    protected config: PluginConfig;
+    protected initialized: boolean;
+    protected active: boolean;
+    constructor(metadata: Omit<PluginMetadata, 'version'> & {
+        version?: string;
+    });
+    initialize(context: PluginContext, config?: PluginConfig): Promise<void>;
+    activate(context: PluginContext): Promise<void>;
+    deactivate(context: PluginContext): Promise<void>;
+    destroy(context: PluginContext): Promise<void>;
+    configure(config: PluginConfig): Promise<void>;
+    healthCheck(): boolean;
+    protected abstract onInitialize(): Promise<void> | void;
+    protected abstract onActivate(): Promise<void> | void;
+    protected abstract onDeactivate(): Promise<void> | void;
+    protected onDestroy(): Promise<void> | void;
+    protected onConfigure(newConfig: PluginConfig, oldConfig: PluginConfig): Promise<void> | void;
+    protected onHealthCheck(): boolean;
+    protected get state(): import("./types").MediaState | undefined;
+    protected get controls(): import("./types").MediaPlayerControls | undefined;
+    protected get element(): HTMLElement | null | undefined;
+    protected get logger(): import("./types").PluginLogger | undefined;
+    protected emit(event: string, data?: any): void;
+    protected on(event: string, handler: (data: any) => void): () => void;
+    protected addEventListeners(element: HTMLElement, events: Record<string, (e: Event) => void>): () => void;
+    protected createConfig<T extends PluginConfig>(defaults: T): T;
+    get isInitialized(): boolean;
+    get isActive(): boolean;
+}
+export declare function createPlugin<T extends BasePlugin>(PluginClass: new (config?: PluginConfig) => T): (config?: PluginConfig) => T;
+export interface UIPluginConfig extends PluginConfig {
+    position?: 'top' | 'bottom' | 'left' | 'right' | 'center';
+    zIndex?: number;
+    className?: string;
+    style?: Record<string, string>;
+}
+export interface AnalyticsPluginConfig extends PluginConfig {
+    trackingId?: string;
+    events?: string[];
+    samplingRate?: number;
+    debug?: boolean;
+}
+export interface PerformancePluginConfig extends PluginConfig {
+    enableMetrics?: boolean;
+    reportInterval?: number;
+    thresholds?: Record<string, number>;
+}
+//# sourceMappingURL=base-plugin.d.ts.map

package/dist/src/core/plugins/base-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-plugin.d.ts","sourceRoot":"","sources":["base-plugin.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,151 @@
+// 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);
+}