@therealtinhtute/baroiplayer 1.0.5 → 1.0.7

package/dist/src/core/events/hooks.js

@@ -1,198 +0,0 @@
-import { useEffect, useRef, useCallback, useMemo, useState } from 'react';
-import { EventBus } from './event-system';
-// Hook to use event bus with React
-export function useEventBus(eventBus) {
-    const eventBusRef = useRef(null);
-    if (!eventBusRef.current) {
-        eventBusRef.current = eventBus || new EventBus();
-    }
-    useEffect(() => {
-        const currentEventBus = eventBusRef.current;
-        return () => {
-            // Cleanup on unmount
-            currentEventBus.destroy();
-        };
-    }, []);
-    return eventBusRef.current;
-}
-// Hook to listen to events
-export function useEventListener(eventBus, type, handler, options, deps) {
-    const handlerRef = useRef(handler);
-    const optionsRef = useRef(options);
-    // Update refs when dependencies change
-    useEffect(() => {
-        handlerRef.current = handler;
-        optionsRef.current = options;
-    });
-    useEffect(() => {
-        const unsubscribe = eventBus.on(type, handlerRef.current, optionsRef.current);
-        return unsubscribe;
-    }, [eventBus, type, ...(deps || [])]);
-}
-// Hook to emit events
-export function useEventEmitter(eventBus) {
-    return useCallback((type, detail, options) => {
-        return eventBus.emit(type, detail, options);
-    }, [eventBus]);
-}
-// Hook for one-time event listeners
-export function useEventOnce(eventBus, type, handler, deps) {
-    useEventListener(eventBus, type, handler, { once: true }, deps);
-}
-// Hook to create event handlers with automatic cleanup
-export function useEventHandlers(eventBus) {
-    const handlersRef = useRef([]);
-    const addHandler = useCallback((type, handler, options) => {
-        const unsubscribe = eventBus.on(type, handler, options);
-        handlersRef.current.push(unsubscribe);
-        return unsubscribe;
-    }, [eventBus]);
-    const removeAllHandlers = useCallback(() => {
-        handlersRef.current.forEach(unsubscribe => unsubscribe());
-        handlersRef.current = [];
-    }, []);
-    useEffect(() => {
-        return removeAllHandlers;
-    }, [removeAllHandlers]);
-    return {
-        on: addHandler,
-        removeAll: removeAllHandlers
-    };
-}
-// Hook for event history
-export function useEventHistory(eventBus, filter, maxSize = 100) {
-    const historyRef = useRef([]);
-    useEffect(() => {
-        const unsubscribe = eventBus.addEventListener('*', (event) => {
-            if (!filter || filter(event)) {
-                historyRef.current.push(event);
-                // Limit history size
-                if (historyRef.current.length > maxSize) {
-                    historyRef.current.shift();
-                }
-            }
-        });
-        return unsubscribe;
-    }, [eventBus, filter, maxSize]);
-    const clearHistory = useCallback(() => {
-        historyRef.current = [];
-    }, []);
-    return {
-        history: historyRef.current,
-        clearHistory
-    };
-}
-// Hook for event metrics/analytics
-export function useEventMetrics(eventBus) {
-    const metricsRef = useRef(new Map());
-    useEffect(() => {
-        const updateMetrics = (event) => {
-            const existing = metricsRef.current.get(event.type) || {
-                count: 0,
-                lastTimestamp: 0,
-                frequency: 0
-            };
-            existing.count++;
-            if (existing.lastTimestamp > 0) {
-                const timeDiff = (event.timestamp - existing.lastTimestamp) / 1000; // seconds
-                existing.frequency = timeDiff > 0 ? 1 / timeDiff : 0;
-            }
-            existing.lastTimestamp = event.timestamp;
-            metricsRef.current.set(event.type, existing);
-        };
-        const unsubscribe = eventBus.addEventListener('*', updateMetrics);
-        return unsubscribe;
-    }, [eventBus]);
-    const getMetrics = useCallback(() => {
-        return Object.fromEntries(metricsRef.current.entries());
-    }, []);
-    const resetMetrics = useCallback(() => {
-        metricsRef.current.clear();
-    }, []);
-    return {
-        getMetrics,
-        resetMetrics
-    };
-}
-// Hook for event debugging
-export function useEventDebugger(eventBus, options = {}) {
-    const { logEvents = true, logMetrics = false, filterEventTypes } = options;
-    useEffect(() => {
-        if (!logEvents)
-            return;
-        const unsubscribe = eventBus.addEventListener('*', (event) => {
-            if (filterEventTypes && !filterEventTypes.includes(event.type)) {
-                return;
-            }
-            console.group(`🎯 Event: ${event.type}`);
-            console.log('Timestamp:', new Date(event.timestamp).toISOString());
-            console.log('Detail:', event.detail);
-            console.log('Bubbles:', event.bubbles);
-            console.log('Cancelable:', event.cancelable);
-            console.groupEnd();
-        });
-        return unsubscribe;
-    }, [eventBus, logEvents, filterEventTypes]);
-    useEffect(() => {
-        if (!logMetrics)
-            return;
-        const interval = setInterval(() => {
-            const listenerCount = eventBus.getListenerCount();
-            const eventTypes = eventBus.getEventTypes();
-            console.group('📊 Event Metrics');
-            console.log('Total Listeners:', listenerCount);
-            console.log('Event Types:', eventTypes.length);
-            console.log('Active Types:', eventTypes);
-            console.groupEnd();
-        }, 5000);
-        return () => clearInterval(interval);
-    }, [eventBus, logMetrics]);
-}
-// Hook for conditional event handling
-export function useConditionalEventListener(eventBus, type, handler, condition, options, deps) {
-    const shouldListen = useMemo(() => {
-        return typeof condition === 'function' ? condition() : condition;
-    }, [condition, ...(deps || [])]);
-    useEffect(() => {
-        if (!shouldListen)
-            return;
-        const unsubscribe = eventBus.on(type, handler, options);
-        return unsubscribe;
-    }, [eventBus, type, shouldListen, ...(deps || [])]);
-}
-// Hook for event state synchronization
-export function useEventState(eventBus, initialValue, eventMapping) {
-    const [state, setState] = useState(initialValue);
-    useEffect(() => {
-        const unsubscribers = [];
-        Object.entries(eventMapping).forEach(([eventType, updater]) => {
-            const unsubscribe = eventBus.addEventListener(eventType, (event) => {
-                setState(current => updater(event.detail, current));
-            });
-            unsubscribers.push(unsubscribe);
-        });
-        return () => {
-            unsubscribers.forEach(unsubscribe => unsubscribe());
-        };
-    }, [eventBus, eventMapping]);
-    return state;
-}
-// Hook for creating event-driven effects
-export function useEventEffect(eventBus, type, effect, deps) {
-    const cleanupRef = useRef(undefined);
-    useEventListener(eventBus, type, useCallback((event) => {
-        // Clean up previous effect
-        if (typeof cleanupRef.current === 'function') {
-            cleanupRef.current();
-        }
-        // Run new effect
-        cleanupRef.current = effect(event.detail);
-    }, deps || []), undefined, deps);
-    useEffect(() => {
-        return () => {
-            if (typeof cleanupRef.current === 'function') {
-                cleanupRef.current();
-            }
-        };
-    }, []);
-}

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EACR,cAAc,EACd,eAAe,EAChB,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,WAAW,EACZ,MAAM,gBAAgB,CAAA;AAGvB,cAAc,cAAc,CAAA;AAC5B,cAAc,SAAS,CAAA;AAGvB,eAAO,MAAM,oBAAoB,UAAU,CAAA"}

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

