@umituz/react-native-ai-generation-content 1.12.21 → 1.12.24

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

@@ -0,0 +1,39 @@
+/* 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/domain/entities.ts

@@ -0,0 +1,48 @@
+/**
+ * Photo Restoration Domain Entities
+ */
+
+export interface PhotoRestorationConfig {
+    /**
+     * Whether to fix scratches and creases
+     * @default true
+     */
+    fixScratches?: boolean;
+
+    /**
+     * Whether to enhance faces in the photo
+     * @default true
+     */
+    enhanceFaces?: boolean;
+
+    /**
+     * Upscale factor for the result
+     * @default 2
+     */
+    upscaleFactor?: 1 | 2 | 4;
+}
+
+export interface PhotoRestorationRequest {
+    /**
+     * The image to restore.
+     * Can be a Base64 string or a remote URL.
+     */
+    image: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: PhotoRestorationConfig;
+}
+
+export interface PhotoRestorationResult {
+    /**
+     * The restored image URL or Base64
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

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

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

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

@@ -0,0 +1,39 @@
+/* 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/domain/entities.ts

@@ -0,0 +1,47 @@
+/**
+ * Sketch to Image Domain Entities
+ */
+
+export interface SketchToImageConfig {
+    /**
+     * Strength of the prompt influence vs sketch influence (0.0 to 1.0)
+     * @default 0.7
+     */
+    strength?: number;
+
+    /**
+     * Steps for generation
+     * @default 20
+     */
+    steps?: number;
+}
+
+export interface SketchToImageRequest {
+    /**
+     * The sketch image.
+     * Can be a Base64 string or a remote URL.
+     */
+    sketchImage: string;
+
+    /**
+     * Description of the desired output
+     */
+    prompt: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: SketchToImageConfig;
+}
+
+export interface SketchToImageResult {
+    /**
+     * The generated realistic image URL
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

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

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

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

@@ -0,0 +1,39 @@
+/* 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/domain/entities.ts

@@ -0,0 +1,52 @@
+/**
+ * Style Transfer Domain Entities
+ */
+
+export interface StyleTransferConfig {
+    /**
+     * Strength of the style application (0.0 to 1.0)
+     * @default 1.0
+     */
+    strength?: number;
+
+    /**
+     * Preserve original colors
+     * @default false
+     */
+    preserveColor?: boolean;
+}
+
+export interface StyleTransferRequest {
+    /**
+     * The content image to apply style TO.
+     * Can be a Base64 string or a remote URL.
+     */
+    contentImage: string;
+
+    /**
+     * The style image references (Base64 or URL)
+     */
+    styleImage?: string;
+
+    /**
+     * Or a preset style ID (e.g. "van_gogh_starry_night")
+     */
+    stylePreset?: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: StyleTransferConfig;
+}
+
+export interface StyleTransferResult {
+    /**
+     * The stylized image URL or Base64
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

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

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

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

@@ -0,0 +1,39 @@
+/* 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/domain/entities.ts

@@ -0,0 +1,58 @@
+/**
+ * Text-to-Image Domain Entities
+ */
+
+export interface TextToImageConfig {
+    /**
+     * Width of the generated image
+     * @default 1024
+     */
+    width?: number;
+
+    /**
+     * Height of the generated image
+     * @default 1024
+     */
+    height?: number;
+
+    /**
+     * Number of inference steps
+     * @default 30
+     */
+    steps?: number;
+
+    /**
+     * Guidance scale
+     * @default 7.5
+     */
+    guidanceScale?: number;
+}
+
+export interface TextToImageRequest {
+    /**
+     * The description of the image to generate
+     */
+    prompt: string;
+
+    /**
+     * Negative prompt for what to avoid
+     */
+    negativePrompt?: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: TextToImageConfig;
+}
+
+export interface TextToImageResult {
+    /**
+     * The generated image URL or Base64
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

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

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

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

@@ -0,0 +1,39 @@
+/* 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/domain/entities.ts

@@ -0,0 +1,52 @@
+/**
+ * Text to Video Domain Entities
+ */
+
+export interface TextToVideoConfig {
+    /**
+     * Duration of the video in seconds
+     * @default 4
+     */
+    duration?: number;
+
+    /**
+     * FPS of the generated video
+     * @default 24
+     */
+    fps?: number;
+
+    /**
+     * Guidance scale
+     * @default 7.5
+     */
+    guidanceScale?: number;
+}
+
+export interface TextToVideoRequest {
+    /**
+     * The text prompt to generate video from
+     */
+    prompt: string;
+
+    /**
+     * Negative prompt
+     */
+    negativePrompt?: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: TextToVideoConfig;
+}
+
+export interface TextToVideoResult {
+    /**
+     * The generated video URL
+     */
+    videoUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

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

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

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

@@ -0,0 +1,39 @@
+/* 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/domain/entities.ts

@@ -0,0 +1,42 @@
+/**
+ * Upscaling Domain Entities
+ */
+
+export interface UpscaleConfig {
+    /**
+     * The factor to upscale the image by
+     * @default 2
+     */
+    scaleFactor?: 2 | 4;
+
+    /**
+     * Whether to enhance faces during upscaling
+     * @default false
+     */
+    enhanceFaces?: boolean;
+}
+
+export interface UpscaleRequest {
+    /**
+     * The image to upscale.
+     * Can be a Base64 string or a remote URL.
+     */
+    image: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: UpscaleConfig;
+}
+
+export interface UpscaleResult {
+    /**
+     * The upscaled image URL or Base64
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/upscaling/index.ts

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

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

@@ -0,0 +1,39 @@
+/* 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,
+    };
+};

package/src/index.ts

@@ -234,11 +234,6 @@ export * from "./domains/prompts";
 
 export * from "./domains/content-moderation";
 
-// =============================================================================
-// DOMAINS - AI Creations
-// =============================================================================
-
-export * from "./domains/creations";
 
 // =============================================================================
 // DOMAINS - Face Detection
@@ -250,4 +245,6 @@ export * from "./domains/face-detection";
 // DOMAINS - Feature Background
 // =============================================================================
 
-export * from "./domains/feature-background";
+export * from "./features/background";
+
+

package/src/infrastructure/utils/status-checker.util.ts

@@ -34,7 +34,7 @@ export function checkStatusForErrors(
   const logs = Array.isArray((status as JobStatus)?.logs)
     ? (status as JobStatus).logs
     : [];
-  const errorLogs = (logs as AILogEntry[]).filter((log) => {
+  const errorLogs = logs.filter((log) => {
     const level = String(log?.level || "").toUpperCase();
     return level === "ERROR" || level === "FATAL";
   });
@@ -44,9 +44,9 @@ export function checkStatusForErrors(
   const errorLogMessage =
     errorLogs.length > 0
       ? (errorLogs[0] as AILogEntry & { text?: string; content?: string })
-          ?.message ||
-        (errorLogs[0] as AILogEntry & { text?: string })?.text ||
-        (errorLogs[0] as AILogEntry & { content?: string })?.content
+        ?.message ||
+      (errorLogs[0] as AILogEntry & { text?: string })?.text ||
+      (errorLogs[0] as AILogEntry & { content?: string })?.content
       : undefined;
 
   // Combine error messages

package/src/infrastructure/wrappers/synchronous-generation.wrapper.ts

@@ -13,13 +13,13 @@ export interface SynchronousGenerationInput {
   userId?: string;
   type?: string;
   languageCode?: string;
-  metadata?: Record<string, any>;
+  metadata?: Record<string, unknown>;
 }
 
-export interface SynchronousGenerationConfig<T = any> {
+export interface SynchronousGenerationConfig<T = unknown> {
   checkCredits?: (userId: string, type: string) => Promise<boolean>;
   deductCredits?: (userId: string, type: string) => Promise<void>;
-  execute: (prompt: string, metadata?: Record<string, any>) => Promise<T>;
+  execute: (prompt: string, metadata?: Record<string, unknown>) => Promise<T>;
 }
 
 export async function generateSynchronously<T = string>(