react-native-ensys-camera-x 1.0.7

package/src/utils.ts

@@ -0,0 +1,177 @@
+import type {
+  CameraTheme,
+  FaceEffect,
+  FilterType,
+  FlashMode,
+  ImageCropOptions,
+} from './types';
+
+export const DEFAULT_FILTERS: FilterType[] = [
+  'none',
+  'grayscale',
+  'sepia',
+  'vintage',
+  'blur',
+];
+
+export const DEFAULT_FACE_EFFECTS: FaceEffect[] = [
+  'none',
+  'dog',
+  'cat',
+  'glasses',
+  'hat',
+];
+
+export const DEFAULT_THEMES: CameraTheme[] = [
+  'default',
+  'dark',
+  'light',
+  'minimal',
+];
+
+export const DEFAULT_FLASH_MODES: FlashMode[] = ['off', 'on', 'auto', 'torch'];
+
+/**
+ * Helper function to validate image crop options
+ */
+export function validateCropOptions(options: ImageCropOptions): boolean {
+  if (options.width === 0 || (options.width !== undefined && options.width < 0)) {
+    return false;
+  }
+  if (options.height === 0 || (options.height !== undefined && options.height < 0)) {
+    return false;
+  }
+  if (options.x !== undefined && options.x < 0) return false;
+  if (options.y !== undefined && options.y < 0) return false;
+  return true;
+}
+
+/**
+ * Helper function to generate a unique album name
+ */
+let albumNameCounter = 0;
+
+export function generateAlbumName(baseName: string): string {
+  const timestamp = new Date().getTime();
+  albumNameCounter += 1;
+  return `${baseName}_${timestamp}_${albumNameCounter}`;
+}
+
+/**
+ * Helper function to format video duration
+ */
+export function formatVideoDuration(seconds: number): string {
+  const mins = Math.floor(seconds / 60);
+  const secs = Math.floor(seconds % 60);
+  return `${mins}:${secs.toString().padStart(2, '0')}`;
+}
+
+/**
+ * Helper function to check if a URI is a video
+ */
+export function isVideoUri(uri: string): boolean {
+  return (
+    uri.toLowerCase().endsWith('.mp4') ||
+    uri.toLowerCase().endsWith('.mov') ||
+    uri.toLowerCase().endsWith('.avi')
+  );
+}
+
+/**
+ * Every still-image container the library handles end to end. Mirrors the native
+ * `ImageFormatSupport` registry — a format present in one and absent from the other is how an
+ * image ends up discovered but not rendered (or vice versa).
+ */
+const IMAGE_EXTENSIONS = new Set([
+  'jpg',
+  'jpeg',
+  'png',
+  'gif',
+  'webp',
+  'bmp',
+  'heic',
+  'heif',
+  'hif',
+  'avif',
+  'avifs',
+]);
+
+/**
+ * Helper function to check if a URI is an image
+ */
+export function isImageUri(uri: string): boolean {
+  // Strip any query string / fragment so `…/photo.avif?token=…` still matches.
+  const path = uri.split(/[?#]/)[0] ?? '';
+  const extension = path.split('.').pop()?.toLowerCase() ?? '';
+  return IMAGE_EXTENSIONS.has(extension);
+}
+
+/**
+ * Whether an asset is a GIF, judged by its declared MIME type first and its file name / uri
+ * extension second — so a file from a provider that reports no MIME type is still recognised.
+ *
+ * A declared, recognised `image/*` type is authoritative: an asset that says it is `image/jpeg`
+ * is not reclassified just because something in its path ends in `.gif`. Mirrors the native
+ * `GifSupport.isGif` precedence so the two sides never disagree about the same file.
+ */
+export function isGifAsset(asset: {
+  mimeType?: string | null;
+  fileName?: string | null;
+  uri?: string | null;
+}): boolean {
+  const mime = asset.mimeType?.toLowerCase();
+  if (mime) {
+    if (mime === 'image/gif') return true;
+    if (mime.startsWith('image/')) return false;
+  }
+  const name = asset.fileName ?? asset.uri;
+  if (!name) return false;
+  // Strip any query string so `…/file.gif?token=…` still matches.
+  const path = name.split(/[?#]/)[0] ?? '';
+  return path.toLowerCase().endsWith('.gif');
+}
+
+/**
+ * Containers ReactNative's own `<Image>` cannot decode on Android. Fresco has no HEIF or AVIF
+ * decoder, so an `<Image>` pointed at one renders nothing at all — a blank tile, with no error.
+ */
+const NATIVE_DECODE_ONLY_MIMES = new Set([
+  'image/heic',
+  'image/heif',
+  'image/heic-sequence',
+  'image/heif-sequence',
+  'image/avif',
+]);
+const NATIVE_DECODE_ONLY_EXTENSIONS = new Set([
+  'heic',
+  'heif',
+  'hif',
+  'avif',
+  'avifs',
+]);
+
+/**
+ * Whether this image must be rendered through the library's native image view instead of
+ * ReactNative's `<Image>`.
+ *
+ * HEIF and AVIF are decoded by the Android platform (API 28+ / API 31+ respectively) but NOT by
+ * Fresco, which is what backs `<Image>` on Android — so those assets silently render as empty
+ * space. `NativeAnimatedImageView` decodes through ImageDecoder/BitmapFactory and therefore shows
+ * them wherever the platform can. Same MIME-then-extension precedence as {@link isGifAsset}.
+ */
+export function requiresNativeImageDecoder(asset: {
+  mimeType?: string | null;
+  fileName?: string | null;
+  uri?: string | null;
+}): boolean {
+  const mime = asset.mimeType?.toLowerCase().split(';')[0]?.trim();
+  if (mime) {
+    if (NATIVE_DECODE_ONLY_MIMES.has(mime)) return true;
+    if (mime.startsWith('image/')) return false;
+  }
+  const name = asset.fileName ?? asset.uri;
+  if (!name) return false;
+  const path = name.split(/[?#]/)[0] ?? '';
+  const extension = path.split('.').pop()?.toLowerCase() ?? '';
+  return NATIVE_DECODE_ONLY_EXTENSIONS.has(extension);
+}

package/src/validation.ts

@@ -0,0 +1,372 @@
+/**
+ * Comprehensive validation utilities for camera operations
+ */
+
+import { CameraError, ERROR_CODES, validateUri } from './errors';
+import { LocalizationManager } from './localization';
+import type { CameraPickerOptions } from './types';
+
+// Constants
+const MAX_IMAGE_SIZE = 50 * 1024 * 1024; // 50MB
+const MAX_VIDEO_SIZE = 500 * 1024 * 1024; // 500MB
+const MAX_ALBUM_NAME_LENGTH = 100;
+const MAX_CAPTION_LENGTH = 2000;
+const MAX_BATCH_SIZE = 50;
+
+/**
+ * Validate camera picker options
+ */
+export function validateCameraPickerOptions(
+  options: CameraPickerOptions
+): void {
+  if (options.selectionLimit !== undefined) {
+    if (
+      !Number.isInteger(options.selectionLimit) ||
+      options.selectionLimit < 0
+    ) {
+      throw new CameraError(
+        LocalizationManager.getString('validationSelectionLimitNonNegativeInteger'),
+        ERROR_CODES.INVALID_PARAMETER,
+        { parameter: 'selectionLimit', value: options.selectionLimit }
+      );
+    }
+  }
+
+  if (
+    options.initialCamera &&
+    !['back', 'front'].includes(options.initialCamera)
+  ) {
+    throw new CameraError(
+      LocalizationManager.getString('validationInitialCameraInvalid'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'initialCamera', value: options.initialCamera }
+    );
+  }
+
+  if (
+    options.mediaTypes &&
+    !['all', 'photo', 'video'].includes(options.mediaTypes)
+  ) {
+    throw new CameraError(
+      LocalizationManager.getString('validationMediaTypesInvalid'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'mediaTypes', value: options.mediaTypes }
+    );
+  }
+
+  // Hold-to-record durations. The native side clamps these anyway, but a nonsense value is far
+  // easier to spot here than as a gesture that silently behaves nothing like the caller asked.
+  if (options.holdToRecordDelayMs !== undefined) {
+    if (
+      !Number.isFinite(options.holdToRecordDelayMs) ||
+      options.holdToRecordDelayMs < 0
+    ) {
+      throw new CameraError(
+        LocalizationManager.getString('validationHoldToRecordDelayInvalid'),
+        ERROR_CODES.INVALID_PARAMETER,
+        {
+          parameter: 'holdToRecordDelayMs',
+          value: options.holdToRecordDelayMs,
+        }
+      );
+    }
+  }
+
+  if (options.minRecordDurationMs !== undefined) {
+    if (
+      !Number.isFinite(options.minRecordDurationMs) ||
+      options.minRecordDurationMs < 0
+    ) {
+      throw new CameraError(
+        LocalizationManager.getString('validationMinRecordDurationInvalid'),
+        ERROR_CODES.INVALID_PARAMETER,
+        { parameter: 'minRecordDurationMs', value: options.minRecordDurationMs }
+      );
+    }
+  }
+}
+
+/**
+ * Validate URIs array
+ */
+export function validateUrisArray(uris: string[]): void {
+  if (!Array.isArray(uris)) {
+    throw new CameraError(
+      LocalizationManager.getString('validationUrisMustBeArray'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'uris', value: uris }
+    );
+  }
+
+  if (uris.length === 0) {
+    throw new CameraError(
+      LocalizationManager.getString('validationUrisCannotBeEmpty'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'uris', value: uris }
+    );
+  }
+
+  if (uris.length > MAX_BATCH_SIZE) {
+    throw new CameraError(
+      LocalizationManager.getString('validationTooManyFiles', MAX_BATCH_SIZE),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'uris', value: uris, maxAllowed: MAX_BATCH_SIZE }
+    );
+  }
+
+  uris.forEach((uri, index) => {
+    if (!validateUri(uri)) {
+      throw new CameraError(
+        LocalizationManager.getString('validationInvalidUriAtIndex', index, uri),
+        ERROR_CODES.INVALID_URI,
+        { uri, index }
+      );
+    }
+  });
+}
+
+/**
+ * Validate album name
+ */
+export function validateAlbumName(albumName: string): void {
+  if (!albumName || typeof albumName !== 'string') {
+    throw new CameraError(
+      LocalizationManager.getString('validationAlbumNameRequired'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'albumName', value: albumName }
+    );
+  }
+
+  if (albumName.length > MAX_ALBUM_NAME_LENGTH) {
+    throw new CameraError(
+      LocalizationManager.getString(
+        'validationAlbumNameTooLong',
+        MAX_ALBUM_NAME_LENGTH
+      ),
+      ERROR_CODES.INVALID_PARAMETER,
+      {
+        parameter: 'albumName',
+        value: albumName,
+        maxLength: MAX_ALBUM_NAME_LENGTH,
+      }
+    );
+  }
+
+  // Check for invalid characters
+  const invalidChars = /[/:*?"<>|]/;
+  if (invalidChars.test(albumName)) {
+    throw new CameraError(
+      LocalizationManager.getString('validationAlbumNameInvalidCharacters'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'albumName', value: albumName }
+    );
+  }
+}
+
+/**
+ * Validate caption
+ */
+export function validateCaption(caption: string): void {
+  if (caption === undefined || caption === null) return;
+
+  if (typeof caption !== 'string') {
+    throw new CameraError(
+      LocalizationManager.getString('validationCaptionMustBeString'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'caption', value: caption }
+    );
+  }
+
+  if (caption.length > MAX_CAPTION_LENGTH) {
+    throw new CameraError(
+      LocalizationManager.getString('validationCaptionTooLong', MAX_CAPTION_LENGTH),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'caption', value: caption, maxLength: MAX_CAPTION_LENGTH }
+    );
+  }
+}
+
+/**
+ * Validate timer delay
+ */
+export function validateTimerDelay(delaySeconds: number): void {
+  if (isNaN(delaySeconds) || !isFinite(delaySeconds)) {
+    throw new CameraError(
+      LocalizationManager.getString('validationDelayMustBeNumber'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'delaySeconds', value: delaySeconds }
+    );
+  }
+
+  if (delaySeconds < 0) {
+    throw new CameraError(
+      LocalizationManager.getString('validationDelayCannotBeNegative'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'delaySeconds', value: delaySeconds }
+    );
+  }
+
+  if (delaySeconds > 30) {
+    throw new CameraError(
+      LocalizationManager.getString('validationDelayTooLong', 30),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'delaySeconds', value: delaySeconds, maxAllowed: 30 }
+    );
+  }
+}
+
+/**
+ * Validate video trim parameters
+ */
+export function validateVideoTrimParameters(
+  startTime: number,
+  endTime: number
+): void {
+  if (isNaN(startTime) || !isFinite(startTime) || startTime < 0) {
+    throw new CameraError(
+      LocalizationManager.getString('validationStartTimeInvalid'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'startTime', value: startTime }
+    );
+  }
+
+  if (isNaN(endTime) || !isFinite(endTime) || endTime < 0) {
+    throw new CameraError(
+      LocalizationManager.getString('validationEndTimeInvalid'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'endTime', value: endTime }
+    );
+  }
+
+  if (startTime >= endTime) {
+    throw new CameraError(
+      LocalizationManager.getString('validationStartBeforeEnd'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { startTime, endTime }
+    );
+  }
+
+  if (endTime - startTime > 600) {
+    // 10 minutes max
+    throw new CameraError(
+      LocalizationManager.getString('validationTrimDurationTooLong', 600),
+      ERROR_CODES.INVALID_PARAMETER,
+      { startTime, endTime, maxDuration: 600 }
+    );
+  }
+}
+
+/**
+ * Validate upload URL
+ */
+export function validateUploadUrl(uploadUrl: string): void {
+  if (!uploadUrl || typeof uploadUrl !== 'string') {
+    throw new CameraError(
+      LocalizationManager.getString('validationUploadUrlRequired'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'uploadUrl', value: uploadUrl }
+    );
+  }
+
+  try {
+    // Basic URL validation
+    const parsedUrl = new URL(uploadUrl);
+    if (!parsedUrl.hostname) {
+      throw new Error('invalid URL');
+    }
+  } catch {
+    throw new CameraError(
+      LocalizationManager.getString('validationUploadUrlInvalid'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'uploadUrl', value: uploadUrl }
+    );
+  }
+}
+
+/**
+ * Check file size limits
+ */
+export function checkFileSize(
+  uri: string,
+  size: number,
+  isVideo: boolean
+): void {
+  const maxSize = isVideo ? MAX_VIDEO_SIZE : MAX_IMAGE_SIZE;
+
+  if (size > maxSize) {
+    const maxSizeMb = maxSize / (1024 * 1024);
+    const fileSizeMb = size / (1024 * 1024);
+
+    throw new CameraError(
+      LocalizationManager.getString(
+        'validationFileTooLarge',
+        isVideo
+          ? LocalizationManager.getString('video', 'Video')
+          : LocalizationManager.getString('image', 'Image'),
+        fileSizeMb.toFixed(2),
+        maxSizeMb
+      ),
+      ERROR_CODES.FILE_TOO_LARGE,
+      { uri, size, maxSize, isVideo }
+    );
+  }
+}
+
+/**
+ * Validate album ID
+ */
+export function validateAlbumId(albumId: string): void {
+  if (!albumId || typeof albumId !== 'string') {
+    throw new CameraError(
+      LocalizationManager.getString('validationAlbumIdRequired'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'albumId', value: albumId }
+    );
+  }
+
+  if (albumId.length > 100) {
+    throw new CameraError(
+      LocalizationManager.getString('validationAlbumIdTooLong', 100),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'albumId', value: albumId }
+    );
+  }
+}
+
+/**
+ * Validate rotation degrees
+ */
+export function validateRotationDegrees(degrees: number): void {
+  if (isNaN(degrees) || !isFinite(degrees)) {
+    throw new CameraError(
+      LocalizationManager.getString('validationDegreesMustBeNumber'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'degrees', value: degrees }
+    );
+  }
+
+  // Normalize degrees to 0-360 range
+  const normalized = ((degrees % 360) + 360) % 360;
+
+  if (
+    normalized !== 0 &&
+    normalized !== 90 &&
+    normalized !== 180 &&
+    normalized !== 270
+  ) {
+    throw new CameraError(
+      LocalizationManager.getString('validationDegreesInvalid'),
+      ERROR_CODES.INVALID_PARAMETER,
+      { parameter: 'degrees', value: degrees, validOptions: [0, 90, 180, 270] }
+    );
+  }
+}
+
+// Export constants for external use
+export const VALIDATION_CONSTANTS = {
+  MAX_IMAGE_SIZE,
+  MAX_VIDEO_SIZE,
+  MAX_ALBUM_NAME_LENGTH,
+  MAX_CAPTION_LENGTH,
+  MAX_BATCH_SIZE,
+} as const;