@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

package/dist/src/core/optimization/bundle-optimizer.tsx

@@ -0,0 +1,308 @@
+"use client"
+
+import React, { Suspense, lazy, useMemo } from "react"
+import { MediaLoading } from "../../components/media-suspense"
+
+// Lazy loaded components for bundle splitting
+const LazyAdvancedControls = lazy(() =>
+	import("../../components/advanced-controls").then(module => ({
+		default: module.AdvancedControls
+	}))
+)
+
+const LazyPlaylist = lazy(() =>
+	import("../../features/playlist/Playlist").then(module => ({
+		default: module.Playlist
+	}))
+)
+
+const LazySubtitles = lazy(() =>
+	import("../../features/subtitles/SubtitleDisplay").then(module => ({
+		default: module.SubtitleDisplay
+	}))
+)
+
+const LazyAnalytics = lazy(() =>
+	import("../../core/plugins/examples/analytics-plugin").then(module => ({
+		default: module.AnalyticsPlugin
+	}))
+)
+
+// Component types for dynamic loading
+export interface LazyComponentConfig {
+	component: string
+	fallback?: React.ReactNode
+	preload?: boolean
+	priority?: "high" | "normal" | "low"
+}
+
+// Bundle optimization component
+export function BundleOptimizer({
+	children,
+	lazyComponents = [],
+	preloadStrategy = "viewport"
+}: {
+	children: React.ReactNode
+	lazyComponents?: LazyComponentConfig[]
+	preloadStrategy?: "viewport" | "hover" | "immediate" | "never"
+}) {
+	// Memoize component mapping for performance
+	const componentMap = useMemo(() => ({
+		'advanced-controls': LazyAdvancedControls,
+		'playlist': LazyPlaylist,
+		'subtitles': LazySubtitles,
+		'analytics': LazyAnalytics
+	}), [])
+
+	// Preload components based on strategy
+	React.useEffect(() => {
+		if (preloadStrategy === "immediate") {
+			// Preload all components immediately
+			lazyComponents.forEach(({ component }) => {
+				const Component = componentMap[component as keyof typeof componentMap]
+				if (Component) {
+					// Trigger dynamic import
+					Component.preload?.()
+				}
+			})
+		} else if (preloadStrategy === "viewport") {
+			// Preload when component is likely to enter viewport
+			const observer = new IntersectionObserver(
+				(entries) => {
+					entries.forEach((entry) => {
+						if (entry.isIntersecting) {
+							const componentName = entry.target.getAttribute('data-component')
+							if (componentName) {
+								const Component = componentMap[componentName as keyof typeof componentMap]
+								if (Component) {
+									Component.preload?.()
+								}
+							}
+							observer.unobserve(entry.target)
+						}
+					})
+				},
+				{ threshold: 0.1, rootMargin: '50px' }
+			)
+
+			// Observe lazy component containers
+			lazyComponents.forEach(({ component, priority }) => {
+				if (priority === "high") {
+					const element = document.querySelector(`[data-component="${component}"]`)
+					if (element) {
+						observer.observe(element)
+					}
+				}
+			})
+
+			return () => observer.disconnect()
+		}
+	}, [preloadStrategy, lazyComponents, componentMap])
+
+	// Render lazy components with suspense boundaries
+	const renderLazyComponent = (config: LazyComponentConfig) => {
+		const Component = componentMap[config.component as keyof typeof componentMap]
+		if (!Component) return null
+
+		const LazyComponent = Component as React.ComponentType<any>
+
+		return (
+			<Suspense
+				key={config.component}
+				fallback={config.fallback || <MediaLoading size="sm" />}>
+				<div
+					data-component={config.component}
+					data-priority={config.priority}>
+					<LazyComponent />
+				</div>
+			</Suspense>
+		)
+	}
+
+	return (
+		<>
+			{children}
+			{lazyComponents.map(renderLazyComponent)}
+		</>
+	)
+}
+
+// Progressive loading hook
+export function useProgressiveLoading() {
+	const [loadedComponents, setLoadedComponents] = React.useState<Set<string>>(new Set())
+
+	const loadComponent = React.useCallback(async (componentName: string) => {
+		if (loadedComponents.has(componentName)) return
+
+		try {
+			// Dynamic import based on component name
+			const imports: Record<string, () => Promise<any>> = {
+				'advanced-controls': () => import("../../components/advanced-controls"),
+				'playlist': () => import("../../features/playlist/Playlist"),
+				'subtitles': () => import("../../features/subtitles/SubtitleDisplay"),
+				'analytics': () => import("../../core/plugins/examples/analytics-plugin")
+			}
+
+			const importFn = imports[componentName]
+			if (importFn) {
+				await importFn()
+				setLoadedComponents(prev => new Set([...prev, componentName]))
+			}
+		} catch (error) {
+			console.warn(`Failed to load component ${componentName}:`, error)
+		}
+	}, [loadedComponents])
+
+	const preloadComponents = React.useCallback((componentNames: string[]) => {
+		componentNames.forEach(loadComponent)
+	}, [loadComponent])
+
+	return {
+		loadedComponents,
+		loadComponent,
+		preloadComponents,
+		isComponentLoaded: (componentName: string) => loadedComponents.has(componentName)
+	}
+}
+
+// Tree shaking utilities
+export function createLazyComponent<T extends React.ComponentType<any>>(
+	importFn: () => Promise<{ default: T }>,
+	componentName: string
+) {
+	const LazyComponent = React.lazy(importFn)
+
+	// Add preload method for manual preloading
+	(LazyComponent as any).preload = importFn
+
+	// Add display name for debugging
+	LazyComponent.displayName = `Lazy${componentName}`
+
+	return LazyComponent
+}
+
+// Bundle analyzer utilities
+export interface BundleMetrics {
+	totalSize: number
+	chunkSizes: Record<string, number>
+	loadedChunks: Set<string>
+	pendingChunks: Set<string>
+	compressionRatio: number
+}
+
+export function useBundleMetrics() {
+	const [metrics, setMetrics] = React.useState<BundleMetrics>({
+		totalSize: 0,
+		chunkSizes: {},
+		loadedChunks: new Set(),
+		pendingChunks: new Set(),
+		compressionRatio: 1
+	})
+
+	React.useEffect(() => {
+		// Monitor bundle loading if performance observer is available
+		if (typeof window !== 'undefined' && 'PerformanceObserver' in window) {
+			const observer = new PerformanceObserver((list) => {
+				for (const entry of list.getEntries()) {
+					if (entry.entryType === 'resource' && entry.name.includes('.js')) {
+						const chunkName = entry.name.split('/').pop() || 'unknown'
+
+						setMetrics(prev => ({
+							...prev,
+							chunkSizes: {
+								...prev.chunkSizes,
+								[chunkName]: entry.transferSize || 0
+							},
+							loadedChunks: new Set([...prev.loadedChunks, chunkName]),
+							totalSize: prev.totalSize + (entry.transferSize || 0)
+						}))
+					}
+				}
+			})
+
+			observer.observe({ entryTypes: ['resource'] })
+
+			return () => observer.disconnect()
+		}
+	}, [])
+
+	const getLargestChunk = React.useCallback(() => {
+		const entries = Object.entries(metrics.chunkSizes)
+		if (entries.length === 0) return null
+
+		return entries.reduce((a, b) => a[1] > b[1] ? a : b)
+	}, [metrics.chunkSizes])
+
+	const formatBytes = React.useCallback((bytes: number) => {
+		if (bytes === 0) return '0 Bytes'
+		const k = 1024
+		const sizes = ['Bytes', 'KB', 'MB', 'GB']
+		const i = Math.floor(Math.log(bytes) / Math.log(k))
+		return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
+	}, [])
+
+	return {
+		...metrics,
+		largestChunk: getLargestChunk(),
+		formatBytes,
+		totalSizeFormatted: formatBytes(metrics.totalSize)
+	}
+}
+
+// Preloading strategies
+export const PreloadStrategies = {
+	// Preload when user hovers over trigger element
+	onHover: (element: HTMLElement, importFn: () => Promise<any>) => {
+		let timeoutId: NodeJS.Timeout
+
+		const handleMouseEnter = () => {
+			timeoutId = setTimeout(importFn, 200) // 200ms delay
+		}
+
+		const handleMouseLeave = () => {
+			if (timeoutId) {
+				clearTimeout(timeoutId)
+			}
+		}
+
+		element.addEventListener('mouseenter', handleMouseEnter)
+		element.addEventListener('mouseleave', handleMouseLeave)
+
+		return () => {
+			element.removeEventListener('mouseenter', handleMouseEnter)
+			element.removeEventListener('mouseleave', handleMouseLeave)
+			if (timeoutId) {
+				clearTimeout(timeoutId)
+			}
+		}
+	},
+
+	// Preload when component enters viewport
+	onViewport: (element: HTMLElement, importFn: () => Promise<any>) => {
+		const observer = new IntersectionObserver(
+			(entries) => {
+				entries.forEach((entry) => {
+					if (entry.isIntersecting) {
+						importFn()
+						observer.unobserve(entry.target)
+					}
+				})
+			},
+			{ threshold: 0.1, rootMargin: '50px' }
+		)
+
+		observer.observe(element)
+		return () => observer.disconnect()
+	},
+
+	// Preload after idle time
+	onIdle: (importFn: () => Promise<any>, delay = 1000) => {
+		if ('requestIdleCallback' in window) {
+			return (window as any).requestIdleCallback(() => {
+				setTimeout(importFn, delay)
+			})
+		} else {
+			return setTimeout(importFn, delay)
+		}
+	}
+}

