@therealtinhtute/baroiplayer 1.0.8 → 1.1.0

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

@@ -1,459 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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