@umituz/react-native-ai-generation-content 1.15.0 → 1.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.15.0",
+  "version": "1.15.1",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/features/audio-generation/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/colorization/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/face-swap/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/future-prediction/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/image-captioning/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/inpainting/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/photo-restoration/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/sketch-to-image/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/style-transfer/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/text-to-image/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/text-to-video/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/upscaling/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/presentation/hooks/base/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Base Feature Hooks
+ * Provider-agnostic hooks for AI image processing features
+ */
+
+export * from "./types";
+export * from "./use-single-image-feature";
+export * from "./use-dual-image-feature";
+export * from "./use-image-with-prompt-feature";

package/src/presentation/hooks/base/types.ts

@@ -0,0 +1,47 @@
+/**
+ * Base Feature Hook Types
+ * Provider-agnostic types for feature hooks
+ */
+
+/**
+ * Result from AI processing
+ */
+export interface FeatureProcessResult {
+  readonly success: boolean;
+  readonly outputUrl?: string;
+  readonly error?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Base state shared by all feature hooks
+ */
+export interface BaseFeatureState {
+  readonly isProcessing: boolean;
+  readonly progress: number;
+  readonly error: string | null;
+  readonly processedUrl: string | null;
+}
+
+/**
+ * Base actions shared by all feature hooks
+ */
+export interface BaseFeatureActions {
+  readonly reset: () => void;
+  readonly clearError: () => void;
+}
+
+/**
+ * Progress callback type
+ */
+export type OnProgressCallback = (progress: number) => void;
+
+/**
+ * Image selection callback - provided by app
+ */
+export type OnSelectImageCallback = () => Promise<string | null>;
+
+/**
+ * Save callback - provided by app
+ */
+export type OnSaveCallback = (url: string) => Promise<void>;

package/src/presentation/hooks/base/use-dual-image-feature.ts

@@ -0,0 +1,178 @@
+/**
+ * useDualImageFeature Hook
+ * Provider-agnostic hook for dual image processing features
+ * Examples: AI Hug, AI Kiss, Face Swap
+ */
+
+import { useCallback, useState } from "react";
+import type {
+  BaseFeatureState,
+  BaseFeatureActions,
+  FeatureProcessResult,
+  OnProgressCallback,
+  OnSelectImageCallback,
+  OnSaveCallback,
+} from "./types";
+
+/**
+ * Request passed to processRequest callback
+ */
+export interface DualImageProcessRequest {
+  readonly firstImageUri: string;
+  readonly secondImageUri: string;
+  readonly onProgress: OnProgressCallback;
+}
+
+/**
+ * Configuration for dual image feature
+ */
+export interface UseDualImageFeatureConfig {
+  readonly onSelectFirstImage: OnSelectImageCallback;
+  readonly onSelectSecondImage: OnSelectImageCallback;
+  readonly processRequest: (
+    request: DualImageProcessRequest
+  ) => Promise<FeatureProcessResult>;
+  readonly onSave?: OnSaveCallback;
+  readonly onError?: (error: string) => void;
+  readonly onSuccess?: (url: string) => void;
+}
+
+/**
+ * State for dual image feature
+ */
+export interface DualImageFeatureState extends BaseFeatureState {
+  readonly firstImageUri: string | null;
+  readonly secondImageUri: string | null;
+}
+
+/**
+ * Return type for dual image feature hook
+ */
+export interface UseDualImageFeatureReturn
+  extends DualImageFeatureState,
+    BaseFeatureActions {
+  readonly selectFirstImage: () => Promise<void>;
+  readonly selectSecondImage: () => Promise<void>;
+  readonly process: () => Promise<void>;
+  readonly save: () => Promise<void>;
+}
+
+export function useDualImageFeature(
+  config: UseDualImageFeatureConfig
+): UseDualImageFeatureReturn {
+  const [firstImageUri, setFirstImageUri] = useState<string | null>(null);
+  const [secondImageUri, setSecondImageUri] = useState<string | null>(null);
+  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 selectFirstImage = useCallback(async (): Promise<void> => {
+    try {
+      const uri = await config.onSelectFirstImage();
+      if (uri) {
+        setFirstImageUri(uri);
+        setError(null);
+        setProcessedUrl(null);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.selectImage";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [config]);
+
+  const selectSecondImage = useCallback(async (): Promise<void> => {
+    try {
+      const uri = await config.onSelectSecondImage();
+      if (uri) {
+        setSecondImageUri(uri);
+        setError(null);
+        setProcessedUrl(null);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.selectImage";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [config]);
+
+  const process = useCallback(async (): Promise<void> => {
+    if (!firstImageUri || !secondImageUri) {
+      const message = "error.noImages";
+      setError(message);
+      config.onError?.(message);
+      return;
+    }
+
+    setIsProcessing(true);
+    setProgress(0);
+    setError(null);
+
+    try {
+      const result = await config.processRequest({
+        firstImageUri,
+        secondImageUri,
+        onProgress: setProgress,
+      });
+
+      if (result.success && result.outputUrl) {
+        setProcessedUrl(result.outputUrl);
+        config.onSuccess?.(result.outputUrl);
+      } else {
+        const message = result.error || "error.processing";
+        setError(message);
+        config.onError?.(message);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.processing";
+      setError(message);
+      config.onError?.(message);
+    } finally {
+      setIsProcessing(false);
+      setProgress(0);
+    }
+  }, [firstImageUri, secondImageUri, config]);
+
+  const save = useCallback(async (): Promise<void> => {
+    if (!processedUrl || !config.onSave) {
+      return;
+    }
+
+    try {
+      await config.onSave(processedUrl);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.save";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [processedUrl, config]);
+
+  const reset = useCallback((): void => {
+    setFirstImageUri(null);
+    setSecondImageUri(null);
+    setProcessedUrl(null);
+    setIsProcessing(false);
+    setProgress(0);
+    setError(null);
+  }, []);
+
+  const clearError = useCallback((): void => {
+    setError(null);
+  }, []);
+
+  return {
+    firstImageUri,
+    secondImageUri,
+    processedUrl,
+    isProcessing,
+    progress,
+    error,
+    selectFirstImage,
+    selectSecondImage,
+    process,
+    save,
+    reset,
+    clearError,
+  };
+}

package/src/presentation/hooks/base/use-image-with-prompt-feature.ts

@@ -0,0 +1,170 @@
+/**
+ * useImageWithPromptFeature Hook
+ * Provider-agnostic hook for image + prompt processing features
+ * Examples: Inpainting, Style Transfer, Background Replacement
+ */
+
+import { useCallback, useState } from "react";
+import type {
+  BaseFeatureState,
+  BaseFeatureActions,
+  FeatureProcessResult,
+  OnProgressCallback,
+  OnSelectImageCallback,
+  OnSaveCallback,
+} from "./types";
+
+/**
+ * Request passed to processRequest callback
+ */
+export interface ImageWithPromptProcessRequest {
+  readonly imageUri: string;
+  readonly prompt: string;
+  readonly onProgress: OnProgressCallback;
+}
+
+/**
+ * Configuration for image with prompt feature
+ */
+export interface UseImageWithPromptFeatureConfig {
+  readonly onSelectImage: OnSelectImageCallback;
+  readonly processRequest: (
+    request: ImageWithPromptProcessRequest
+  ) => Promise<FeatureProcessResult>;
+  readonly onSave?: OnSaveCallback;
+  readonly onError?: (error: string) => void;
+  readonly onSuccess?: (url: string) => void;
+  readonly requirePrompt?: boolean;
+}
+
+/**
+ * State for image with prompt feature
+ */
+export interface ImageWithPromptFeatureState extends BaseFeatureState {
+  readonly imageUri: string | null;
+  readonly prompt: string;
+}
+
+/**
+ * Return type for image with prompt feature hook
+ */
+export interface UseImageWithPromptFeatureReturn
+  extends ImageWithPromptFeatureState,
+    BaseFeatureActions {
+  readonly selectImage: () => Promise<void>;
+  readonly setPrompt: (prompt: string) => void;
+  readonly process: () => Promise<void>;
+  readonly save: () => Promise<void>;
+}
+
+export function useImageWithPromptFeature(
+  config: UseImageWithPromptFeatureConfig
+): UseImageWithPromptFeatureReturn {
+  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> => {
+    try {
+      const uri = await config.onSelectImage();
+      if (uri) {
+        setImageUri(uri);
+        setError(null);
+        setProcessedUrl(null);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.selectImage";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [config]);
+
+  const process = useCallback(async (): Promise<void> => {
+    if (!imageUri) {
+      const message = "error.noImage";
+      setError(message);
+      config.onError?.(message);
+      return;
+    }
+
+    if (config.requirePrompt && !prompt.trim()) {
+      const message = "error.noPrompt";
+      setError(message);
+      config.onError?.(message);
+      return;
+    }
+
+    setIsProcessing(true);
+    setProgress(0);
+    setError(null);
+
+    try {
+      const result = await config.processRequest({
+        imageUri,
+        prompt: prompt.trim(),
+        onProgress: setProgress,
+      });
+
+      if (result.success && result.outputUrl) {
+        setProcessedUrl(result.outputUrl);
+        config.onSuccess?.(result.outputUrl);
+      } else {
+        const message = result.error || "error.processing";
+        setError(message);
+        config.onError?.(message);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.processing";
+      setError(message);
+      config.onError?.(message);
+    } finally {
+      setIsProcessing(false);
+      setProgress(0);
+    }
+  }, [imageUri, prompt, config]);
+
+  const save = useCallback(async (): Promise<void> => {
+    if (!processedUrl || !config.onSave) {
+      return;
+    }
+
+    try {
+      await config.onSave(processedUrl);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.save";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [processedUrl, config]);
+
+  const reset = useCallback((): void => {
+    setImageUri(null);
+    setPrompt("");
+    setProcessedUrl(null);
+    setIsProcessing(false);
+    setProgress(0);
+    setError(null);
+  }, []);
+
+  const clearError = useCallback((): void => {
+    setError(null);
+  }, []);
+
+  return {
+    imageUri,
+    prompt,
+    processedUrl,
+    isProcessing,
+    progress,
+    error,
+    selectImage,
+    setPrompt,
+    process,
+    save,
+    reset,
+    clearError,
+  };
+}

package/src/presentation/hooks/base/use-single-image-feature.ts

@@ -0,0 +1,154 @@
+/**
+ * useSingleImageFeature Hook
+ * Provider-agnostic hook for single image processing features
+ * App provides processRequest callback with their AI provider
+ */
+
+import { useCallback, useState } from "react";
+import type {
+  BaseFeatureState,
+  BaseFeatureActions,
+  FeatureProcessResult,
+  OnProgressCallback,
+  OnSelectImageCallback,
+  OnSaveCallback,
+} from "./types";
+
+/**
+ * Request passed to processRequest callback
+ */
+export interface SingleImageProcessRequest {
+  readonly imageUri: string;
+  readonly onProgress: OnProgressCallback;
+}
+
+/**
+ * Configuration for single image feature
+ */
+export interface UseSingleImageFeatureConfig {
+  readonly onSelectImage: OnSelectImageCallback;
+  readonly processRequest: (
+    request: SingleImageProcessRequest
+  ) => Promise<FeatureProcessResult>;
+  readonly onSave?: OnSaveCallback;
+  readonly onError?: (error: string) => void;
+  readonly onSuccess?: (url: string) => void;
+}
+
+/**
+ * State for single image feature
+ */
+export interface SingleImageFeatureState extends BaseFeatureState {
+  readonly imageUri: string | null;
+}
+
+/**
+ * Return type for single image feature hook
+ */
+export interface UseSingleImageFeatureReturn
+  extends SingleImageFeatureState,
+    BaseFeatureActions {
+  readonly selectImage: () => Promise<void>;
+  readonly process: () => Promise<void>;
+  readonly save: () => Promise<void>;
+}
+
+export function useSingleImageFeature(
+  config: UseSingleImageFeatureConfig
+): UseSingleImageFeatureReturn {
+  const [imageUri, setImageUri] = useState<string | null>(null);
+  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> => {
+    try {
+      const uri = await config.onSelectImage();
+      if (uri) {
+        setImageUri(uri);
+        setError(null);
+        setProcessedUrl(null);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.selectImage";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [config]);
+
+  const process = useCallback(async (): Promise<void> => {
+    if (!imageUri) {
+      const message = "error.noImage";
+      setError(message);
+      config.onError?.(message);
+      return;
+    }
+
+    setIsProcessing(true);
+    setProgress(0);
+    setError(null);
+
+    try {
+      const result = await config.processRequest({
+        imageUri,
+        onProgress: setProgress,
+      });
+
+      if (result.success && result.outputUrl) {
+        setProcessedUrl(result.outputUrl);
+        config.onSuccess?.(result.outputUrl);
+      } else {
+        const message = result.error || "error.processing";
+        setError(message);
+        config.onError?.(message);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.processing";
+      setError(message);
+      config.onError?.(message);
+    } finally {
+      setIsProcessing(false);
+      setProgress(0);
+    }
+  }, [imageUri, config]);
+
+  const save = useCallback(async (): Promise<void> => {
+    if (!processedUrl || !config.onSave) {
+      return;
+    }
+
+    try {
+      await config.onSave(processedUrl);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "error.save";
+      setError(message);
+      config.onError?.(message);
+    }
+  }, [processedUrl, config]);
+
+  const reset = useCallback((): void => {
+    setImageUri(null);
+    setProcessedUrl(null);
+    setIsProcessing(false);
+    setProgress(0);
+    setError(null);
+  }, []);
+
+  const clearError = useCallback((): void => {
+    setError(null);
+  }, []);
+
+  return {
+    imageUri,
+    processedUrl,
+    isProcessing,
+    progress,
+    error,
+    selectImage,
+    process,
+    save,
+    reset,
+    clearError,
+  };
+}

package/src/presentation/hooks/index.ts

@@ -2,6 +2,9 @@
  * Presentation Hooks
  */
 
+// Base Feature Hooks (Provider-Agnostic)
+export * from "./base";
+
 export { useGeneration } from "./use-generation";
 export type {
   UseGenerationOptions,

package/src/features/audio-generation/presentation/hooks.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { AudioGenerationRequest, AudioGenerationResult } from '../domain/entities';
-
-export interface UseAudioGenerationReturn {
-    generateAudio: (request: AudioGenerationRequest) => Promise<AudioGenerationResult>;
-    isGenerating: boolean;
-    result: AudioGenerationResult | null;
-    error: Error | null;
-}
-
-export const useAudioGeneration = (): UseAudioGenerationReturn => {
-    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
-    const [result, setResult] = useState<AudioGenerationResult | null>(null);
-
-    const generateAudio = useCallback(async (request: AudioGenerationRequest) => {
-        await generate(request as any);
-
-        if (genResult?.data) {
-            setResult(genResult.data as AudioGenerationResult);
-            return genResult.data as AudioGenerationResult;
-        }
-
-        throw new Error('Audio generation failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        generateAudio,
-        isGenerating,
-        result,
-        error: error as any,
-    };
-};

package/src/features/colorization/presentation/hooks.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { ColorizationRequest, ColorizationResult } from '../domain/entities';
-
-export interface UseColorizationReturn {
-    colorize: (request: ColorizationRequest) => Promise<ColorizationResult>;
-    isColorizing: boolean;
-    result: ColorizationResult | null;
-    error: Error | null;
-}
-
-export const useColorization = (): UseColorizationReturn => {
-    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
-    const [result, setResult] = useState<ColorizationResult | null>(null);
-
-    const colorize = useCallback(async (request: ColorizationRequest) => {
-        await generate(request as any);
-
-        if (genResult?.data) {
-            setResult(genResult.data as ColorizationResult);
-            return genResult.data as ColorizationResult;
-        }
-
-        throw new Error('Colorization failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        colorize,
-        isColorizing: isGenerating,
-        result,
-        error: error as any,
-    };
-};

package/src/features/face-swap/presentation/hooks.ts

@@ -1,41 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { FaceSwapRequest, FaceSwapResult } from '../domain/entities';
-
-export interface UseFaceSwapReturn {
-    swapFace: (request: FaceSwapRequest) => Promise<FaceSwapResult>;
-    isSwapping: boolean;
-    result: FaceSwapResult | null;
-    error: Error | null;
-}
-
-export const useFaceSwap = (): UseFaceSwapReturn => {
-    // @ts-ignore - Deprecated feature, kept for backward compatibility
-    const { generate, isGenerating, error, result: genResult } = useGeneration<FaceSwapResult>({ model: 'face-swap' });
-    const [result, setResult] = useState<FaceSwapResult | null>(null);
-
-    const swapFace = useCallback(async (request: FaceSwapRequest) => {
-        // @ts-ignore - Deprecated feature
-        await generate(request);
-
-        if (genResult?.data) {
-            setResult(genResult.data as FaceSwapResult);
-            return genResult.data as FaceSwapResult;
-        }
-
-        throw new Error('Face swap failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        swapFace,
-        isSwapping: isGenerating,
-        result,
-        error: error as any,
-    };
-};

package/src/features/future-prediction/presentation/hooks.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { FuturePredictionRequest, FuturePredictionResult } from '../domain/entities';
-
-export interface UseFuturePredictionReturn {
-    predictFuture: (request: FuturePredictionRequest) => Promise<FuturePredictionResult>;
-    isPredicting: boolean;
-    result: FuturePredictionResult | null;
-    error: Error | null;
-}
-
-export const useFuturePrediction = (): UseFuturePredictionReturn => {
-    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
-    const [result, setResult] = useState<FuturePredictionResult | null>(null);
-
-    const predictFuture = useCallback(async (request: FuturePredictionRequest) => {
-        await generate(request as any);
-
-        if (genResult?.data) {
-            setResult(genResult.data as FuturePredictionResult);
-            return genResult.data as FuturePredictionResult;
-        }
-
-        throw new Error('Future prediction failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        predictFuture,
-        isPredicting: isGenerating,
-        result,
-        error: error as any,
-    };
-};

package/src/features/image-captioning/presentation/hooks.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { ImageCaptioningRequest, ImageCaptioningResult } from '../domain/entities';
-
-export interface UseImageCaptioningReturn {
-    generateCaption: (request: ImageCaptioningRequest) => Promise<ImageCaptioningResult>;
-    isGenerating: boolean;
-    result: ImageCaptioningResult | null;
-    error: Error | null;
-}
-
-export const useImageCaptioning = (): UseImageCaptioningReturn => {
-    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
-    const [result, setResult] = useState<ImageCaptioningResult | null>(null);
-
-    const generateCaption = useCallback(async (request: ImageCaptioningRequest) => {
-        await generate(request as any);
-
-        if (genResult?.data) {
-            setResult(genResult.data as ImageCaptioningResult);
-            return genResult.data as ImageCaptioningResult;
-        }
-
-        throw new Error('Caption generation failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        generateCaption,
-        isGenerating,
-        result,
-        error: error as any,
-    };
-};

package/src/features/inpainting/presentation/hooks.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { InpaintingRequest, InpaintingResult } from '../domain/entities';
-
-export interface UseInpaintingReturn {
-    inpaint: (request: InpaintingRequest) => Promise<InpaintingResult>;
-    isInpainting: boolean;
-    result: InpaintingResult | null;
-    error: Error | null;
-}
-
-export const useInpainting = (): UseInpaintingReturn => {
-    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
-    const [result, setResult] = useState<InpaintingResult | null>(null);
-
-    const inpaint = useCallback(async (request: InpaintingRequest) => {
-        await generate(request as any);
-
-        if (genResult?.data) {
-            setResult(genResult.data as InpaintingResult);
-            return genResult.data as InpaintingResult;
-        }
-
-        throw new Error('Inpainting failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        inpaint,
-        isInpainting: isGenerating,
-        result,
-        error: error as any,
-    };
-};

package/src/features/photo-restoration/presentation/hooks.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { PhotoRestorationRequest, PhotoRestorationResult } from '../domain/entities';
-
-export interface UsePhotoRestorationReturn {
-    restorePhoto: (request: PhotoRestorationRequest) => Promise<PhotoRestorationResult>;
-    isRestoring: boolean;
-    result: PhotoRestorationResult | null;
-    error: Error | null;
-}
-
-export const usePhotoRestoration = (): UsePhotoRestorationReturn => {
-    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
-    const [result, setResult] = useState<PhotoRestorationResult | null>(null);
-
-    const restorePhoto = useCallback(async (request: PhotoRestorationRequest) => {
-        await generate(request as any);
-
-        if (genResult?.data) {
-            setResult(genResult.data as PhotoRestorationResult);
-            return genResult.data as PhotoRestorationResult;
-        }
-
-        throw new Error('Photo restoration failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        restorePhoto,
-        isRestoring: isGenerating,
-        result,
-        error: error as any,
-    };
-};

package/src/features/sketch-to-image/presentation/hooks.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { SketchToImageRequest, SketchToImageResult } from '../domain/entities';
-
-export interface UseSketchToImageReturn {
-    generateFromSketch: (request: SketchToImageRequest) => Promise<SketchToImageResult>;
-    isGenerating: boolean;
-    result: SketchToImageResult | null;
-    error: Error | null;
-}
-
-export const useSketchToImage = (): UseSketchToImageReturn => {
-    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
-    const [result, setResult] = useState<SketchToImageResult | null>(null);
-
-    const generateFromSketch = useCallback(async (request: SketchToImageRequest) => {
-        await generate(request as any);
-
-        if (genResult?.data) {
-            setResult(genResult.data as SketchToImageResult);
-            return genResult.data as SketchToImageResult;
-        }
-
-        throw new Error('Sketch to image generation failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        generateFromSketch,
-        isGenerating,
-        result,
-        error: error as any,
-    };
-};

package/src/features/style-transfer/presentation/hooks.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { StyleTransferRequest, StyleTransferResult } from '../domain/entities';
-
-export interface UseStyleTransferReturn {
-    transferStyle: (request: StyleTransferRequest) => Promise<StyleTransferResult>;
-    isTransferring: boolean;
-    result: StyleTransferResult | null;
-    error: Error | null;
-}
-
-export const useStyleTransfer = (): UseStyleTransferReturn => {
-    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
-    const [result, setResult] = useState<StyleTransferResult | null>(null);
-
-    const transferStyle = useCallback(async (request: StyleTransferRequest) => {
-        await generate(request as any);
-
-        if (genResult?.data) {
-            setResult(genResult.data as StyleTransferResult);
-            return genResult.data as StyleTransferResult;
-        }
-
-        throw new Error('Style transfer failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        transferStyle,
-        isTransferring: isGenerating,
-        result,
-        error: error as any,
-    };
-};

package/src/features/text-to-image/presentation/hooks.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { TextToImageRequest, TextToImageResult } from '../domain/entities';
-
-export interface UseTextToImageReturn {
-    generateImage: (request: TextToImageRequest) => Promise<TextToImageResult>;
-    isGenerating: boolean;
-    result: TextToImageResult | null;
-    error: Error | null;
-}
-
-export const useTextToImage = (): UseTextToImageReturn => {
-    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
-    const [result, setResult] = useState<TextToImageResult | null>(null);
-
-    const generateImage = useCallback(async (request: TextToImageRequest) => {
-        await generate(request as any);
-
-        if (genResult?.data) {
-            setResult(genResult.data as TextToImageResult);
-            return genResult.data as TextToImageResult;
-        }
-
-        throw new Error('Image generation failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        generateImage,
-        isGenerating,
-        result,
-        error: error as any,
-    };
-};

package/src/features/text-to-video/presentation/hooks.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { TextToVideoRequest, TextToVideoResult } from '../domain/entities';
-
-export interface UseTextToVideoReturn {
-    generateVideo: (request: TextToVideoRequest) => Promise<TextToVideoResult>;
-    isGenerating: boolean;
-    result: TextToVideoResult | null;
-    error: Error | null;
-}
-
-export const useTextToVideo = (): UseTextToVideoReturn => {
-    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
-    const [result, setResult] = useState<TextToVideoResult | null>(null);
-
-    const generateVideo = useCallback(async (request: TextToVideoRequest) => {
-        await generate(request as any);
-
-        if (genResult?.data) {
-            setResult(genResult.data as TextToVideoResult);
-            return genResult.data as TextToVideoResult;
-        }
-
-        throw new Error('Video generation failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        generateVideo,
-        isGenerating,
-        result,
-        error: error as any,
-    };
-};

package/src/features/upscaling/presentation/hooks.ts

@@ -1,39 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { useState, useCallback } from 'react';
-import { useGeneration } from '../../../presentation/hooks/use-generation';
-import { UpscaleRequest, UpscaleResult } from '../domain/entities';
-
-export interface UseUpscalingReturn {
-    upscale: (request: UpscaleRequest) => Promise<UpscaleResult>;
-    isUpscaling: boolean;
-    result: UpscaleResult | null;
-    error: Error | null;
-}
-
-export const useUpscaling = (): UseUpscalingReturn => {
-    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
-    const [result, setResult] = useState<UpscaleResult | null>(null);
-
-    const upscale = useCallback(async (request: UpscaleRequest) => {
-        await generate(request as any);
-
-        if (genResult?.data) {
-            setResult(genResult.data as UpscaleResult);
-            return genResult.data as UpscaleResult;
-        }
-
-        throw new Error('Upscaling failed to return a result');
-    }, [generate, genResult]);
-
-    return {
-        upscale,
-        isUpscaling: isGenerating,
-        result,
-        error: error as any,
-    };
-};