package/dist/src/core/performance/cicd.d.ts

@@ -0,0 +1,8 @@
+export declare const cicdIntegration: {
+    isCI(): boolean;
+    enforcebudgets(distPath: string): Promise<void>;
+    generateCIReport(): string;
+    formatValue(value: number, unit: "bytes" | "ms" | "score" | "percent"): string;
+    formatBytes(bytes: number): string;
+};
+//# sourceMappingURL=cicd.d.ts.map

package/dist/src/core/performance/cicd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cicd.d.ts","sourceRoot":"","sources":["cicd.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;YAElB,OAAO;6BAYgB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;wBAmBjC,MAAM;uBAmCP,MAAM,QAAQ,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM;uBAe3D,MAAM,GAAG,MAAM;CASnC,CAAC"}

package/dist/src/core/performance/cicd.js

@@ -0,0 +1,83 @@
+// CI/CD integration utilities - Node.js only
+import { performanceBudgetMonitor } from './performance-budgets';
+export const cicdIntegration = {
+    // Check if running in CI environment
+    isCI() {
+        return !!(process.env.CI ||
+            process.env.CONTINUOUS_INTEGRATION ||
+            process.env.BUILD_NUMBER ||
+            process.env.GITHUB_ACTIONS ||
+            process.env.GITLAB_CI ||
+            process.env.CIRCLE_CI);
+    },
+    // Exit with error code if budget violations found
+    async enforcebudgets(distPath) {
+        const violations = await performanceBudgetMonitor.checkBundleSizes(distPath);
+        const errorViolations = violations.filter(v => v.budget.severity === 'error');
+        if (errorViolations.length > 0) {
+            console.error(`❌ Performance budget violations detected: ${errorViolations.length} errors`);
+            errorViolations.forEach(violation => {
+                console.error(`  - ${violation.budget.name}: ${this.formatValue(violation.actualValue, violation.budget.unit)} (limit: ${this.formatValue(violation.budget.limit, violation.budget.unit)})`);
+            });
+            if (this.isCI()) {
+                process.exit(1);
+            }
+        }
+        else {
+            console.log('✅ All performance budgets passed');
+        }
+    },
+    // Generate budget report for CI
+    generateCIReport() {
+        const summary = performanceBudgetMonitor.getViolationSummary();
+        const violations = performanceBudgetMonitor.getViolations();
+        let report = '## Performance Budget Report\n\n';
+        if (summary.total === 0) {
+            report += '✅ **All performance budgets passed!**\n\n';
+        }
+        else {
+            report += `❌ **${summary.total} budget violations detected**\n\n`;
+            report += '### Violations by Category\n';
+            Object.entries(summary.byCategory).forEach(([category, count]) => {
+                report += `- ${category}: ${count}\n`;
+            });
+            report += '\n### Violations by Severity\n';
+            Object.entries(summary.bySeverity).forEach(([severity, count]) => {
+                const emoji = severity === 'error' ? '🔴' : severity === 'warning' ? '🟡' : '🔵';
+                report += `- ${emoji} ${severity}: ${count}\n`;
+            });
+            report += '\n### Detailed Violations\n';
+            violations.forEach(violation => {
+                const emoji = violation.budget.severity === 'error' ? '🔴' : '🟡';
+                report += `${emoji} **${violation.budget.name}**\n`;
+                report += `- Limit: ${this.formatValue(violation.budget.limit, violation.budget.unit)}\n`;
+                report += `- Actual: ${this.formatValue(violation.actualValue, violation.budget.unit)}\n`;
+                report += `- Overage: +${violation.overagePercentage.toFixed(1)}%\n\n`;
+            });
+        }
+        return report;
+    },
+    formatValue(value, unit) {
+        switch (unit) {
+            case 'bytes':
+                return this.formatBytes(value);
+            case 'ms':
+                return `${value.toFixed(2)}ms`;
+            case 'score':
+                return value.toFixed(3);
+            case 'percent':
+                return `${value.toFixed(1)}%`;
+            default:
+                return value.toString();
+        }
+    },
+    formatBytes(bytes) {
+        if (bytes >= 1024 * 1024) {
+            return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
+        }
+        if (bytes >= 1024) {
+            return `${(bytes / 1024).toFixed(2)}KB`;
+        }
+        return `${bytes}B`;
+    }
+};

