@umituz/react-native-ai-generation-content 1.90.2 → 1.90.3

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.input-builder.ts

@@ -0,0 +1,90 @@
+/**
+ * Video Generation Strategy - Input Builder
+ * Builds video input from wizard data
+ */
+
+import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+import type { WizardVideoInput } from "./video-generation.types";
+import { VIDEO_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
+import { extractPrompt, extractDuration, extractAspectRatio, extractResolution, extractQualityMode } from "../utils";
+import { extractPhotosAsBase64 } from "./shared/photo-extraction.utils";
+import { extractAudioAsBase64 } from "./video-generation.audio-extractor";
+import { validatePhotoCount } from "./video-generation.validation";
+
+export async function buildVideoInput(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData,
+): Promise<WizardVideoInput | null> {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy] Building input", { scenarioId: scenario.id });
+  }
+
+  // Extract audio (shared by all code paths)
+  const audioUrl = await extractAudioAsBase64(wizardData);
+
+  // If a pre-generated image URL exists (e.g., two-step solo video),
+  // use it directly instead of extracting photos from wizard data
+  if (scenario.preGeneratedImageUrl) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[VideoStrategy] Using pre-generated image URL", {
+        url: scenario.preGeneratedImageUrl.slice(0, 80),
+        hasAudio: !!audioUrl,
+      });
+    }
+    const finalPrompt = extractPrompt(wizardData, scenario.aiPrompt) || scenario.aiPrompt || "";
+    const qualityMode = extractQualityMode(wizardData);
+
+    return {
+      sourceImageBase64: scenario.preGeneratedImageUrl,
+      prompt: finalPrompt,
+      duration: extractDuration(wizardData),
+      aspectRatio: extractAspectRatio(wizardData),
+      resolution: extractResolution(wizardData),
+      audioUrl,
+      qualityMode,
+    };
+  }
+
+  const photos = await extractPhotosAsBase64(wizardData, true);
+
+  const validation = validatePhotoCount(photos.length, scenario.inputType);
+  if (!validation.isValid) {
+    throw new Error(validation.errorKey ?? "error.generation.invalidInput");
+  }
+
+  let finalPrompt = extractPrompt(wizardData, scenario.aiPrompt);
+
+  if (!finalPrompt) {
+    const defaultPrompt = VIDEO_PROCESSING_PROMPTS[scenario.id];
+    if (defaultPrompt) {
+      finalPrompt = defaultPrompt;
+    } else {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[VideoStrategy] No prompt found for scenario:", scenario.id);
+        console.error("[VideoStrategy] Available defaults:", Object.keys(VIDEO_PROCESSING_PROMPTS));
+      }
+      throw new Error("error.generation.promptRequired");
+    }
+  }
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy] Using clean prompt for video generation", {
+      promptLength: finalPrompt.length,
+      photoCount: photos.length,
+      hasAudio: !!audioUrl,
+    });
+  }
+
+  const qualityMode = extractQualityMode(wizardData);
+
+  return {
+    sourceImageBase64: photos[0] || undefined,
+    targetImageBase64: photos[1] || photos[0] || undefined,
+    prompt: finalPrompt,
+    duration: extractDuration(wizardData),
+    aspectRatio: extractAspectRatio(wizardData),
+    resolution: extractResolution(wizardData),
+    audioUrl,
+    qualityMode,
+  };
+}

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.strategy.ts

@@ -4,116 +4,10 @@
  * Uses direct provider calls for generation models (text-to-video, image-to-video)
  */
 
