@umituz/react-native-ai-feature-background 1.0.0

package/src/presentation/hooks/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Presentation Hooks Export
+ */
+
+export { useBackgroundFeature } from "./useBackgroundFeature";
+
+export type { UseBackgroundFeatureReturn } from "./useBackgroundFeature";

package/src/presentation/hooks/useBackgroundFeature.ts

@@ -0,0 +1,111 @@
+/**
+ * useBackgroundFeature Hook
+ * @description Main hook for background feature state and actions
+ */
+
+import { useCallback, useState } from "react";
+import type {
+    BackgroundFeatureState,
+    BackgroundProcessResult,
+    UseBackgroundFeatureConfig,
+} from "../../domain/entities";
+
+export interface UseBackgroundFeatureReturn extends BackgroundFeatureState {
+    readonly selectImage: () => Promise<void>;
+    readonly process: (prompt?: string) => Promise<void>;
+    readonly save: () => Promise<void>;
+    readonly reset: () => void;
+    readonly setPrompt: (prompt: string) => void;
+}
+
+export function useBackgroundFeature(
+    config: UseBackgroundFeatureConfig
+): UseBackgroundFeatureReturn {
+    const [imageUri, setImageUri] = useState<string | null>(null);
+    const [prompt, setPrompt] = useState<string>("");
+    const [processedUrl, setProcessedUrl] = useState<string | null>(null);
+    const [isProcessing, setIsProcessing] = useState(false);
+    const [progress, setProgress] = useState(0);
+    const [error, setError] = useState<string | null>(null);
+
+    const selectImage = useCallback(async (): Promise<void> => {
+        if (!config.onSelectImage) {
+            return;
+        }
+
+        try {
+            const uri = await config.onSelectImage();
+            if (uri) {
+                setImageUri(uri);
+                setError(null);
+                setProcessedUrl(null);
+            }
+        } catch (err) {
+            setError(err instanceof Error ? err.message : "Failed to select image");
+        }
+    }, [config]);
+
+    const process = useCallback(
+        async (newPrompt?: string): Promise<void> => {
+            if (!imageUri) {
+                setError("Please select an image first");
+                return;
+            }
+
+            const currentPrompt = newPrompt ?? prompt;
+            setIsProcessing(true);
+            setProgress(0);
+            setError(null);
+
+            try {
+                const result: BackgroundProcessResult = await config.processRequest({
+                    imageUri,
+                    prompt: currentPrompt,
+                    onProgress: setProgress,
+                });
+
+                if (result.success && result.imageUrl) {
+                    setProcessedUrl(result.imageUrl);
+                } else {
+                    setError(result.error || "Processing failed");
+                }
+            } catch (err) {
+                setError(err instanceof Error ? err.message : "Processing failed");
+            } finally {
+                setIsProcessing(false);
+                setProgress(0);
+            }
+        },
+        [imageUri, prompt, config]
+    );
+
+    const save = useCallback(async (): Promise<void> => {
+        if (!processedUrl) {
+            return;
+        }
+        // Save logic is handled by parent component via config
+    }, [processedUrl]);
+
+    const reset = useCallback((): void => {
+        setImageUri(null);
+        setPrompt("");
+        setProcessedUrl(null);
+        setIsProcessing(false);
+        setProgress(0);
+        setError(null);
+    }, []);
+
+    return {
+        imageUri,
+        prompt,
+        processedUrl,
+        isProcessing,
+        progress,
+        error,
+        selectImage,
+        process,
+        save,
+        reset,
+        setPrompt,
+    };
+}