react-native-ensys-camera-x 1.0.7

package/src/logger.ts

@@ -0,0 +1,20 @@
+// Simple development-only logger to avoid direct console usage
+declare const __DEV__: boolean;
+
+export function devLog(...args: unknown[]): void {
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    console.log(...args);
+  }
+}
+
+export function devWarn(...args: unknown[]): void {
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    console.warn(...args);
+  }
+}
+
+export function devError(...args: unknown[]): void {
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    console.error(...args);
+  }
+}

package/src/lowMemoryCache.ts

@@ -0,0 +1,218 @@
+/**
+ * Low-memory optimized cache for media operations
+ * Designed specifically for devices with 2GB-4GB RAM
+ */
+
+import type { ImageCropOptions } from './types';
+import { isGifAsset } from './utils';
+
+export class LowMemoryCache {
+  private cache: Map<string, string>;
+  private maxSizeMb: number;
+  private currentSize: number = 0;
+
+  /**
+   * Create a low-memory cache
+   * @param maxSizeMb Maximum cache size in megabytes (default: 20MB for low-end devices)
+   */
+  constructor(maxSizeMb: number = 20) {
+    this.maxSizeMb = maxSizeMb * 1024 * 1024; // Convert to bytes
+    this.cache = new Map();
+  }
+
+  /**
+   * Get cached value
+   */
+  async get(key: string): Promise<string | undefined> {
+    return this.cache.get(key);
+  }
+
+  /**
+   * Set cached value with size awareness
+   */
+  async set(key: string, value: string, size: number): Promise<void> {
+    // Aggressive eviction for low memory devices
+    while (this.currentSize + size > this.maxSizeMb && this.cache.size > 0) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey === undefined) {
+        break;
+      }
+      const firstSize = this.estimateSize(firstKey);
+      this.cache.delete(firstKey);
+      this.currentSize -= firstSize;
+    }
+
+    // Only cache if we have enough memory
+    if (this.currentSize + size <= this.maxSizeMb) {
+      this.cache.set(key, value);
+      this.currentSize += size;
+    }
+  }
+
+  /**
+   * Estimate size of cached item (conservative estimate)
+   */
+  private estimateSize(_key: string): number {
+    // Very conservative size estimation for low-end devices
+    return 512 * 1024; // Assume 512KB per item
+  }
+
+  /**
+   * Clear the entire cache
+   */
+  clear(): void {
+    this.cache.clear();
+    this.currentSize = 0;
+  }
+
+  /**
+   * Handle memory warning from system
+   * Evicts 50% of cache immediately
+   */
+  onMemoryWarning(): void {
+    // Clear 50% of cache on memory warning
+    const keys = Array.from(this.cache.keys());
+    const toRemove = Math.ceil(keys.length * 0.5);
+
+    for (let i = 0; i < toRemove; i++) {
+      const key = keys[i];
+      if (key === undefined) {
+        continue;
+      }
+      const size = this.estimateSize(key);
+      this.cache.delete(key);
+      this.currentSize -= size;
+    }
+  }
+
+  /**
+   * Get current cache size in bytes
+   */
+  size(): number {
+    return this.currentSize;
+  }
+
+  /**
+   * Get number of items in cache
+   */
+  count(): number {
+    return this.cache.size;
+  }
+}
+
+/**
+ * Process media with low-memory optimizations
+ */
+export async function processMediaForLowEnd(
+  uri: string,
+  options: ImageCropOptions,
+  isLowEndDevice: boolean = true
+): Promise<string> {
+  // Cropping decodes and re-encodes to a flat still, which would destroy a GIF's animation.
+  // Saving memory is never worth silently converting the user's file, so a GIF is returned
+  // untouched — it stays animated all the way to the send.
+  if (isGifAsset({ uri })) {
+    return uri;
+  }
+
+  if (isLowEndDevice) {
+    // More aggressive downscaling for low-end devices
+    const lowEndOptions = {
+      width: Math.min(options.width || 1024, 800), // Cap at 800px
+      height: Math.min(options.height || 1024, 800), // Cap at 800px
+      quality: 0.7, // Reduce quality for smaller files
+    };
+
+    // Import dynamically to avoid bundling if not needed
+    const { cropImage } = await import('./index');
+    return cropImage(uri, lowEndOptions);
+  }
+
+  // Use standard processing for capable devices
+  const { cropImage } = await import('./index');
+  return cropImage(uri, options);
+}
+
+/**
+ * Memory-efficient batch processing for low-end devices
+ */
+export async function processInSmallBatches<T, R>(
+  items: T[],
+  batchSize: number,
+  processor: (item: T, batchIndex: number, itemIndex: number) => Promise<R>,
+  onProgress?: (progress: number) => void,
+  isLowEndDevice: boolean = true
+): Promise<R[]> {
+  const results: R[] = [];
+  const totalItems = items.length;
+
+  // Use smaller batch size for low-end devices
+  const effectiveBatchSize = isLowEndDevice
+    ? Math.min(batchSize, 2)
+    : batchSize;
+
+  for (let i = 0; i < totalItems; i += effectiveBatchSize) {
+    const batch = items.slice(i, i + effectiveBatchSize);
+
+    // Process one at a time to reduce memory pressure
+    for (const item of batch) {
+      const result = await processor(item, i / effectiveBatchSize, i);
+      results.push(result);
+
+      if (onProgress) {
+        const progress = Math.min(
+          100,
+          Math.round(((i + 1) / totalItems) * 100)
+        );
+        onProgress(progress);
+      }
+
+      // Yield to main thread and allow garbage collection
+      if (isLowEndDevice) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Get optimized image dimensions for low-end devices
+ */
+export function getOptimizedImageDimensions(
+  originalWidth: number,
+  originalHeight: number,
+  isLowEndDevice: boolean = true
+): { width: number; height: number } {
+  if (!isLowEndDevice) {
+    return { width: originalWidth, height: originalHeight };
+  }
+
+  // For low-end devices, never exceed 800px on either dimension
+  const maxDimension = 800;
+  const aspectRatio = originalWidth / originalHeight;
+
+  if (originalWidth > originalHeight) {
+    // Landscape
+    const width = Math.min(originalWidth, maxDimension);
+    const height = Math.round(width / aspectRatio);
+    return { width, height };
+  } else {
+    // Portrait or square
+    const height = Math.min(originalHeight, maxDimension);
+    const width = Math.round(height * aspectRatio);
+    return { width, height };
+  }
+}
+
+/**
+ * Check if device should use low-memory optimizations
+ */
+export function shouldUseLowMemoryOptimizations(
+  ram: 'low' | 'medium' | 'high',
+  processor: 'weak' | 'medium' | 'strong'
+): boolean {
+  // Use low-memory optimizations for low-end devices
+  return ram === 'low' || processor === 'weak';
+}

package/src/mediaHistory.ts

@@ -0,0 +1,42 @@
+import type { CameraAsset } from './types';
+
+function getAssetKey(asset: CameraAsset): string | null {
+  if (asset.id) return `id:${asset.id}`;
+  if (asset.uri) return `uri:${asset.uri}`;
+  if (asset.fileName) return `file:${asset.fileName}`;
+  return null;
+}
+
+export function prependMediaHistory(
+  existingAssets: CameraAsset[],
+  incomingAssets: CameraAsset[]
+): CameraAsset[] {
+  if (incomingAssets.length === 0) {
+    return existingAssets;
+  }
+
+  const seenKeys = new Set<string>();
+  const orderedAssets: CameraAsset[] = [];
+
+  for (const asset of incomingAssets) {
+    const key = getAssetKey(asset);
+    if (!key || seenKeys.has(key)) {
+      continue;
+    }
+
+    seenKeys.add(key);
+    orderedAssets.push(asset);
+  }
+
+  for (const asset of existingAssets) {
+    const key = getAssetKey(asset);
+    if (!key || seenKeys.has(key)) {
+      continue;
+    }
+
+    seenKeys.add(key);
+    orderedAssets.push(asset);
+  }
+
+  return orderedAssets;
+}