-import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import type { WizardStrategy } from "./wizard-strategy.types";
-import { VIDEO_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
-import { extractPrompt, extractDuration, extractAspectRatio, extractResolution, extractQualityMode } from "../utils";
-import { extractPhotosAsBase64 } from "./shared/photo-extraction.utils";
-import type { WizardVideoInput, CreateVideoStrategyOptions } from "./video-generation.types";
-import { validatePhotoCount, validateWizardVideoInput } from "./video-generation.types";
+import type { CreateVideoStrategyOptions } from "./video-generation.types";
+import { validateWizardVideoInput } from "./video-generation.validation";
 import { executeVideoGeneration, submitVideoGenerationToQueue } from "./video-generation.executor";
-import { readFileAsBase64 } from "@umituz/react-native-design-system/filesystem";
-
-
-
-/**
- * Extract audio from wizardData and read as base64.
- * Audio step stores data as { uri: "file:///..." }.
- */
-async function extractAudioAsBase64(wizardData: Record<string, unknown>): Promise<string | undefined> {
-  const audioData = wizardData.background_audio as { uri?: string } | undefined;
-  if (!audioData?.uri) return undefined;
-
-  try {
-    const base64 = await readFileAsBase64(audioData.uri);
-    if (!base64) return undefined;
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[VideoStrategy] Audio extracted as base64", { length: base64.length });
-    }
-    return base64;
-  } catch (error) {
-    console.warn("[VideoStrategy] Failed to read audio file:", error);
-    return undefined;
-  }
-}
-
-export async function buildVideoInput(
-  wizardData: Record<string, unknown>,
-  scenario: WizardScenarioData,
-): Promise<WizardVideoInput | null> {
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy] Building input", { scenarioId: scenario.id });
-  }
-
-  // Extract audio (shared by all code paths)
-  const audioUrl = await extractAudioAsBase64(wizardData);
-
-  // If a pre-generated image URL exists (e.g., two-step solo video),
-  // use it directly instead of extracting photos from wizard data
-  if (scenario.preGeneratedImageUrl) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[VideoStrategy] Using pre-generated image URL", {
-        url: scenario.preGeneratedImageUrl.slice(0, 80),
-        hasAudio: !!audioUrl,
-      });
-    }
-    const finalPrompt = extractPrompt(wizardData, scenario.aiPrompt) || scenario.aiPrompt || "";
-    const qualityMode = extractQualityMode(wizardData);
-
-    return {
-      sourceImageBase64: scenario.preGeneratedImageUrl,
-      prompt: finalPrompt,
-      duration: extractDuration(wizardData),
-      aspectRatio: extractAspectRatio(wizardData),
-      resolution: extractResolution(wizardData),
-      audioUrl,
-      qualityMode,
-    };
-  }
-
-  const photos = await extractPhotosAsBase64(wizardData, true);
-
-  const validation = validatePhotoCount(photos.length, scenario.inputType);
-  if (!validation.isValid) {
-    throw new Error(validation.errorKey ?? "error.generation.invalidInput");
-  }
-
-  let finalPrompt = extractPrompt(wizardData, scenario.aiPrompt);
-
-  if (!finalPrompt) {
-    const defaultPrompt = VIDEO_PROCESSING_PROMPTS[scenario.id];
-    if (defaultPrompt) {
-      finalPrompt = defaultPrompt;
-    } else {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[VideoStrategy] No prompt found for scenario:", scenario.id);
-        console.error("[VideoStrategy] Available defaults:", Object.keys(VIDEO_PROCESSING_PROMPTS));
-      }
-      throw new Error("error.generation.promptRequired");
-    }
-  }
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy] Using clean prompt for video generation", {
-      promptLength: finalPrompt.length,
-      photoCount: photos.length,
-      hasAudio: !!audioUrl,
-    });
-  }
-
-  const qualityMode = extractQualityMode(wizardData);
-
-  return {
-    sourceImageBase64: photos[0] || undefined,
-    targetImageBase64: photos[1] || photos[0] || undefined,
-    prompt: finalPrompt,
-    duration: extractDuration(wizardData),
-    aspectRatio: extractAspectRatio(wizardData),
-    resolution: extractResolution(wizardData),
-    audioUrl,
-    qualityMode,
-  };
-}
 
 export function createVideoStrategy(options: CreateVideoStrategyOptions): WizardStrategy {
   const { scenario, modelConfig } = options;
@@ -153,3 +47,4 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
     },
   };
 }
