@therealtinhtute/baroiplayer 1.0.0 → 1.0.1

package/dist/src/context/error-handling.d.ts

@@ -0,0 +1,72 @@
+import type { MediaActionType } from "./media-context";
+import type { OptimisticMediaAction } from "./media-store";
+export declare enum MediaErrorType {
+    NETWORK_ERROR = "NETWORK_ERROR",
+    PLAYBACK_ERROR = "PLAYBACK_ERROR",
+    PERMISSION_ERROR = "PERMISSION_ERROR",
+    NOT_SUPPORTED_ERROR = "NOT_SUPPORTED_ERROR",
+    TIMEOUT_ERROR = "TIMEOUT_ERROR",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+export interface MediaError {
+    type: MediaErrorType;
+    message: string;
+    action?: OptimisticMediaAction;
+    timestamp: number;
+    retryable: boolean;
+    retryCount: number;
+    originalError?: Error;
+}
+export interface RetryConfig {
+    maxRetries: number;
+    baseDelay: number;
+    maxDelay: number;
+    exponentialBackoff: boolean;
+    retryableErrors: MediaErrorType[];
+    retryableActions: MediaActionType[];
+}
+export interface ErrorRecoveryStrategy {
+    canRecover(error: MediaError): boolean;
+    recover(error: MediaError): Promise<void>;
+}
+export declare class MediaErrorHandler {
+    private config;
+    private recoveryStrategies;
+    private errorQueue;
+    private listeners;
+    constructor(config?: Partial<RetryConfig>, recoveryStrategies?: ErrorRecoveryStrategy[]);
+    createMediaError(error: unknown, action?: OptimisticMediaAction, retryCount?: number): MediaError;
+    private categorizeError;
+    private isRetryable;
+    private calculateRetryDelay;
+    handleError(error: unknown, action?: OptimisticMediaAction, retryCallback?: (action: OptimisticMediaAction) => Promise<void>): Promise<MediaError>;
+    subscribe(listener: (error: MediaError) => void): () => void;
+    getErrors(): MediaError[];
+    clearError(errorId: string): void;
+    clearAllErrors(): void;
+    getErrorStats(): {
+        totalErrors: number;
+        errorsByType: Record<MediaErrorType, number>;
+        retryableErrors: number;
+        recentErrors: MediaError[];
+    };
+}
+export declare function useMediaErrorHandler(config?: Partial<RetryConfig>): {
+    handler: MediaErrorHandler;
+    errors: MediaError[];
+    clearError: (errorId: string) => void;
+    clearAllErrors: () => void;
+    errorStats: {
+        totalErrors: number;
+        errorsByType: Record<MediaErrorType, number>;
+        retryableErrors: number;
+        recentErrors: MediaError[];
+    };
+};
+export declare function useMediaErrorBoundary(): {
+    error: MediaError | null;
+    hasError: boolean;
+    resetError: () => void;
+    captureError: (error: unknown, action?: OptimisticMediaAction) => void;
+};
+//# sourceMappingURL=error-handling.d.ts.map

package/dist/src/context/error-handling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handling.d.ts","sourceRoot":"","sources":["error-handling.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAG1D,oBAAY,cAAc;IACzB,aAAa,kBAAkB;IAC/B,cAAc,mBAAmB;IACjC,gBAAgB,qBAAqB;IACrC,mBAAmB,wBAAwB;IAC3C,aAAa,kBAAkB;IAC/B,aAAa,kBAAkB;CAC/B;AAGD,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,cAAc,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,qBAAqB,CAAA;IAC9B,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,CAAC,EAAE,KAAK,CAAA;CACrB;AAGD,MAAM,WAAW,WAAW;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,kBAAkB,EAAE,OAAO,CAAA;IAC3B,eAAe,EAAE,cAAc,EAAE,CAAA;IACjC,gBAAgB,EAAE,eAAe,EAAE,CAAA;CACnC;AAuBD,MAAM,WAAW,qBAAqB;IACrC,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAA;IACtC,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACzC;AA8DD,qBAAa,iBAAiB;IAC7B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,kBAAkB,CAAyB;IACnD,OAAO,CAAC,UAAU,CAAqC;IACvD,OAAO,CAAC,SAAS,CAA8C;gBAG9D,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM,EACjC,kBAAkB,GAAE,qBAAqB,EAAO;IAYjD,gBAAgB,CACf,KAAK,EAAE,OAAO,EACd,MAAM,CAAC,EAAE,qBAAqB,EAC9B,UAAU,SAAI,GACZ,UAAU;IA2Bb,OAAO,CAAC,eAAe;IA4CvB,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,mBAAmB;IAUrB,WAAW,CAChB,KAAK,EAAE,OAAO,EACd,MAAM,CAAC,EAAE,qBAAqB,EAC9B,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,OAAO,CAAC,IAAI,CAAC,GAC9D,OAAO,CAAC,UAAU,CAAC;IAsDtB,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,MAAM,IAAI;IAM5D,SAAS,IAAI,UAAU,EAAE;IAKzB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAKjC,cAAc,IAAI,IAAI;IAKtB,aAAa,IAAI;QAChB,WAAW,EAAE,MAAM,CAAA;QACnB,YAAY,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC,CAAA;QAC5C,eAAe,EAAE,MAAM,CAAA;QACvB,YAAY,EAAE,UAAU,EAAE,CAAA;KAC1B;CAoBD;AAGD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC;;;0BAYlB,MAAM;;;qBAvCvC,MAAM;sBACL,MAAM,CAAC,cAAc,EAAE,MAAM,CAAC;yBAC3B,MAAM;sBACT,UAAU,EAAE;;EAqD3B;AAGD,wBAAgB,qBAAqB;;;;0BAOW,OAAO,WAAW,qBAAqB;EAYtF"}

package/dist/src/context/error-handling.js

@@ -0,0 +1,300 @@
+"use client";
+import React from "react";
+// Error types specific to media operations
+export var MediaErrorType;
+(function (MediaErrorType) {
+    MediaErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
+    MediaErrorType["PLAYBACK_ERROR"] = "PLAYBACK_ERROR";
+    MediaErrorType["PERMISSION_ERROR"] = "PERMISSION_ERROR";
+    MediaErrorType["NOT_SUPPORTED_ERROR"] = "NOT_SUPPORTED_ERROR";
+    MediaErrorType["TIMEOUT_ERROR"] = "TIMEOUT_ERROR";
+    MediaErrorType["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+})(MediaErrorType || (MediaErrorType = {}));
+// Default retry configuration
+const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 3,
+    baseDelay: 1000,
+    maxDelay: 10000,
+    exponentialBackoff: true,
+    retryableErrors: [
+        MediaErrorType.NETWORK_ERROR,
+        MediaErrorType.TIMEOUT_ERROR
+    ],
+    retryableActions: [
+        "PLAY",
+        "PAUSE",
+        "SEEK",
+        "SET_VOLUME",
+        "ENTER_FULLSCREEN",
+        "EXIT_FULLSCREEN"
+    ]
+};
+// Network error recovery
+class NetworkErrorRecovery {
+    canRecover(error) {
+        return error.type === MediaErrorType.NETWORK_ERROR && error.retryCount < 3;
+    }
+    async recover(error) {
+        // Wait for network to become available
+        if (navigator.onLine === false) {
+            await new Promise(resolve => {
+                const handleOnline = () => {
+                    window.removeEventListener('online', handleOnline);
+                    resolve(void 0);
+                };
+                window.addEventListener('online', handleOnline);
+            });
+        }
+        // Additional delay for network stability
+        await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+}
+// Playback error recovery
+class PlaybackErrorRecovery {
+    canRecover(error) {
+        return error.type === MediaErrorType.PLAYBACK_ERROR && error.retryCount < 2;
+    }
+    async recover(error) {
+        // Try to reload the media element
+        const mediaElement = document.querySelector('video, audio');
+        if (mediaElement) {
+            mediaElement.load();
+            await new Promise(resolve => {
+                const handleCanPlay = () => {
+                    mediaElement.removeEventListener('canplay', handleCanPlay);
+                    resolve(void 0);
+                };
+                mediaElement.addEventListener('canplay', handleCanPlay);
+            });
+        }
+    }
+}
+// Permission error recovery (for fullscreen, etc.)
+class PermissionErrorRecovery {
+    canRecover(error) {
+        return error.type === MediaErrorType.PERMISSION_ERROR &&
+            error.action?.type === 'ENTER_FULLSCREEN';
+    }
+    async recover(error) {
+        // Request user interaction for fullscreen
+        console.warn('Fullscreen requires user interaction');
+        // In a real implementation, you might show a message to the user
+    }
+}
+// Error handler class
+export class MediaErrorHandler {
+    config;
+    recoveryStrategies;
+    errorQueue = new Map();
+    listeners = new Set();
+    constructor(config = {}, recoveryStrategies = []) {
+        this.config = { ...DEFAULT_RETRY_CONFIG, ...config };
+        this.recoveryStrategies = [
+            new NetworkErrorRecovery(),
+            new PlaybackErrorRecovery(),
+            new PermissionErrorRecovery(),
+            ...recoveryStrategies
+        ];
+    }
+    // Create a media error from a generic error
+    createMediaError(error, action, retryCount = 0) {
+        const timestamp = Date.now();
+        if (error instanceof Error) {
+            const errorType = this.categorizeError(error, action);
+            return {
+                type: errorType,
+                message: error.message,
+                action,
+                timestamp,
+                retryable: this.isRetryable(errorType, action),
+                retryCount,
+                originalError: error
+            };
+        }
+        return {
+            type: MediaErrorType.UNKNOWN_ERROR,
+            message: typeof error === 'string' ? error : 'Unknown error occurred',
+            action,
+            timestamp,
+            retryable: this.isRetryable(MediaErrorType.UNKNOWN_ERROR, action),
+            retryCount
+        };
+    }
+    // Categorize errors based on error properties and action context
+    categorizeError(error, action) {
+        const message = error.message.toLowerCase();
+        // Network-related errors
+        if (message.includes('network') ||
+            message.includes('fetch') ||
+            message.includes('connection') ||
+            error.name === 'NetworkError') {
+            return MediaErrorType.NETWORK_ERROR;
+        }
+        // Permission errors
+        if (message.includes('permission') ||
+            message.includes('denied') ||
+            message.includes('fullscreen') ||
+            error.name === 'NotAllowedError') {
+            return MediaErrorType.PERMISSION_ERROR;
+        }
+        // Playback errors
+        if (message.includes('decode') ||
+            message.includes('format') ||
+            message.includes('codec') ||
+            action?.type === 'PLAY') {
+            return MediaErrorType.PLAYBACK_ERROR;
+        }
+        // Timeout errors
+        if (message.includes('timeout') ||
+            error.name === 'TimeoutError') {
+            return MediaErrorType.TIMEOUT_ERROR;
+        }
+        // Not supported errors
+        if (message.includes('not supported') ||
+            message.includes('unsupported') ||
+            error.name === 'NotSupportedError') {
+            return MediaErrorType.NOT_SUPPORTED_ERROR;
+        }
+        return MediaErrorType.UNKNOWN_ERROR;
+    }
+    // Check if an error/action combination is retryable
+    isRetryable(errorType, action) {
+        const errorRetryable = this.config.retryableErrors.includes(errorType);
+        const actionRetryable = !action || this.config.retryableActions.includes(action.type);
+        return errorRetryable && actionRetryable;
+    }
+    // Calculate retry delay with exponential backoff
+    calculateRetryDelay(retryCount) {
+        if (!this.config.exponentialBackoff) {
+            return this.config.baseDelay;
+        }
+        const delay = this.config.baseDelay * Math.pow(2, retryCount);
+        return Math.min(delay, this.config.maxDelay);
+    }
+    // Handle an error with automatic retry logic
+    async handleError(error, action, retryCallback) {
+        const mediaError = this.createMediaError(error, action, action?.retryCount || 0);
+        const errorId = `${action?.type}-${mediaError.timestamp}`;
+        // Store error for tracking
+        this.errorQueue.set(errorId, mediaError);
+        // Notify listeners
+        this.listeners.forEach(listener => listener(mediaError));
+        // Try recovery strategies
+        for (const strategy of this.recoveryStrategies) {
+            if (strategy.canRecover(mediaError)) {
+                try {
+                    await strategy.recover(mediaError);
+                    break;
+                }
+                catch (recoveryError) {
+                    console.warn('Recovery strategy failed:', recoveryError);
+                }
+            }
+        }
+        // Retry if possible
+        if (mediaError.retryable &&
+            mediaError.retryCount < this.config.maxRetries &&
+            retryCallback &&
+            action) {
+            const delay = this.calculateRetryDelay(mediaError.retryCount);
+            console.log(`Retrying action ${action.type} in ${delay}ms (attempt ${mediaError.retryCount + 1}/${this.config.maxRetries})`);
+            setTimeout(async () => {
+                try {
+                    await retryCallback({
+                        ...action,
+                        retryCount: mediaError.retryCount + 1
+                    });
+                    // Remove from error queue on successful retry
+                    this.errorQueue.delete(errorId);
+                }
+                catch (retryError) {
+                    // Handle retry failure
+                    await this.handleError(retryError, {
+                        ...action,
+                        retryCount: mediaError.retryCount + 1
+                    }, retryCallback);
+                }
+            }, delay);
+        }
+        return mediaError;
+    }
+    // Subscribe to error events
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    // Get current errors
+    getErrors() {
+        return Array.from(this.errorQueue.values());
+    }
+    // Clear specific error
+    clearError(errorId) {
+        this.errorQueue.delete(errorId);
+    }
+    // Clear all errors
+    clearAllErrors() {
+        this.errorQueue.clear();
+    }
+    // Get error statistics
+    getErrorStats() {
+        const errors = this.getErrors();
+        const now = Date.now();
+        const recentThreshold = 5 * 60 * 1000; // 5 minutes
+        const errorsByType = errors.reduce((acc, error) => {
+            acc[error.type] = (acc[error.type] || 0) + 1;
+            return acc;
+        }, {});
+        const retryableErrors = errors.filter(e => e.retryable).length;
+        const recentErrors = errors.filter(e => now - e.timestamp < recentThreshold);
+        return {
+            totalErrors: errors.length,
+            errorsByType,
+            retryableErrors,
+            recentErrors
+        };
+    }
+}
+// Hook for using error handling in components
+export function useMediaErrorHandler(config) {
+    const [handler] = React.useState(() => new MediaErrorHandler(config));
+    const [errors, setErrors] = React.useState([]);
+    React.useEffect(() => {
+        const unsubscribe = handler.subscribe((error) => {
+            setErrors(current => [...current, error]);
+        });
+        return unsubscribe;
+    }, [handler]);
+    const clearError = React.useCallback((errorId) => {
+        handler.clearError(errorId);
+        setErrors(current => current.filter(e => `${e.action?.type}-${e.timestamp}` !== errorId));
+    }, [handler]);
+    const clearAllErrors = React.useCallback(() => {
+        handler.clearAllErrors();
+        setErrors([]);
+    }, [handler]);
+    return {
+        handler,
+        errors,
+        clearError,
+        clearAllErrors,
+        errorStats: handler.getErrorStats()
+    };
+}
+// Hook for error boundaries
+export function useMediaErrorBoundary() {
+    const [error, setError] = React.useState(null);
+    const resetError = React.useCallback(() => {
+        setError(null);
+    }, []);
+    const captureError = React.useCallback((error, action) => {
+        const handler = new MediaErrorHandler();
+        const mediaError = handler.createMediaError(error, action);
+        setError(mediaError);
+    }, []);
+    return {
+        error,
+        hasError: !!error,
+        resetError,
+        captureError
+    };
+}