react-native-ensys-camera-x 1.0.7

package/src/state.ts

@@ -0,0 +1,333 @@
+/**
+ * State management utilities for camera operations
+ */
+
+import {
+  CameraError,
+  ERROR_CODES,
+  getUserFriendlyErrorMessage,
+} from './errors';
+import { LocalizationManager } from './localization';
+import { devError } from './logger';
+
+/**
+ * Operation status types
+ */
+export type OperationStatus =
+  | 'idle'
+  | 'loading'
+  | 'success'
+  | 'error'
+  | 'cancelled';
+
+/**
+ * Operation result interface
+ */
+export interface OperationResult<T> {
+  status: OperationStatus;
+  data?: T;
+  error?: CameraError;
+  progress?: number; // 0-100
+  timestamp: number;
+}
+
+/**
+ * Create initial operation state
+ */
+export function createInitialOperationState<T>(): OperationResult<T> {
+  return {
+    status: 'idle',
+    timestamp: Date.now(),
+  };
+}
+
+/**
+ * Create loading state
+ */
+export function createLoadingState<T>(progress?: number): OperationResult<T> {
+  return {
+    status: 'loading',
+    progress: progress !== undefined ? Math.min(100, Math.max(0, progress)) : 0,
+    timestamp: Date.now(),
+  };
+}
+
+/**
+ * Create success state
+ */
+export function createSuccessState<T>(data: T): OperationResult<T> {
+  return {
+    status: 'success',
+    data,
+    timestamp: Date.now(),
+  };
+}
+
+/**
+ * Create error state
+ */
+export function createErrorState<T>(
+  error: CameraError | Error | string
+): OperationResult<T> {
+  let cameraError: CameraError;
+
+  if (error instanceof CameraError) {
+    cameraError = error;
+  } else if (error instanceof Error) {
+    cameraError = new CameraError(error.message, ERROR_CODES.UNKNOWN, {
+      originalError: error,
+      stack: error.stack,
+    });
+  } else {
+    cameraError = new CameraError(String(error), ERROR_CODES.UNKNOWN);
+  }
+
+  return {
+    status: 'error',
+    error: cameraError,
+    timestamp: Date.now(),
+  };
+}
+
+/**
+ * Create cancelled state
+ */
+export function createCancelledState<T>(): OperationResult<T> {
+  return {
+    status: 'cancelled',
+    timestamp: Date.now(),
+  };
+}
+
+/**
+ * Check if operation is in progress
+ */
+export function isOperationInProgress<T>(result: OperationResult<T>): boolean {
+  return result.status === 'loading';
+}
+
+/**
+ * Check if operation was successful
+ */
+export function isOperationSuccessful<T>(result: OperationResult<T>): boolean {
+  return result.status === 'success' && result.data !== undefined;
+}
+
+/**
+ * Check if operation failed
+ */
+export function isOperationFailed<T>(result: OperationResult<T>): boolean {
+  return result.status === 'error' && result.error !== undefined;
+}
+
+/**
+ * Check if operation was cancelled
+ */
+export function isOperationCancelled<T>(result: OperationResult<T>): boolean {
+  return result.status === 'cancelled';
+}
+
+/**
+ * Get user-friendly status message
+ */
+export function getStatusMessage<T>(result: OperationResult<T>): string {
+  switch (result.status) {
+    case 'idle':
+      return LocalizationManager.getString('statusReady');
+    case 'loading':
+      return result.progress !== undefined
+        ? LocalizationManager.getString('statusProcessingWithProgress', result.progress)
+        : LocalizationManager.getString('statusProcessing');
+    case 'success':
+      return LocalizationManager.getString('statusSuccess');
+    case 'error':
+      return result.error
+        ? getUserFriendlyErrorMessage(result.error)
+        : LocalizationManager.getString('errorUnknown');
+    case 'cancelled':
+      return LocalizationManager.getString('errorOperationCancelled');
+    default:
+      return LocalizationManager.getString('statusUnknown');
+  }
+}
+
+/**
+ * Operation queue management
+ */
+export class OperationQueue {
+  private queue: Array<() => Promise<void>> = [];
+  private isProcessing = false;
+  private maxConcurrent = 1;
+  private generation = 0;
+
+  constructor(maxConcurrent: number = 1) {
+    this.maxConcurrent = Math.max(1, maxConcurrent);
+  }
+
+  /**
+   * Add operation to queue
+   */
+  enqueue(operation: () => Promise<void>): Promise<void> {
+    const generation = this.generation;
+
+    return new Promise((resolve, reject) => {
+      this.queue.push(async () => {
+        if (generation !== this.generation) {
+          return;
+        }
+
+        try {
+          await operation();
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+
+      setTimeout(() => {
+        this.processQueue();
+      }, 0);
+    });
+  }
+
+  /**
+   * Process queue
+   */
+  private async processQueue() {
+    if (this.isProcessing || this.queue.length === 0) return;
+
+    const generation = this.generation;
+    this.isProcessing = true;
+
+    // Process up to maxConcurrent operations
+    const operationsToProcess = this.queue.splice(0, this.maxConcurrent);
+
+    try {
+      await Promise.all(operationsToProcess.map((op) => op()));
+    } catch (error) {
+      devError('Operation queue error:', error);
+    } finally {
+      if (generation !== this.generation) {
+        return;
+      }
+
+      this.isProcessing = false;
+      // Process remaining queue
+      if (this.queue.length > 0) {
+        this.processQueue();
+      }
+    }
+  }
+
+  /**
+   * Clear queue
+   */
+  clear(): void {
+    this.generation += 1;
+    this.queue = [];
+    this.isProcessing = false;
+  }
+
+  /**
+   * Get queue size
+   */
+  size(): number {
+    return this.queue.length;
+  }
+
+  /**
+   * Check if queue is processing
+   */
+  isProcessingQueue(): boolean {
+    return this.isProcessing;
+  }
+}
+
+/**
+ * Batch operation helper
+ */
+export async function processInBatches<T, R>(
+  items: T[],
+  batchSize: number,
+  processor: (item: T, batchIndex: number, itemIndex: number) => Promise<R>,
+  onProgress?: (progress: number, current: number, total: number) => void
+): Promise<R[]> {
+  const results: R[] = [];
+  const totalItems = items.length;
+
+  for (let i = 0; i < totalItems; i += batchSize) {
+    const batch = items.slice(i, i + batchSize);
+    const batchResults = await Promise.all(
+      batch.map((item, batchIndex) =>
+        processor(item, i / batchSize, i + batchIndex)
+      )
+    );
+
+    results.push(...batchResults);
+
+    if (onProgress) {
+      const progress = Math.min(
+        100,
+        Math.round(((i + batch.length) / totalItems) * 100)
+      );
+      onProgress(progress, i + batch.length, totalItems);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Retry operation with exponential backoff
+ */
+export async function retryWithBackoff<T>(
+  operation: () => Promise<T>,
+  maxRetries: number = 3,
+  initialDelay: number = 100,
+  backoffFactor: number = 2
+): Promise<T> {
+  let lastError: unknown;
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error;
+
+      if (attempt < maxRetries) {
+        const delay = initialDelay * Math.pow(backoffFactor, attempt - 1);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Timeout wrapper for operations
+ */
+export function withTimeout<T>(
+  operation: () => Promise<T>,
+  timeoutMs: number,
+  timeoutMessage: string = LocalizationManager.getString(
+    'operationTimedOut',
+    'Operation timed out'
+  )
+): Promise<T> {
+  return Promise.race([
+    operation(),
+    new Promise<T>((_, reject) =>
+      setTimeout(() => {
+        reject(
+          new CameraError(timeoutMessage, ERROR_CODES.OPERATION_FAILED, {
+            timeout: timeoutMs,
+          })
+        );
+      }, timeoutMs)
+    ),
+  ]);
+}
+
+// Re-export error handling function
+export { getUserFriendlyErrorMessage } from './errors';