react-native-ensys-camera-x 1.0.7

package/lib/module/state.js

@@ -0,0 +1,266 @@
+"use strict";
+
+/**
+ * State management utilities for camera operations
+ */
+
+import { CameraError, ERROR_CODES, getUserFriendlyErrorMessage } from "./errors.js";
+import { LocalizationManager } from "./localization.js";
+import { devError } from "./logger.js";
+
+/**
+ * Operation status types
+ */
+
+/**
+ * Operation result interface
+ */
+
+/**
+ * Create initial operation state
+ */
+export function createInitialOperationState() {
+  return {
+    status: 'idle',
+    timestamp: Date.now()
+  };
+}
+
+/**
+ * Create loading state
+ */
+export function createLoadingState(progress) {
+  return {
+    status: 'loading',
+    progress: progress !== undefined ? Math.min(100, Math.max(0, progress)) : 0,
+    timestamp: Date.now()
+  };
+}
+
+/**
+ * Create success state
+ */
+export function createSuccessState(data) {
+  return {
+    status: 'success',
+    data,
+    timestamp: Date.now()
+  };
+}
+
+/**
+ * Create error state
+ */
+export function createErrorState(error) {
+  let 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() {
+  return {
+    status: 'cancelled',
+    timestamp: Date.now()
+  };
+}
+
+/**
+ * Check if operation is in progress
+ */
+export function isOperationInProgress(result) {
+  return result.status === 'loading';
+}
+
+/**
+ * Check if operation was successful
+ */
+export function isOperationSuccessful(result) {
+  return result.status === 'success' && result.data !== undefined;
+}
+
+/**
+ * Check if operation failed
+ */
+export function isOperationFailed(result) {
+  return result.status === 'error' && result.error !== undefined;
+}
+
+/**
+ * Check if operation was cancelled
+ */
+export function isOperationCancelled(result) {
+  return result.status === 'cancelled';
+}
+
+/**
+ * Get user-friendly status message
+ */
+export function getStatusMessage(result) {
+  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 {
+  queue = [];
+  isProcessing = false;
+  maxConcurrent = 1;
+  generation = 0;
+  constructor(maxConcurrent = 1) {
+    this.maxConcurrent = Math.max(1, maxConcurrent);
+  }
+
+  /**
+   * Add operation to queue
+   */
+  enqueue(operation) {
+    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
+   */
+  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() {
+    this.generation += 1;
+    this.queue = [];
+    this.isProcessing = false;
+  }
+
+  /**
+   * Get queue size
+   */
+  size() {
+    return this.queue.length;
+  }
+
+  /**
+   * Check if queue is processing
+   */
+  isProcessingQueue() {
+    return this.isProcessing;
+  }
+}
+
+/**
+ * Batch operation helper
+ */
+export async function processInBatches(items, batchSize, processor, onProgress) {
+  const results = [];
+  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(operation, maxRetries = 3, initialDelay = 100, backoffFactor = 2) {
+  let lastError;
+  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(operation, timeoutMs, timeoutMessage = LocalizationManager.getString('operationTimedOut', 'Operation timed out')) {
+  return Promise.race([operation(), new Promise((_, reject) => setTimeout(() => {
+    reject(new CameraError(timeoutMessage, ERROR_CODES.OPERATION_FAILED, {
+      timeout: timeoutMs
+    }));
+  }, timeoutMs))]);
+}
+
+// Re-export error handling function
+export { getUserFriendlyErrorMessage } from "./errors.js";
+//# sourceMappingURL=state.js.map

package/lib/module/state.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["CameraError","ERROR_CODES","getUserFriendlyErrorMessage","LocalizationManager","devError","createInitialOperationState","status","timestamp","Date","now","createLoadingState","progress","undefined","Math","min","max","createSuccessState","data","createErrorState","error","cameraError","Error","message","UNKNOWN","originalError","stack","String","createCancelledState","isOperationInProgress","result","isOperationSuccessful","isOperationFailed","isOperationCancelled","getStatusMessage","getString","OperationQueue","queue","isProcessing","maxConcurrent","generation","constructor","enqueue","operation","Promise","resolve","reject","push","setTimeout","processQueue","length","operationsToProcess","splice","all","map","op","clear","size","isProcessingQueue","processInBatches","items","batchSize","processor","onProgress","results","totalItems","i","batch","slice","batchResults","item","batchIndex","round","retryWithBackoff","maxRetries","initialDelay","backoffFactor","lastError","attempt","delay","pow","withTimeout","timeoutMs","timeoutMessage","race","_","OPERATION_FAILED","timeout"],"sourceRoot":"..\\..\\src","sources":["state.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/storage.js

@@ -0,0 +1,400 @@
+"use strict";
+
+/**
+ * Media Storage Module - Bridges React Native with native media storage workflow
+ *
+ * Provides a complete API for managing media lifecycle:
+ * 1. Capture/select media -> stored in cache
+ * 2. User sends/publishes -> moved to documents
+ * 3. Persistent metadata tracking
+ * 4. Automatic cleanup and duplicate detection
+ */
+
+import { NativeModules } from 'react-native';
+const {
+  CustomCamera
+} = NativeModules;
+
+/**
+ * Media Storage Manager - High-level API for media storage operations
+ */
+class MediaStorageManager {
+  initialized = false;
+
+  /**
+   * Initialize the media storage workflow
+   * Call this once when the app starts
+   */
+  async initialize() {
+    try {
+      if (this.initialized) {
+        return {
+          success: true
+        };
+      }
+      const result = await CustomCamera.initializeMediaStorage();
+      this.initialized = result.success;
+      return result;
+    } catch (error) {
+      console.error('[MediaStorage] Initialization failed', error);
+      throw new Error(`Failed to initialize media storage: ${error}`);
+    }
+  }
+
+  /**
+   * Publish media from cache to document directory
+   * Moves file if moveMode=true, copies if false
+   */
+  async publishMedia(mediaId, options) {
+    try {
+      const moveMode = options?.moveMode ?? true;
+      const result = await CustomCamera.publishMedia(mediaId, moveMode);
+      return {
+        success: result.success,
+        mediaId: result.mediaId,
+        sourceLocation: 'cache',
+        targetLocation: 'document',
+        sourceUri: '',
+        targetUri: result.targetUri,
+        fileHash: result.fileHash,
+        movedAt: Date.now(),
+        error: result.error ? {
+          code: 'PUBLISH_ERROR',
+          message: result.error
+        } : undefined
+      };
+    } catch (error) {
+      console.error('[MediaStorage] Publish failed', error);
+      return {
+        success: false,
+        mediaId,
+        sourceLocation: 'cache',
+        targetLocation: 'document',
+        sourceUri: '',
+        movedAt: Date.now(),
+        error: {
+          code: 'PUBLISH_ERROR',
+          message: error instanceof Error ? error.message : 'Unknown error'
+        }
+      };
+    }
+  }
+
+  /**
+   * Publish multiple media files in batch
+   */
+  async publishBatch(mediaIds, options) {
+    try {
+      const moveMode = options?.moveMode ?? true;
+      const result = await CustomCamera.publishBatch(mediaIds, moveMode);
+      return {
+        totalCount: result.totalCount,
+        successCount: result.successCount,
+        failureCount: result.failureCount,
+        results: mediaIds.map(id => ({
+          success: id in (result.results || {}),
+          mediaId: id,
+          sourceLocation: 'cache',
+          targetLocation: 'document',
+          sourceUri: '',
+          movedAt: Date.now()
+        }))
+      };
+    } catch (error) {
+      console.error('[MediaStorage] Batch publish failed', error);
+      throw new Error(`Failed to publish batch: ${error}`);
+    }
+  }
+
+  /**
+   * Get all cached media (not yet published)
+   */
+  async getCachedMedia() {
+    try {
+      const result = await CustomCamera.getCachedMedia();
+      return result.map(item => ({
+        id: item.id,
+        fileName: item.fileName,
+        uri: item.cachePath || '',
+        type: item.fileType === 'video' ? 'video' : 'photo',
+        size: item.fileSize,
+        width: item.width,
+        height: item.height,
+        duration: item.duration,
+        dateTaken: item.cacheCreatedAt,
+        storageLocation: 'cache',
+        storageStatus: 'cached',
+        cacheCreatedAt: item.cacheCreatedAt,
+        cacheLastModified: item.cacheLastModified,
+        isEdited: false
+      }));
+    } catch (error) {
+      console.error('[MediaStorage] Get cached media failed', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get all published media
+   */
+  async getPublishedMedia() {
+    try {
+      const result = await CustomCamera.getPublishedMedia();
+      return result.map(item => ({
+        id: item.id,
+        fileName: item.fileName,
+        uri: item.documentUri || '',
+        type: item.fileType === 'video' ? 'video' : 'photo',
+        size: item.fileSize,
+        width: item.width,
+        height: item.height,
+        duration: item.duration,
+        dateTaken: item.publishedAt,
+        documentUri: item.documentUri,
+        storageLocation: 'document',
+        storageStatus: 'published',
+        cacheCreatedAt: item.cacheCreatedAt,
+        cacheLastModified: item.cacheLastModified,
+        publishedAt: item.publishedAt,
+        isEdited: false
+      }));
+    } catch (error) {
+      console.error('[MediaStorage] Get published media failed', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get storage statistics
+   */
+  async getStorageStats() {
+    try {
+      const stats = await CustomCamera.getStorageStats();
+      return {
+        cacheUsedMB: stats.cacheUsedMB || 0,
+        documentUsedMB: stats.documentUsedMB || 0,
+        totalAvailableMB: stats.totalAvailableMB || 0,
+        cachedItemsCount: stats.cachedItemsCount || 0,
+        publishedItemsCount: stats.publishedItemsCount || 0,
+        duplicateItemsCount: stats.duplicateItemsCount || 0,
+        oldestCacheItemAge: stats.oldestCacheItemAge || 0,
+        newestCacheItemAge: stats.newestCacheItemAge || 0
+      };
+    } catch (error) {
+      console.error('[MediaStorage] Get storage stats failed', error);
+      return {
+        cacheUsedMB: 0,
+        documentUsedMB: 0,
+        totalAvailableMB: 0,
+        cachedItemsCount: 0,
+        publishedItemsCount: 0,
+        duplicateItemsCount: 0,
+        oldestCacheItemAge: 0,
+        newestCacheItemAge: 0
+      };
+    }
+  }
+
+  /**
+   * Cleanup old cache files
+   */
+  async cleanupOldCache(olderThanDays = 7) {
+    try {
+      const result = await CustomCamera.cleanupOldCache(olderThanDays);
+      return {
+        success: result.success,
+        filesRemoved: result.filesRemoved,
+        spaceFreedMB: result.spaceFreedMB,
+        erroredFiles: [],
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      console.error('[MediaStorage] Cleanup failed', error);
+      return {
+        success: false,
+        filesRemoved: 0,
+        spaceFreedMB: 0,
+        erroredFiles: [],
+        timestamp: Date.now()
+      };
+    }
+  }
+
+  /**
+   * Delete a specific media
+   */
+  async deleteMedia(mediaId) {
+    try {
+      return await CustomCamera.deleteStoredMedia(mediaId);
+    } catch (error) {
+      console.error('[MediaStorage] Delete media failed', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get failed transfers that can be retried
+   */
+  async getFailedTransfers() {
+    try {
+      const result = await CustomCamera.getFailedTransfers();
+      return result || [];
+    } catch (error) {
+      console.error('[MediaStorage] Get failed transfers failed', error);
+      return [];
+    }
+  }
+
+  /**
+   * Retry failed transfers
+   */
+  async retryFailedTransfers() {
+    try {
+      const result = await CustomCamera.retryFailedTransfers();
+      return result.map(item => ({
+        success: item.success,
+        mediaId: item.mediaId,
+        sourceLocation: 'cache',
+        targetLocation: 'document',
+        sourceUri: '',
+        targetUri: item.targetUri,
+        movedAt: Date.now(),
+        error: item.error ? {
+          code: 'RETRY_ERROR',
+          message: item.error
+        } : undefined
+      }));
+    } catch (error) {
+      console.error('[MediaStorage] Retry failed transfers failed', error);
+      return [];
+    }
+  }
+
+  /**
+   * Get media cache size in MB
+   */
+  async getCacheSizeMB() {
+    try {
+      const stats = await this.getStorageStats();
+      return stats.cacheUsedMB;
+    } catch (error) {
+      console.error('[MediaStorage] Get cache size failed', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Check if cache is almost full
+   */
+  async isCacheAlmostFull(threshold = 80) {
+    try {
+      const stats = await this.getStorageStats();
+      const percentageUsed = stats.cacheUsedMB / (stats.cacheUsedMB + stats.totalAvailableMB) * 100;
+      return percentageUsed > threshold;
+    } catch (error) {
+      console.error('[MediaStorage] Check cache full failed', error);
+      return false;
+    }
+  }
+
+  /**
+   * Request cleanup if cache exceeds threshold
+   */
+  async requestCleanupIfNeeded(maxCacheMB = 400) {
+    try {
+      const cacheSize = await this.getCacheSizeMB();
+      if (cacheSize > maxCacheMB) {
+        const daysOld = Math.ceil((cacheSize - maxCacheMB) / 10);
+        const result = await this.cleanupOldCache(Math.max(1, daysOld));
+        return result.success;
+      }
+      return true;
+    } catch (error) {
+      console.error('[MediaStorage] Request cleanup failed', error);
+      return false;
+    }
+  }
+
+  /**
+   * Get a summary of storage status
+   */
+  async getStorageSummary() {
+    try {
+      const stats = await this.getStorageStats();
+      const percentageFull = stats.cacheUsedMB / (stats.cacheUsedMB + stats.totalAvailableMB) * 100;
+      return {
+        totalCached: stats.cachedItemsCount,
+        totalPublished: stats.publishedItemsCount,
+        cacheUsageMB: Math.round(stats.cacheUsedMB),
+        cachePercentageFull: Math.round(percentageFull),
+        needsCleanup: percentageFull > 75,
+        duplicatesCount: stats.duplicateItemsCount
+      };
+    } catch (error) {
+      console.error('[MediaStorage] Get storage summary failed', error);
+      return {
+        totalCached: 0,
+        totalPublished: 0,
+        cacheUsageMB: 0,
+        cachePercentageFull: 0,
+        needsCleanup: false,
+        duplicatesCount: 0
+      };
+    }
+  }
+}
+
+// Singleton instance
+let instance = null;
+
+/**
+ * Get the media storage manager instance
+ */
+export function getMediaStorageManager() {
+  if (!instance) {
+    instance = new MediaStorageManager();
+  }
+  return instance;
+}
+
+/**
+ * Quick access functions for common operations
+ */
+
+export async function initializeMediaStorage() {
+  const manager = getMediaStorageManager();
+  const result = await manager.initialize();
+  if (!result.success) {
+    throw new Error(result.message || 'Failed to initialize media storage');
+  }
+}
+export async function publishCachedMedia(mediaId, moveMode = true) {
+  const manager = getMediaStorageManager();
+  const result = await manager.publishMedia(mediaId, {
+    moveMode
+  });
+  if (!result.success) {
+    throw new Error(result.error?.message || 'Failed to publish media');
+  }
+  return result;
+}
+export async function getCacheInfo() {
+  const manager = getMediaStorageManager();
+  const [cached, stats] = await Promise.all([manager.getCachedMedia(), manager.getStorageStats()]);
+  const percentageFull = stats.cacheUsedMB / (stats.cacheUsedMB + stats.totalAvailableMB) * 100;
+  return {
+    items: cached.length,
+    sizeMB: Math.round(stats.cacheUsedMB),
+    percentageFull: Math.round(percentageFull)
+  };
+}
+export async function cleanupExpiredCache() {
+  const manager = getMediaStorageManager();
+  const result = await manager.cleanupOldCache(7);
+  return {
+    filesRemoved: result.filesRemoved,
+    spaceFreedMB: Math.round(result.spaceFreedMB)
+  };
+}
+export { MediaStorageManager };
+//# sourceMappingURL=storage.js.map