+

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.types.ts

@@ -33,132 +33,3 @@ export interface CreateVideoStrategyOptions {
   /** Credit cost for this generation - REQUIRED, determined by the app */
   readonly creditCost: number;
 }
-
-interface PhotoValidationResult {
-  isValid: boolean;
-  errorKey?: string;
-}
-
-export function validatePhotoCount(
-  photoCount: number,
-  inputType: ScenarioInputType | undefined,
-): PhotoValidationResult {
-  const effectiveInputType = inputType ?? "single";
-
-  switch (effectiveInputType) {
-    case "dual":
-      if (photoCount < 2) {
-        return { isValid: false, errorKey: "error.generation.dualPhotosRequired" };
-      }
-      break;
-    case "single":
-      if (photoCount < 1) {
-        return { isValid: false, errorKey: "error.generation.photoRequired" };
-      }
-      break;
-    case "text":
-      break;
-    default: {
-      // Exhaustive check: log unexpected input types in development
-      const _exhaustive: never = effectiveInputType;
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.warn(`[validatePhotoCount] Unknown inputType: ${_exhaustive}`);
-      }
-      break;
-    }
-  }
-
-  return { isValid: true };
-}
-
-/**
- * Type guard for WizardVideoInput
- * Validates runtime input and provides type safety
- */
-function isWizardVideoInput(input: unknown): input is WizardVideoInput {
-  if (!input || typeof input !== "object") {
-    return false;
-  }
-
-  const obj = input as Record<string, unknown>;
-
-  // prompt is required
-  if (typeof obj.prompt !== "string" || obj.prompt.length === 0) {
-    return false;
-  }
-
-  // Optional fields validation
-  if (obj.sourceImageBase64 !== undefined && typeof obj.sourceImageBase64 !== "string") {
-    return false;
-  }
-
-  if (obj.targetImageBase64 !== undefined && typeof obj.targetImageBase64 !== "string") {
-    return false;
-  }
-
-  if (obj.duration !== undefined && typeof obj.duration !== "number") {
-    return false;
-  }
-
-  if (obj.aspectRatio !== undefined && typeof obj.aspectRatio !== "string") {
-    return false;
-  }
-
-  if (obj.resolution !== undefined && typeof obj.resolution !== "string") {
-    return false;
-  }
-
-  if (obj.audioUrl !== undefined && typeof obj.audioUrl !== "string") {
-    return false;
-  }
-
-  return true;
-}
-
-/**
- * Validates and casts input to WizardVideoInput
- * Throws descriptive error if validation fails
- */
-export function validateWizardVideoInput(input: unknown): WizardVideoInput {
-  if (!isWizardVideoInput(input)) {
-    const errors: string[] = [];
-
-    if (!input || typeof input !== "object") {
-      throw new Error("Invalid input: expected object");
-    }
-
-    const obj = input as Record<string, unknown>;
-
-    if (typeof obj.prompt !== "string" || obj.prompt.length === 0) {
-      errors.push("prompt (string, required)");
-    }
-
-    if (obj.sourceImageBase64 !== undefined && typeof obj.sourceImageBase64 !== "string") {
-      errors.push("sourceImageBase64 (string, optional)");
-    }
-
-    if (obj.targetImageBase64 !== undefined && typeof obj.targetImageBase64 !== "string") {
-      errors.push("targetImageBase64 (string, optional)");
-    }
-
-    if (obj.duration !== undefined && typeof obj.duration !== "number") {
-      errors.push("duration (number, optional)");
-    }
-
-    if (obj.aspectRatio !== undefined && typeof obj.aspectRatio !== "string") {
-      errors.push("aspectRatio (string, optional)");
-    }
-
-    if (obj.resolution !== undefined && typeof obj.resolution !== "string") {
-      errors.push("resolution (string, optional)");
-    }
-
-    if (obj.audioUrl !== undefined && typeof obj.audioUrl !== "string") {
-      errors.push("audioUrl (string, optional)");
-    }
-
-    throw new Error(`Invalid WizardVideoInput: ${errors.join(", ")}`);
-  }
-
-  return input;
-}

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.validation.ts