package/dist/src/core/performance/cicd.ts

@@ -0,0 +1,96 @@
+// CI/CD integration utilities - Node.js only
+import { performanceBudgetMonitor, type BudgetViolation } from './performance-budgets';
+
+export const cicdIntegration = {
+  // Check if running in CI environment
+  isCI(): boolean {
+    return !!(
+      process.env.CI ||
+      process.env.CONTINUOUS_INTEGRATION ||
+      process.env.BUILD_NUMBER ||
+      process.env.GITHUB_ACTIONS ||
+      process.env.GITLAB_CI ||
+      process.env.CIRCLE_CI
+    );
+  },
+
+  // Exit with error code if budget violations found
+  async enforcebudgets(distPath: string): Promise<void> {
+    const violations = await performanceBudgetMonitor.checkBundleSizes(distPath);
+    const errorViolations = violations.filter(v => v.budget.severity === 'error');
+    
+    if (errorViolations.length > 0) {
+      console.error(`❌ Performance budget violations detected: ${errorViolations.length} errors`);
+      errorViolations.forEach(violation => {
+        console.error(`  - ${violation.budget.name}: ${this.formatValue(violation.actualValue, violation.budget.unit)} (limit: ${this.formatValue(violation.budget.limit, violation.budget.unit)})`);
+      });
+      
+      if (this.isCI()) {
+        process.exit(1);
+      }
+    } else {
+      console.log('✅ All performance budgets passed');
+    }
+  },
+
+  // Generate budget report for CI
+  generateCIReport(): string {
+    const summary = performanceBudgetMonitor.getViolationSummary();
+    const violations = performanceBudgetMonitor.getViolations();
+    
+    let report = '## Performance Budget Report\n\n';
+    
+    if (summary.total === 0) {
+      report += '✅ **All performance budgets passed!**\n\n';
+    } else {
+      report += `❌ **${summary.total} budget violations detected**\n\n`;
+      
+      report += '### Violations by Category\n';
+      Object.entries(summary.byCategory).forEach(([category, count]) => {
+        report += `- ${category}: ${count}\n`;
+      });
+      
+      report += '\n### Violations by Severity\n';
+      Object.entries(summary.bySeverity).forEach(([severity, count]) => {
+        const emoji = severity === 'error' ? '🔴' : severity === 'warning' ? '🟡' : '🔵';
+        report += `- ${emoji} ${severity}: ${count}\n`;
+      });
+      
+      report += '\n### Detailed Violations\n';
+      violations.forEach(violation => {
+        const emoji = violation.budget.severity === 'error' ? '🔴' : '🟡';
+        report += `${emoji} **${violation.budget.name}**\n`;
+        report += `- Limit: ${this.formatValue(violation.budget.limit, violation.budget.unit)}\n`;
+        report += `- Actual: ${this.formatValue(violation.actualValue, violation.budget.unit)}\n`;
+        report += `- Overage: +${violation.overagePercentage.toFixed(1)}%\n\n`;
+      });
+    }
+    
+    return report;
+  },
+
+  formatValue(value: number, unit: 'bytes' | 'ms' | 'score' | 'percent'): string {
+    switch (unit) {
+      case 'bytes':
+        return this.formatBytes(value);
+      case 'ms':
+        return `${value.toFixed(2)}ms`;
+      case 'score':
+        return value.toFixed(3);
+      case 'percent':
+        return `${value.toFixed(1)}%`;
+      default:
+        return value.toString();
+    }
+  },
+
+  formatBytes(bytes: number): string {
+    if (bytes >= 1024 * 1024) {
+      return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
+    }
+    if (bytes >= 1024) {
+      return `${(bytes / 1024).toFixed(2)}KB`;
+    }
+    return `${bytes}B`;
+  }
+};

