react-native-ensys-camera-x 1.0.7

package/src/errors.ts

@@ -0,0 +1,350 @@
+/**
+ * Comprehensive error handling for the camera module
+ */
+
+import type {
+  CameraTheme,
+  FaceEffect,
+  FilterType,
+  FlashMode,
+  ImageCropOptions,
+} from './types';
+import { LocalizationManager } from './localization';
+
+export class CameraError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public details?: unknown,
+    public isRecoverable = false,
+    public severity: 'low' | 'medium' | 'high' = 'medium'
+  ) {
+    super(message);
+    this.name = 'CameraError';
+    (
+      Error as ErrorConstructor & {
+        captureStackTrace?: (target: object, constructor?: Function) => void;
+      }
+    ).captureStackTrace?.(this, this.constructor);
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details,
+      isRecoverable: this.isRecoverable,
+      severity: this.severity,
+      stack: this.stack,
+    };
+  }
+}
+
+// Error Codes
+export const ERROR_CODES = {
+  // General errors
+  UNKNOWN: 'CAMERA_UNKNOWN_ERROR',
+  NO_ACTIVITY: 'CAMERA_NO_ACTIVITY',
+  PICKER_ALREADY_OPEN: 'CAMERA_PICKER_ALREADY_OPEN',
+
+  // Permission errors
+  PERMISSION_DENIED: 'CAMERA_PERMISSION_DENIED',
+  CAMERA_PERMISSION_DENIED: 'CAMERA_CAMERA_PERMISSION_DENIED',
+  MICROPHONE_PERMISSION_DENIED: 'CAMERA_MICROPHONE_PERMISSION_DENIED',
+  STORAGE_PERMISSION_DENIED: 'CAMERA_STORAGE_PERMISSION_DENIED',
+
+  // Input validation errors
+  INVALID_URI: 'CAMERA_INVALID_URI',
+  INVALID_FILE_TYPE: 'CAMERA_INVALID_FILE_TYPE',
+  INVALID_PARAMETER: 'CAMERA_INVALID_PARAMETER',
+  FILE_NOT_FOUND: 'CAMERA_FILE_NOT_FOUND',
+  FILE_TOO_LARGE: 'CAMERA_FILE_TOO_LARGE',
+
+  // Operation errors
+  OPERATION_CANCELLED: 'CAMERA_OPERATION_CANCELLED',
+  OPERATION_FAILED: 'CAMERA_OPERATION_FAILED',
+  UNSUPPORTED_OPERATION: 'CAMERA_UNSUPPORTED_OPERATION',
+
+  // Media errors
+  MEDIA_CORRUPTED: 'CAMERA_MEDIA_CORRUPTED',
+  MEDIA_TYPE_NOT_SUPPORTED: 'CAMERA_MEDIA_TYPE_NOT_SUPPORTED',
+
+  // Network errors
+  NETWORK_UNAVAILABLE: 'CAMERA_NETWORK_UNAVAILABLE',
+  UPLOAD_FAILED: 'CAMERA_UPLOAD_FAILED',
+
+  // Device errors
+  CAMERA_UNAVAILABLE: 'CAMERA_CAMERA_UNAVAILABLE',
+  DEVICE_NOT_SUPPORTED: 'CAMERA_DEVICE_NOT_SUPPORTED',
+
+  // Memory errors
+  INSUFFICIENT_MEMORY: 'CAMERA_INSUFFICIENT_MEMORY',
+  INSUFFICIENT_STORAGE: 'CAMERA_INSUFFICIENT_STORAGE',
+} as const;
+
+export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+
+/**
+ * Validate URI format
+ */
+export function validateUri(uri: string): boolean {
+  if (!uri || typeof uri !== 'string') return false;
+
+  // Basic URI validation
+  try {
+    // Check if it's a valid file URI or content URI
+    const isFileUri = uri.startsWith('file://') || uri.startsWith('content://');
+    const isHttpUri = uri.startsWith('http://') || uri.startsWith('https://');
+
+    if (!isFileUri && !isHttpUri) return false;
+
+    // Additional validation for file URIs
+    if (isFileUri) {
+      const path = decodeURI(uri.replace('file://', ''));
+      if (path.length === 0) return false;
+    }
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Validate file type based on URI
+ */
+export function validateFileType(uri: string, allowedTypes: string[]): boolean {
+  if (!validateUri(uri)) return false;
+
+  // Extract extension
+  const extension = uri.split('.').pop()?.toLowerCase() || '';
+  return allowedTypes.includes(extension);
+}
+
+/**
+ * Validate image file types
+ */
+export function validateImageUri(uri: string): boolean {
+  return validateFileType(uri, [
+    'jpg',
+    'jpeg',
+    'png',
+    'gif',
+    'webp',
+    'bmp',
+    'heic',
+    'heif',
+    'hif',
+    'avif',
+    'avifs',
+  ]);
+}
+
+/**
+ * Validate video file types
+ */
+export function validateVideoUri(uri: string): boolean {
+  return validateFileType(uri, ['mp4', 'mov', 'avi', 'mkv', 'webm', '3gp']);
+}
+
+/**
+ * Validate crop options
+ */
+export function validateCropOptions(options: ImageCropOptions): void {
+  if (
+    options.width !== undefined &&
+    (isNaN(options.width) || options.width <= 0)
+  ) {
+    throw new CameraError(
+      LocalizationManager.getString('validationWidthPositive'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'width', value: options.width }
+    );
+  }
+
+  if (
+    options.height !== undefined &&
+    (isNaN(options.height) || options.height <= 0)
+  ) {
+    throw new CameraError(
+      LocalizationManager.getString('validationHeightPositive'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'height', value: options.height }
+    );
+  }
+
+  if (options.x !== undefined && isNaN(options.x)) {
+    throw new CameraError(
+      LocalizationManager.getString('validationXNumber'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'x', value: options.x }
+    );
+  }
+
+  if (options.y !== undefined && isNaN(options.y)) {
+    throw new CameraError(
+      LocalizationManager.getString('validationYNumber'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'y', value: options.y }
+    );
+  }
+}
+
+/**
+ * Validate filter type
+ */
+export function validateFilterType(filterType: string): void {
+  const validFilters: FilterType[] = [
+    'none',
+    'grayscale',
+    'sepia',
+    'vintage',
+    'blur',
+  ];
+
+  if (!validFilters.includes(filterType as FilterType)) {
+    throw new CameraError(
+      LocalizationManager.getString(
+        'validationFilterTypeInvalid',
+        filterType,
+        validFilters.join(', ')
+      ),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'filterType', value: filterType, validOptions: validFilters }
+    );
+  }
+}
+
+/**
+ * Validate flash mode
+ */
+export function validateFlashMode(mode: string): void {
+  const validModes: FlashMode[] = ['off', 'on', 'auto', 'torch'];
+
+  if (!validModes.includes(mode as FlashMode)) {
+    throw new CameraError(
+      LocalizationManager.getString(
+        'validationFlashModeInvalid',
+        mode,
+        validModes.join(', ')
+      ),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'mode', value: mode, validOptions: validModes }
+    );
+  }
+}
+
+/**
+ * Validate face effect
+ */
+export function validateFaceEffect(effect: string): void {
+  const validEffects: FaceEffect[] = ['none', 'dog', 'cat', 'glasses', 'hat'];
+
+  if (!validEffects.includes(effect as FaceEffect)) {
+    throw new CameraError(
+      LocalizationManager.getString(
+        'validationFaceEffectInvalid',
+        effect,
+        validEffects.join(', ')
+      ),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'effect', value: effect, validOptions: validEffects }
+    );
+  }
+}
+
+/**
+ * Validate camera theme
+ */
+export function validateCameraTheme(theme: string): void {
+  const validThemes: CameraTheme[] = ['default', 'dark', 'light', 'minimal'];
+
+  if (!validThemes.includes(theme as CameraTheme)) {
+    throw new CameraError(
+      LocalizationManager.getString(
+        'validationThemeInvalid',
+        theme,
+        validThemes.join(', ')
+      ),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'theme', value: theme, validOptions: validThemes }
+    );
+  }
+}
+
+/**
+ * Check if error is a CameraError
+ */
+export function isCameraError(error: unknown): error is CameraError {
+  return (
+    error instanceof CameraError ||
+    (typeof error === 'object' &&
+      error !== null &&
+      'name' in error &&
+      error.name === 'CameraError')
+  );
+}
+
+/**
+ * Handle errors consistently
+ */
+export function handleCameraError(error: unknown): never {
+  if (isCameraError(error)) {
+    // Re-throw CameraError as-is
+    throw error;
+  } else if (error instanceof Error) {
+    // Convert regular errors to CameraError
+    throw new CameraError(error.message, ERROR_CODES.UNKNOWN, {
+      originalError: error,
+      stack: error.stack,
+    });
+  } else {
+    // Handle non-error objects
+    throw new CameraError(String(error), ERROR_CODES.UNKNOWN, {
+      originalValue: error,
+    });
+  }
+}
+
+/**
+ * Create user-friendly error messages
+ */
+export function getUserFriendlyErrorMessage(error: unknown): string {
+  if (isCameraError(error)) {
+    switch (error.code) {
+      case ERROR_CODES.PERMISSION_DENIED:
+        return LocalizationManager.getString('errorCameraPermission');
+      case ERROR_CODES.CAMERA_PERMISSION_DENIED:
+        return LocalizationManager.getString('errorPleaseEnableCameraPermission');
+      case ERROR_CODES.MICROPHONE_PERMISSION_DENIED:
+        return LocalizationManager.getString('errorMicrophonePermission');
+      case ERROR_CODES.STORAGE_PERMISSION_DENIED:
+        return LocalizationManager.getString('errorStoragePermission');
+      case ERROR_CODES.INVALID_URI:
+        return LocalizationManager.getString('errorInvalidUri');
+      case ERROR_CODES.FILE_NOT_FOUND:
+        return LocalizationManager.getString('errorFileNotFound');
+      case ERROR_CODES.FILE_TOO_LARGE:
+        return LocalizationManager.getString('errorFileTooLarge');
+      case ERROR_CODES.OPERATION_CANCELLED:
+        return LocalizationManager.getString('errorOperationCancelled');
+      case ERROR_CODES.CAMERA_UNAVAILABLE:
+        return LocalizationManager.getString('errorCameraUnavailable');
+      case ERROR_CODES.INSUFFICIENT_STORAGE:
+        return LocalizationManager.getString('errorInsufficientStorage');
+      case ERROR_CODES.NETWORK_UNAVAILABLE:
+        return LocalizationManager.getString('errorNetworkUnavailable');
+      case ERROR_CODES.UPLOAD_FAILED:
+        return LocalizationManager.getString('errorUploadFailed');
+      default:
+        return error.message || LocalizationManager.getString('errorUnknown');
+    }
+  }
+
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  return LocalizationManager.getString('errorUnknown');
+}