@@ -0,0 +1,136 @@
+/**
+ * Wizard Video Generation Validation
+ * Validation functions for video generation input
+ */
+
+import type { WizardVideoInput } from "./video-generation.types";
+import type { ScenarioInputType } from "../../../../scenarios/domain/Scenario";
+
+interface PhotoValidationResult {
+  isValid: boolean;
+  errorKey?: string;
+}
+
+export function validatePhotoCount(
+  photoCount: number,
+  inputType: ScenarioInputType | undefined,
+): PhotoValidationResult {
+  const effectiveInputType = inputType ?? "single";
+
+  switch (effectiveInputType) {
+    case "dual":
+      if (photoCount < 2) {
+        return { isValid: false, errorKey: "error.generation.dualPhotosRequired" };
+      }
+      break;
+    case "single":
+      if (photoCount < 1) {
+        return { isValid: false, errorKey: "error.generation.photoRequired" };
+      }
+      break;
+    case "text":
+      break;
+    default: {
+      // Exhaustive check: log unexpected input types in development
+      const _exhaustive: never = effectiveInputType;
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn(`[validatePhotoCount] Unknown inputType: ${_exhaustive}`);
+      }
+      break;
+    }
+  }
+
+  return { isValid: true };
+}
+
+/**
+ * Type guard for WizardVideoInput
+ * Validates runtime input and provides type safety
+ */
+function isWizardVideoInput(input: unknown): input is WizardVideoInput {
+  if (!input || typeof input !== "object") {
+    return false;
+  }
+
+  const obj = input as Record<string, unknown>;
+
+  // prompt is required
+  if (typeof obj.prompt !== "string" || obj.prompt.length === 0) {
+    return false;
+  }
+
+  // Optional fields validation
+  if (obj.sourceImageBase64 !== undefined && typeof obj.sourceImageBase64 !== "string") {
+    return false;
+  }
+
+  if (obj.targetImageBase64 !== undefined && typeof obj.targetImageBase64 !== "string") {
+    return false;
+  }
+
+  if (obj.duration !== undefined && typeof obj.duration !== "number") {
+    return false;
+  }
+
+  if (obj.aspectRatio !== undefined && typeof obj.aspectRatio !== "string") {
+    return false;
+  }
+
+  if (obj.resolution !== undefined && typeof obj.resolution !== "string") {
+    return false;
+  }
+
+  if (obj.audioUrl !== undefined && typeof obj.audioUrl !== "string") {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Validates and casts input to WizardVideoInput
+ * Throws descriptive error if validation fails
+ */
+export function validateWizardVideoInput(input: unknown): WizardVideoInput {
+  if (!isWizardVideoInput(input)) {
+    const errors: string[] = [];
+
+    if (!input || typeof input !== "object") {
+      throw new Error("Invalid input: expected object");
+    }
+
+    const obj = input as Record<string, unknown>;
+
+    if (typeof obj.prompt !== "string" || obj.prompt.length === 0) {
+      errors.push("prompt (string, required)");
+    }
+
+    if (obj.sourceImageBase64 !== undefined && typeof obj.sourceImageBase64 !== "string") {
+      errors.push("sourceImageBase64 (string, optional)");
+    }
+
+    if (obj.targetImageBase64 !== undefined && typeof obj.targetImageBase64 !== "string") {
+      errors.push("targetImageBase64 (string, optional)");
+    }
+
+    if (obj.duration !== undefined && typeof obj.duration !== "number") {
+      errors.push("duration (number, optional)");
+    }
+
+    if (obj.aspectRatio !== undefined && typeof obj.aspectRatio !== "string") {
+      errors.push("aspectRatio (string, optional)");
+    }
+
+    if (obj.resolution !== undefined && typeof obj.resolution !== "string") {
+      errors.push("resolution (string, optional)");
+    }
+
+    if (obj.audioUrl !== undefined && typeof obj.audioUrl !== "string") {
+      errors.push("audioUrl (string, optional)");
+    }
+
+    throw new Error(`Invalid WizardVideoInput: ${errors.join(", ")}`);
+  }
+
+  return input;
+}

package/src/domains/generation/wizard/presentation/hooks/photo-upload/index.ts

@@ -0,0 +1,39 @@
+/**
+ * Generic Photo Upload State Hook
+ * Manages photo upload state for wizard steps
+ * Uses design system's useMedia hook for media picking with built-in validation
+ */
+
+import { useState } from "react";
+import type { UsePhotoUploadStateProps, UsePhotoUploadStateReturn } from "./types";
+import { usePhotoUploadStateLogic } from "./usePhotoUploadStateLogic";
+
+export const usePhotoUploadState = ({
+  config,
+  translations,
+  initialImage,
+  stepId,
+  onError,
+}: UsePhotoUploadStateProps): UsePhotoUploadStateReturn => {
+  const [image, setImage] = useState<UploadedImage | null>(initialImage || null);
+
+  const { handlePickImage, clearImage, isLoading } = usePhotoUploadStateLogic(
+    config,
+    translations,
+    initialImage,
+    stepId,
+    onError,
+    setImage,
+  );
+
+  const canContinue = image !== null && !isLoading;
+
+  return {
+    image,
+    handlePickImage,
+    canContinue,
+    clearImage,
+  };
+};
+
+export type { PhotoUploadConfig, PhotoUploadTranslations, PhotoUploadError, UsePhotoUploadStateProps, UsePhotoUploadStateReturn } from "./types";

package/src/domains/generation/wizard/presentation/hooks/photo-upload/types.ts

@@ -0,0 +1,37 @@
+/**
+ * Generic Photo Upload State Hook - Type Definitions
+ */
+
+import type { UploadedImage } from "../../../../presentation/hooks/generation/useAIGenerateState";
+
+export interface PhotoUploadConfig {
+  readonly maxFileSizeMB?: number;
+}
+
+export interface PhotoUploadTranslations {
+  readonly fileTooLarge: string;
+  readonly maxFileSize: string;
+  readonly error: string;
+  readonly uploadFailed: string;
+  readonly permissionDenied?: string;
+}
+
+export interface PhotoUploadError {
+  readonly title: string;
+  readonly message: string;
+}
+
+export interface UsePhotoUploadStateProps {
+  readonly config?: PhotoUploadConfig;
+  readonly translations: PhotoUploadTranslations;
+  readonly initialImage?: UploadedImage;
+  readonly stepId?: string;
+  readonly onError?: (error: PhotoUploadError) => void;
+}
+
+export interface UsePhotoUploadStateReturn {
+  readonly image: UploadedImage | null;
+  readonly handlePickImage: () => Promise<void>;
+  readonly canContinue: boolean;
+  readonly clearImage: () => void;
+}

package/src/domains/generation/wizard/presentation/hooks/photo-upload/usePhotoUploadStateLogic.ts

@@ -0,0 +1,142 @@
+/**
+ * Generic Photo Upload State Hook - Core Logic
+ */
+
+import { useCallback, useRef, useEffect } from "react";
+import { useMedia, MediaQuality, MediaValidationError, MEDIA_CONSTANTS } from "@umituz/react-native-design-system/media";
+import type { UploadedImage } from "../../../../presentation/hooks/generation/useAIGenerateState";
+import type { PhotoUploadConfig, PhotoUploadError, PhotoUploadTranslations } from "./types";
+
+export function usePhotoUploadStateLogic(
+  config: PhotoUploadConfig | undefined,
+  translations: PhotoUploadTranslations,
+  initialImage: UploadedImage | undefined,
+  stepId: string | undefined,
+  onError: ((error: PhotoUploadError) => void) | undefined,
+  setImage: (image: UploadedImage | null) => void,
+) {
+  const { pickImage, isLoading } = useMedia();
+  const timeoutRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
+
+  // Use refs to avoid effect re-runs on callback changes
+  const onErrorRef = useRef(onError);
+  const translationsRef = useRef(translations);
+
+  useEffect(() => {
+    onErrorRef.current = onError;
+    translationsRef.current = translations;
+  }, [onError, translations]);
+
+  const maxFileSizeMB = config?.maxFileSizeMB ?? MEDIA_CONSTANTS.MAX_IMAGE_SIZE_MB;
+
+  useEffect(() => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[usePhotoUploadState] Step changed, resetting image", { stepId, hasInitialImage: !!initialImage });
+    }
+    setImage(initialImage || null);
+  }, [stepId, initialImage, setImage]);
+
+  useEffect(() => {
+    // Clear any existing timeout first
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = undefined;
+    }
+
+    if (isLoading) {
+      timeoutRef.current = setTimeout(() => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.warn("[usePhotoUploadState] Image picker timeout - possible stuck state (DEV warning only)");
+        }
+        // NOTE: Do NOT call onError here — the picker may still complete successfully.
+        // Showing a modal alert while the picker is open blocks the UI.
+      }, 30000);
+    }
+
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+        timeoutRef.current = undefined;
+      }
+    };
+  }, [isLoading]);
+
+  const clearImage = useCallback(() => {
+    setImage(null);
+  }, [setImage]);
+
+  const handlePickImage = useCallback(async () => {
+    try {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[usePhotoUploadState] Starting image pick");
+      }
+
+      const result = await pickImage({
+        allowsEditing: true,
+        aspect: [1, 1],
+        quality: MediaQuality.MEDIUM,
+        maxFileSizeMB,
+      });
+
+      if (result.error) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[usePhotoUploadState] Validation error", result.error);
+        }
+
+        if (result.error === MediaValidationError.FILE_TOO_LARGE) {
+          onErrorRef.current?.({
+            title: translationsRef.current.fileTooLarge,
+            message: translationsRef.current.maxFileSize.replace("{size}", maxFileSizeMB.toString()),
+          });
+        } else if (result.error === MediaValidationError.PERMISSION_DENIED) {
+          onErrorRef.current?.({
+            title: translationsRef.current.error,
+            message: translationsRef.current.permissionDenied ?? "Permission to access media library is required",
+          });
+        }
+        return;
+      }
+
+      if (result.canceled || !result.assets || result.assets.length === 0) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[usePhotoUploadState] Image pick canceled");
+        }
+        return;
+      }
+
+      const selectedAsset = result.assets[0];
+      if (!selectedAsset) {
+        return;
+      }
+
+      const uploadedImage: UploadedImage = {
+        uri: selectedAsset.uri,
+        previewUrl: selectedAsset.uri,
+        width: selectedAsset.width,
+        height: selectedAsset.height,
+        fileSize: selectedAsset.fileSize,
+      };
+
+      setImage(uploadedImage);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        const fileSizeMB = (selectedAsset.fileSize ?? 0) / (1024 * 1024);
+        console.log("[usePhotoUploadState] Image selected", {
+          width: uploadedImage.width,
+          height: uploadedImage.height,
+          fileSizeMB: fileSizeMB.toFixed(2),
+        });
+      }
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[usePhotoUploadState] Error picking image", error);
+      }
+      onErrorRef.current?.({
+        title: translationsRef.current.error,
+        message: translationsRef.current.uploadFailed,
+      });
+    }
+  }, [pickImage, maxFileSizeMB, setImage]);
+
+  return { handlePickImage, clearImage, isLoading };
+}