package/dist/src/core/performance/index.d.ts

@@ -0,0 +1,10 @@
+export * from './performance-monitor';
+export { default as PerformanceMonitor } from './performance-monitor';
+export * from './performance-testing';
+export * from './performance-budgets';
+export * from './media-loading-optimizer';
+export { performanceMonitor, PerformanceDashboard, usePerformanceMonitor, withPerformanceMonitoring } from './performance-monitor';
+export { performanceBenchmark, performanceTestUtils, performanceTestFramework } from './performance-testing';
+export { performanceBudgetMonitor, defaultPerformanceBudgets } from './performance-budgets';
+export { mediaLoadingOptimizer, useMediaLoadingOptimizer, NetworkMonitor, MediaLoadingOptimizer } from './media-loading-optimizer';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/core/performance/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AACA,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,cAAc,uBAAuB,CAAC;AAGtC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,2BAA2B,CAAC;AAG1C,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EAC1B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACzB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,cAAc,EACd,qBAAqB,EACtB,MAAM,2BAA2B,CAAC"}

package/dist/src/core/performance/index.js

@@ -0,0 +1,14 @@
+// Performance Monitoring
+export * from './performance-monitor';
+export { default as PerformanceMonitor } from './performance-monitor';
+// Performance Testing
+export * from './performance-testing';
+// Performance Budgets and CI/CD
+export * from './performance-budgets';
+// Media Loading Optimization
+export * from './media-loading-optimizer';
+// Re-export key classes and utilities for convenience
+export { performanceMonitor, PerformanceDashboard, usePerformanceMonitor, withPerformanceMonitoring } from './performance-monitor';
+export { performanceBenchmark, performanceTestUtils, performanceTestFramework } from './performance-testing';
+export { performanceBudgetMonitor, defaultPerformanceBudgets } from './performance-budgets';
+export { mediaLoadingOptimizer, useMediaLoadingOptimizer, NetworkMonitor, MediaLoadingOptimizer } from './media-loading-optimizer';