@@ -1,7 +0,0 @@
-// Event system exports
-export { EventBus, EventDelegator, defaultEventBus } from './event-system';
-// Event utilities
-export * from './middleware';
-export * from './hooks';
-// Version
-export const EVENT_SYSTEM_VERSION = '1.0.0';

package/dist/src/core/events/middleware.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAGtD,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,gBAAgB,KAAK,gBAAgB,GAAG,IAAI,CAAA;AAGlF,eAAO,MAAM,gBAAgB;iCAEG,eAAe;2BAQtB,MAAM,EAAE,qBAAgB,eAAe;2BAoBvC,MAAM,EAAE,qBAAgB,eAAe;wBAqC1C,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,KAAG,eAAe;6BAKjD,CAAC,KAAK,EAAE,gBAAgB,KAAK,gBAAgB,KAAG,eAAe;uBAUvE,eAAe;6BAuBP,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,gBAAgB,KAAK,IAAI,KAAG,eAAe;yBAuBtE;QAClB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;QAC5B,cAAc,CAAC,EAAE,OAAO,CAAA;QACxB,aAAa,CAAC,EAAE,MAAM,CAAA;KACvB,KAAQ,eAAe;sBA2BN,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,cAAc,eAAe,KAAG,eAAe;4BAK7E,eAAe,EAAE,KAAG,eAAe;CAU5D,CAAA;AAGD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAAwB;IAG3C,GAAG,CAAC,UAAU,EAAE,eAAe,GAAG,IAAI;IAMtC,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAK1B,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAKpD,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAKpD,MAAM,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,GAAG,IAAI;IAK7D,SAAS,CAAC,WAAW,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,gBAAgB,GAAG,IAAI;IAK3E,WAAW,IAAI,IAAI;IAKnB,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,gBAAgB,KAAK,IAAI,GAAG,IAAI;IAK7E,QAAQ,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAKzE,IAAI,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI;IAKxF,KAAK,IAAI,eAAe;CAGzB;AAGD,eAAO,MAAM,gBAAgB,yBAAgC,CAAA;AAG7D,eAAO,MAAM,iBAAiB;;;;CAqB7B,CAAA"}

