@therealtinhtute/baroiplayer 1.0.6 → 1.0.8

package/src/core/events/middleware.js

@@ -1,219 +0,0 @@
-// Common middleware implementations
-export const eventMiddlewares = {
-    // Logging middleware
-    logger: (prefix = '[Event]') => (event) => {
-        if (process.env.NODE_ENV === 'development') {
-            console.log(`${prefix} ${event.type}`, event.detail);
-        }
-        return event;
-    },
-    // Throttling middleware
-    throttle: (eventTypes, delay = 100) => {
-        const lastTimes = new Map();
-        return (event) => {
-            if (eventTypes.includes(event.type)) {
-                const lastTime = lastTimes.get(event.type) || 0;
-                const now = event.timestamp;
-                if (now - lastTime < delay) {
-                    return null; // Throttle this event
-                }
-                lastTimes.set(event.type, now);
-            }
-            return event;
-        };
-    },
-    // Debouncing middleware
-    debounce: (eventTypes, delay = 100) => {
-        const timeouts = new Map();
-        const eventQueue = new Map();
-        return (event) => {
-            if (eventTypes.includes(event.type)) {
-                // Clear existing timeout
-                const existingTimeout = timeouts.get(event.type);
-                if (existingTimeout) {
-                    clearTimeout(existingTimeout);
-                }
-                // Store the latest event
-                eventQueue.set(event.type, event);
-                // Set new timeout
-                const timeout = setTimeout(() => {
-                    const queuedEvent = eventQueue.get(event.type);
-                    if (queuedEvent) {
-                        // Process the debounced event
-                        // Note: This is a simplified approach - in a real implementation,
-                        // you'd need to re-inject the event into the processing pipeline
-                        eventQueue.delete(event.type);
-                        timeouts.delete(event.type);
-                    }
-                }, delay);
-                timeouts.set(event.type, timeout);
-                return null; // Don't process immediately
-            }
-            return event;
-        };
-    },
-    // Filtering middleware
-    filter: (predicate) => (event) => {
-        return predicate(event) ? event : null;
-    },
-    // Event transformation middleware
-    transform: (transformer) => (event) => {
-        try {
-            return transformer(event);
-        }
-        catch (error) {
-            console.error('Error in event transformer:', error);
-            return event;
-        }
-    },
-    // Performance monitoring middleware
-    performance: () => {
-        const metrics = new Map();
-        return (event) => {
-            const startTime = performance.now();
-            // Update metrics
-            const existing = metrics.get(event.type) || { count: 0, totalTime: 0 };
-            existing.count++;
-            existing.totalTime += performance.now() - startTime;
-            metrics.set(event.type, existing);
-            // Log metrics periodically (every 100 events)
-            if (existing.count % 100 === 0) {
-                const avgTime = existing.totalTime / existing.count;
-                console.log(`Event ${event.type}: ${existing.count} calls, avg ${avgTime.toFixed(2)}ms`);
-            }
-            return event;
-        };
-    },
-    // Error handling middleware
-    errorHandler: (onError) => (event) => {
-        try {
-            // Validate event structure
-            if (!event.type || typeof event.type !== 'string') {
-                throw new Error('Invalid event: missing or invalid type');
-            }
-            if (!event.timestamp || typeof event.timestamp !== 'number') {
-                throw new Error('Invalid event: missing or invalid timestamp');
-            }
-            return event;
-        }
-        catch (error) {
-            if (onError) {
-                onError(error, event);
-            }
-            else {
-                console.error('Event validation error:', error);
-            }
-            return null;
-        }
-    },
-    // Security middleware (prevent certain events or sanitize data)
-    security: (options = {}) => (event) => {
-        const { blockedEventTypes = [], sanitizeDetail = true, maxDetailSize = 10000 } = options;
-        // Block certain event types
-        if (blockedEventTypes.includes(event.type)) {
-            console.warn(`Blocked event type: ${event.type}`);
-            return null;
-        }
-        // Sanitize detail if needed
-        if (sanitizeDetail && event.detail) {
-            try {
-                const detailStr = JSON.stringify(event.detail);
-                if (detailStr.length > maxDetailSize) {
-                    console.warn(`Event detail too large, truncating: ${event.type}`);
-                    event.detail = { ...event.detail, _truncated: true };
-                }
-            }
-            catch (error) {
-                console.warn(`Failed to serialize event detail: ${event.type}`);
-                event.detail = { _serializationError: true };
-            }
-        }
-        return event;
-    },
-    // Conditional middleware
-    when: (condition, middleware) => (event) => {
-        return condition(event) ? middleware(event) : event;
-    },
-    // Chain multiple middleware
-    chain: (...middlewares) => (event) => {
-        let currentEvent = event;
-        for (const middleware of middlewares) {
-            if (currentEvent === null)
-                break;
-            currentEvent = middleware(currentEvent);
-        }
-        return currentEvent;
-    }
-};
-// Middleware builder class
-export class MiddlewareBuilder {
-    middlewares = [];
-    // Add middleware
-    use(middleware) {
-        this.middlewares.push(middleware);
-        return this;
-    }
-    // Add logging
-    log(prefix) {
-        return this.use(eventMiddlewares.logger(prefix));
-    }
-    // Add throttling
-    throttle(eventTypes, delay) {
-        return this.use(eventMiddlewares.throttle(eventTypes, delay));
-    }
-    // Add debouncing
-    debounce(eventTypes, delay) {
-        return this.use(eventMiddlewares.debounce(eventTypes, delay));
-    }
-    // Add filtering
-    filter(predicate) {
-        return this.use(eventMiddlewares.filter(predicate));
-    }
-    // Add transformation
-    transform(transformer) {
-        return this.use(eventMiddlewares.transform(transformer));
-    }
-    // Add performance monitoring
-    performance() {
-        return this.use(eventMiddlewares.performance());
-    }
-    // Add error handling
-    errorHandler(onError) {
-        return this.use(eventMiddlewares.errorHandler(onError));
-    }
-    // Add security
-    security(options) {
-        return this.use(eventMiddlewares.security(options));
-    }
-    // Add conditional middleware
-    when(condition, middleware) {
-        return this.use(eventMiddlewares.when(condition, middleware));
-    }
-    // Build the final middleware
-    build() {
-        return eventMiddlewares.chain(...this.middlewares);
-    }
-}
-// Helper to create middleware builder
-export const createMiddleware = () => new MiddlewareBuilder();
-// Export commonly used middleware combinations
-export const commonMiddlewares = {
-    // Development middleware stack
-    development: () => createMiddleware()
-        .log('[Dev Event]')
-        .performance()
-        .errorHandler()
-        .build(),
-    // Production middleware stack
-    production: () => createMiddleware()
-        .security()
-        .errorHandler()
-        .throttle(['media:timeupdate', 'user:mousemove'], 16) // ~60fps
-        .build(),
-    // Testing middleware stack
-    testing: () => createMiddleware()
-        .errorHandler((error, event) => {
-        throw new Error(`Event error in test: ${error.message} for event ${event.type}`);
-    })
-        .build()
-};