package/dist/src/core/performance/index.ts

@@ -0,0 +1,38 @@
+// Performance Monitoring
+export * from './performance-monitor';
+export { default as PerformanceMonitor } from './performance-monitor';
+
+// Performance Testing
+export * from './performance-testing';
+
+// Performance Budgets and CI/CD
+export * from './performance-budgets';
+
+// Media Loading Optimization
+export * from './media-loading-optimizer';
+
+// Re-export key classes and utilities for convenience
+export {
+  performanceMonitor,
+  PerformanceDashboard,
+  usePerformanceMonitor,
+  withPerformanceMonitoring
+} from './performance-monitor';
+
+export {
+  performanceBenchmark,
+  performanceTestUtils,
+  performanceTestFramework
+} from './performance-testing';
+
+export {
+  performanceBudgetMonitor,
+  defaultPerformanceBudgets
+} from './performance-budgets';
+
+export {
+  mediaLoadingOptimizer,
+  useMediaLoadingOptimizer,
+  NetworkMonitor,
+  MediaLoadingOptimizer
+} from './media-loading-optimizer';

package/dist/src/core/performance/media-loading-optimizer.d.ts

@@ -0,0 +1,105 @@
+export interface NetworkInfo {
+    effectiveType: '2g' | '3g' | '4g' | '5g' | 'unknown';
+    downlink: number;
+    rtt: number;
+    saveData: boolean;
+    isOnline: boolean;
+}
+export interface MediaLoadingConfig {
+    preloadStrategy: 'none' | 'metadata' | 'auto';
+    adaptiveBitrate: boolean;
+    maxPreloadSize: number;
+    networkThresholds: {
+        '2g': {
+            maxBitrate: number;
+            preload: boolean;
+        };
+        '3g': {
+            maxBitrate: number;
+            preload: boolean;
+        };
+        '4g': {
+            maxBitrate: number;
+            preload: boolean;
+        };
+        '5g': {
+            maxBitrate: number;
+            preload: boolean;
+        };
+    };
+    bufferSize: number;
+    enableServiceWorker: boolean;
+}
+export declare const defaultMediaLoadingConfig: MediaLoadingConfig;
+export interface MediaLoadingMetrics {
+    loadStartTime: number;
+    firstByteTime?: number;
+    loadCompleteTime?: number;
+    totalLoadTime?: number;
+    bytesLoaded: number;
+    loadSpeed: number;
+    networkType: string;
+    quality: string;
+    bufferHealth: number;
+    stallsCount: number;
+    stallsDuration: number;
+}
+export declare class NetworkMonitor {
+    private connection;
+    private listeners;
+    private currentInfo;
+    constructor();
+    private getNetworkInfo;
+    private initializeListeners;
+    private handleNetworkChange;
+    getCurrentNetworkInfo(): NetworkInfo;
+    subscribe(listener: (info: NetworkInfo) => void): () => void;
+    estimateBandwidth(): Promise<number>;
+}
+export declare class MediaLoadingOptimizer {
+    private config;
+    private networkMonitor;
+    private loadingMetrics;
+    private preloadCache;
+    constructor(config?: Partial<MediaLoadingConfig>);
+    private initializeNetworkMonitoring;
+    private handleNetworkChange;
+    optimizeMediaLoading(mediaUrl: string, element: HTMLMediaElement, options?: {
+        quality?: string;
+        preload?: boolean;
+        priority?: 'high' | 'normal' | 'low';
+    }): Promise<MediaLoadingMetrics>;
+    private chooseLoadingStrategy;
+    private getPreloadAttribute;
+    private getSuggestedQuality;
+    private getBufferTarget;
+    preloadMedia(url: string, maxSize: number): Promise<void>;
+    private fetchWithProgress;
+    private monitorLoadingProgress;
+    private applyQualitySettings;
+    private adjustQualityForNetwork;
+    clearPreloadCache(): void;
+    getLoadingMetrics(url: string): MediaLoadingMetrics | undefined;
+    getAllMetrics(): MediaLoadingMetrics[];
+    getAverageLoadingTime(): number;
+    getNetworkPerformanceStats(): {
+        networkType: string;
+        avgLoadTime: number;
+        avgStalls: number;
+        avgBufferHealth: number;
+    }[];
+}
+export declare const mediaLoadingOptimizer: MediaLoadingOptimizer;
+export declare function useMediaLoadingOptimizer(config?: Partial<MediaLoadingConfig>): {
+    networkInfo: NetworkInfo | null;
+    loadingMetrics: MediaLoadingMetrics[];
+    optimizeLoading: (mediaUrl: string, element: HTMLMediaElement, options?: any) => Promise<MediaLoadingMetrics>;
+    averageLoadTime: number;
+    networkStats: {
+        networkType: string;
+        avgLoadTime: number;
+        avgStalls: number;
+        avgBufferHealth: number;
+    }[];
+};
+//# sourceMappingURL=media-loading-optimizer.d.ts.map

package/dist/src/core/performance/media-loading-optimizer.d.ts.map

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