package/dist/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/dist/src/core/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAGA,cAAc,WAAW,CAAA;AAGzB,cAAc,UAAU,CAAA;AAGxB,cAAc,8BAA8B,CAAA;AAG5C,eAAO,MAAM,yBAAyB,UAAU,CAAA;AAGhD,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAG5C,cAAc,uBAAuB,CAAA;AAGrC,cAAc,eAAe,CAAA"}

package/dist/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/dist/src/core/optimization/bundle-optimizer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle-optimizer.d.ts","sourceRoot":"","sources":["bundle-optimizer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAkC,MAAM,OAAO,CAAA;AA6BtD,MAAM,WAAW,mBAAmB;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAA;CACpC;AAGD,wBAAgB,eAAe,CAAC,EAC/B,QAAQ,EACR,cAAmB,EACnB,eAA4B,EAC5B,EAAE;IACF,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,cAAc,CAAC,EAAE,mBAAmB,EAAE,CAAA;IACtC,eAAe,CAAC,EAAE,UAAU,GAAG,OAAO,GAAG,WAAW,GAAG,OAAO,CAAA;CAC9D,2CAgFA;AAGD,wBAAgB,qBAAqB;;mCAG0B,MAAM;wCAsBP,MAAM,EAAE;uCAQjC,MAAM;EAE1C;AAGD,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,EACrE,QAAQ,EAAE,MAAM,OAAO,CAAC;IAAE,OAAO,EAAE,CAAC,CAAA;CAAE,CAAC,EACvC,aAAa,EAAE,MAAM,OAWrB;AAGD,MAAM,WAAW,aAAa;IAC7B,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACzB,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC1B,gBAAgB,EAAE,MAAM,CAAA;CACxB;AAED,wBAAgB,gBAAgB;;yBA2Ce,MAAM;;eAlDzC,MAAM;gBACL,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;kBACpB,GAAG,CAAC,MAAM,CAAC;mBACV,GAAG,CAAC,MAAM,CAAC;sBACR,MAAM;EA4DxB;AAGD,eAAO,MAAM,iBAAiB;uBAEV,WAAW,YAAY,MAAM,OAAO,CAAC,GAAG,CAAC;0BA0BtC,WAAW,YAAY,MAAM,OAAO,CAAC,GAAG,CAAC;uBAkB5C,MAAM,OAAO,CAAC,GAAG,CAAC;CASrC,CAAA"}

package/dist/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/dist/src/core/performance/cicd.d.ts.map

@@ -1 +0,0 @@
-{"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"}