package/src/core/index.js

@@ -1,15 +0,0 @@
-// Core architecture exports
-// Plugin system
-export * from './plugins';
-// Event system  
-export * from './events';
-// Service providers
-export * from './providers/service-provider';
-// Version
-export const CORE_ARCHITECTURE_VERSION = '1.0.0';
-// Architecture utilities
-export { createArchitecture } from './utils';
-// Progressive loading system
-export * from './progressive-loading';
-// Performance monitoring and testing
-export * from './performance';

package/src/core/optimization/bundle-optimizer.js

@@ -1,217 +0,0 @@
-"use client";
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-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
-})));
-// Bundle optimization component
-export function BundleOptimizer({ children, lazyComponents = [], preloadStrategy = "viewport" }) {
-    // 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];
-                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];
-                            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) => {
-        const Component = componentMap[config.component];
-        if (!Component)
-            return null;
-        const LazyComponent = Component;
-        return (_jsx(Suspense, { fallback: config.fallback || _jsx(MediaLoading, { size: "sm" }), children: _jsx("div", { "data-component": config.component, "data-priority": config.priority, children: _jsx(LazyComponent, {}) }) }, config.component));
-    };
-    return (_jsxs(_Fragment, { children: [children, lazyComponents.map(renderLazyComponent)] }));
-}
-// Progressive loading hook
-export function useProgressiveLoading() {
-    const [loadedComponents, setLoadedComponents] = React.useState(new Set());
-    const loadComponent = React.useCallback(async (componentName) => {
-        if (loadedComponents.has(componentName))
-            return;
-        try {
-            // Dynamic import based on component name
-            const imports = {
-                '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) => {
-        componentNames.forEach(loadComponent);
-    }, [loadComponent]);
-    return {
-        loadedComponents,
-        loadComponent,
-        preloadComponents,
-        isComponentLoaded: (componentName) => loadedComponents.has(componentName)
-    };
-}
-// Tree shaking utilities
-export function createLazyComponent(importFn, componentName) {
-    const LazyComponent = React.lazy(importFn)(LazyComponent).preload = importFn;
-    // Add display name for debugging
-    LazyComponent.displayName = `Lazy${componentName}`;
-    return LazyComponent;
-}
-export function useBundleMetrics() {
-    const [metrics, setMetrics] = React.useState({
-        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) => {
-        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, importFn) => {
-        let timeoutId;
-        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, importFn) => {
-        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, delay = 1000) => {
-        if ('requestIdleCallback' in window) {
-            return window.requestIdleCallback(() => {
-                setTimeout(importFn, delay);
-            });
-        }
-        else {
-            return setTimeout(importFn, delay);
-        }
-    }
-};

package/src/core/performance/cicd.js

@@ -1,83 +0,0 @@
-// 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/src/core/performance/index.js

@@ -1,14 +0,0 @@
-// 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';