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

package/src/domains/prompts/infrastructure/services/FuturePredictionService.ts

@@ -96,36 +96,36 @@ export class FuturePredictionService implements IFuturePredictionService {
         this.promptService = new PromptGenerationService();
     }
 
-    async generateTemplate(
+    generateTemplate(
         config: FuturePredictionConfig
     ): Promise<AIPromptResult<AIPromptTemplate>> {
         if (!this.validateConfig(config)) {
-            return {
+            return Promise.resolve({
                 success: false,
                 error: 'VALIDATION_ERROR',
                 message: 'Invalid future prediction configuration',
-            };
+            });
         }
 
         const template = this.createTemplate(config);
-        return { success: true, data: template };
+        return Promise.resolve({ success: true, data: template });
     }
 
-    async generatePrompts(
+    generatePrompts(
         config: FuturePredictionConfig
     ): Promise<AIPromptResult<FuturePredictionResult>> {
         if (!this.validateConfig(config)) {
-            return {
+            return Promise.resolve({
                 success: false,
                 error: 'VALIDATION_ERROR',
                 message: 'Invalid configuration',
-            };
+            });
         }
 
         const imagePrompt = this.buildImagePrompt(config);
         const storyPrompt = this.buildStoryPrompt(config);
 
-        return {
+        return Promise.resolve({
             success: true,
             data: {
                 imagePrompt,
@@ -137,7 +137,7 @@ export class FuturePredictionService implements IFuturePredictionService {
                     generatedAt: Date.now(),
                 },
             },
-        };
+        });
     }
 
     validateConfig(config: FuturePredictionConfig): boolean {
@@ -171,10 +171,10 @@ export class FuturePredictionService implements IFuturePredictionService {
             .replace(/{{promptModifier}}/g, config.promptModifier)
             .replace(/{{futureYear}}/g, String(futureYear));
 
-        if (config.settings.language && config.settings.language !== 'en') {
+        if (config.settings.languageName) {
             prompt = prompt.replace(
                 /{{#if language}}(.*?){{\/if}}/g,
-                `$1`.replace(/{{language}}/g, this.getLanguageName(config.settings.language))
+                `$1`.replace(/{{language}}/g, config.settings.languageName)
             );
         } else {
             prompt = prompt.replace(/{{#if language}}.*?{{\/if}}/g, '');
@@ -201,24 +201,4 @@ export class FuturePredictionService implements IFuturePredictionService {
             version: '1.0.0',
         });
     }
-
-    private getLanguageName(code: string): string {
-        const languages: Record<string, string> = {
-            tr: 'Turkish',
-            es: 'Spanish',
-            fr: 'French',
-            de: 'German',
-            it: 'Italian',
-            pt: 'Portuguese',
-            ru: 'Russian',
-            ja: 'Japanese',
-            ko: 'Korean',
-            zh: 'Chinese',
-            ar: 'Arabic',
-            hi: 'Hindi',
-            th: 'Thai',
-            vi: 'Vietnamese',
-        };
-        return languages[code] || 'English';
-    }
 }

package/src/domains/prompts/infrastructure/services/ImageEnhancementService.ts

@@ -67,24 +67,24 @@ export class ImageEnhancementService implements IImageEnhancementService {
     this.promptService = new PromptGenerationService();
   }
 
-  async generateTemplate(config: ImageEnhancementConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+  generateTemplate(config: ImageEnhancementConfig): Promise<AIPromptResult<AIPromptTemplate>> {
     try {
       if (!this.validateConfig(config)) {
-        return {
+        return Promise.resolve({
           success: false,
           error: 'VALIDATION_ERROR',
           message: 'Invalid image enhancement configuration'
-        };
+        });
       }
 
       const template = this.createImageEnhancementTemplate(config);
-      return { success: true, data: template };
-    } catch (error) {
-      return {
+      return Promise.resolve({ success: true, data: template });
+    } catch {
+      return Promise.resolve({
         success: false,
         error: 'GENERATION_FAILED',
         message: 'Failed to generate image enhancement template'
-      };
+      });
     }
   }
 

package/src/domains/prompts/infrastructure/services/PhotoRestorationService.ts

@@ -59,24 +59,24 @@ export class PhotoRestorationService implements IPhotoRestorationService {
     this.promptService = new PromptGenerationService();
   }
 
-  async generateTemplate(config: PhotoRestorationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+  generateTemplate(config: PhotoRestorationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
     try {
       if (!this.validateConfig(config)) {
-        return {
+        return Promise.resolve({
           success: false,
           error: 'VALIDATION_ERROR',
           message: 'Invalid photo restoration configuration'
-        };
+        });
       }
 
       const template = this.createPhotoRestorationTemplate(config);
-      return { success: true, data: template };
-    } catch (error) {
-      return {
+      return Promise.resolve({ success: true, data: template });
+    } catch {
+      return Promise.resolve({
         success: false,
         error: 'GENERATION_FAILED',
         message: 'Failed to generate photo restoration template'
-      };
+      });
     }
   }
 

package/src/domains/prompts/infrastructure/services/PromptGenerationService.ts

@@ -1,10 +1,10 @@
 import type { IPromptGenerationService } from '../../domain/repositories/IAIPromptServices';
 import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
-import type { AIPromptResult, AIPromptError } from '../../domain/entities/types';
+import type { AIPromptResult } from '../../domain/entities/types';
 
 export class PromptGenerationService implements IPromptGenerationService {
   generateFromTemplate(
-    template: AIPromptTemplate, 
+    template: AIPromptTemplate,
     variables: Record<string, unknown>
   ): Promise<AIPromptResult<string>> {
     return new Promise((resolve) => {
@@ -18,25 +18,25 @@ export class PromptGenerationService implements IPromptGenerationService {
         const generatedText = this.replaceTemplateVariables(template.template, variables);
         resolve({ success: true, data: generatedText });
       } catch (error) {
-        resolve({ 
-          success: false, 
-          error: 'GENERATION_FAILED', 
-          message: 'Failed to generate prompt' 
+        resolve({
+          success: false,
+          error: 'GENERATION_FAILED',
+          message: 'Failed to generate prompt'
         });
       }
     });
   }
 
   validateVariables(
-    template: AIPromptTemplate, 
+    template: AIPromptTemplate,
     variables: Record<string, unknown>
   ): AIPromptResult<void> {
     for (const variable of template.variables) {
       if (variable.required && !(variable.name in variables)) {
-        return { 
-          success: false, 
-          error: 'INVALID_VARIABLES', 
-          message: `Required variable ${variable.name} is missing` 
+        return {
+          success: false,
+          error: 'INVALID_VARIABLES',
+          message: `Required variable ${variable.name} is missing`
         };
       }
     }
@@ -44,11 +44,11 @@ export class PromptGenerationService implements IPromptGenerationService {
   }
 
   replaceTemplateVariables(
-    template: string, 
+    template: string,
     variables: Record<string, unknown>
   ): string {
     let result = template;
-    
+
     Object.entries(variables).forEach(([key, value]) => {
       const regex = new RegExp(`\\$\\{${key}\\}`, 'g');
       result = result.replace(regex, String(value || ''));

package/src/domains/prompts/infrastructure/services/StyleTransferService.ts

@@ -72,24 +72,24 @@ export class StyleTransferService implements IStyleTransferService {
     this.initializeDefaultStyles();
   }
 
-  async generateTemplate(config: StyleTransferConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+  generateTemplate(config: StyleTransferConfig): Promise<AIPromptResult<AIPromptTemplate>> {
     try {
       if (!this.validateConfig(config)) {
-        return {
+        return Promise.resolve({
           success: false,
           error: 'VALIDATION_ERROR',
           message: 'Invalid style transfer configuration'
-        };
+        });
       }
 
       const template = this.createStyleTransferTemplate(config);
-      return { success: true, data: template };
-    } catch (error) {
-      return {
+      return Promise.resolve({ success: true, data: template });
+    } catch {
+      return Promise.resolve({
         success: false,
         error: 'GENERATION_FAILED',
         message: 'Failed to generate style transfer template'
-      };
+      });
     }
   }
 
@@ -114,7 +114,7 @@ export class StyleTransferService implements IStyleTransferService {
     return validateStyleTransferConfig(config);
   }
 
-  async getAvailableStyles(): Promise<string[]> {
+  getAvailableStyles(): Promise<string[]> {
     return Promise.resolve([...this.availableStyles]);
   }
 

package/src/domains/prompts/infrastructure/services/TextGenerationService.ts

@@ -72,24 +72,24 @@ export class TextGenerationService implements ITextGenerationService {
     this.promptService = new PromptGenerationService();
   }
 
-  async generateTemplate(config: TextGenerationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+  generateTemplate(config: TextGenerationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
     try {
       if (!this.validateConfig(config)) {
-        return {
+        return Promise.resolve({
           success: false,
           error: 'VALIDATION_ERROR',
           message: 'Invalid text generation configuration'
-        };
+        });
       }
 
       const template = this.createTextGenerationTemplate(config);
-      return { success: true, data: template };
-    } catch (error) {
-      return {
+      return Promise.resolve({ success: true, data: template });
+    } catch {
+      return Promise.resolve({
         success: false,
         error: 'GENERATION_FAILED',
         message: 'Failed to generate text template'
-      };
+      });
     }
   }
 

package/src/domains/prompts/presentation/hooks/useAIServices.ts

@@ -1,26 +1,26 @@
 import { useState, useCallback } from 'react';
-import type { 
+import type {
   FaceSwapConfig
 } from '../../domain/entities/FaceSwapConfig';
-import type { 
+import type {
   PhotoRestorationConfig
 } from '../../domain/entities/PhotoRestorationConfig';
-import type { 
+import type {
   ImageEnhancementConfig
 } from '../../domain/entities/ImageEnhancementConfig';
-import type { 
+import type {
   StyleTransferConfig
 } from '../../domain/entities/StyleTransferConfig';
-import type { 
+import type {
   BackgroundRemovalConfig
 } from '../../domain/entities/BackgroundRemovalConfig';
-import type { 
+import type {
   TextGenerationConfig
 } from '../../domain/entities/TextGenerationConfig';
-import type { 
+import type {
   ColorizationConfig
 } from '../../domain/entities/ColorizationConfig';
-import type { 
+import type {
   IFaceSwapService,
   IPhotoRestorationService,
   IImageEnhancementService,
@@ -34,8 +34,10 @@ import type { IPromptHistoryRepository } from '../../domain/repositories/IPrompt
 import type { GeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
 import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
 import { useAsyncState } from './useAsyncState';
+import type { AIPromptResult } from '../../domain/entities/types';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
 
-export type AIConfig = 
+export type AIConfig =
   | { type: 'face-swap'; config: FaceSwapConfig }
   | { type: 'photo-restoration'; config: PhotoRestorationConfig }
   | { type: 'image-enhancement'; config: ImageEnhancementConfig }
@@ -86,11 +88,11 @@ export const useAIServices = (
   const processRequest = useCallback(async (aiConfig: AIConfig): Promise<void> => {
     clearError();
     setCurrentService(aiConfig.type);
-    
+
     try {
-      let templateResult;
-      let promptResult;
-      
+      let templateResult: AIPromptResult<AIPromptTemplate> | undefined;
+      let promptResult: AIPromptResult<string> | undefined;
+
       switch (aiConfig.type) {
         case 'face-swap':
           templateResult = await services.faceSwap.generateTemplate(aiConfig.config);
@@ -98,74 +100,74 @@ export const useAIServices = (
             promptResult = await services.faceSwap.generatePrompt(templateResult.data, aiConfig.config);
           }
           break;
-          
+
         case 'photo-restoration':
           templateResult = await services.photoRestoration.generateTemplate(aiConfig.config);
           if (templateResult.success && templateResult.data) {
             promptResult = await services.photoRestoration.generatePrompt(templateResult.data, aiConfig.config);
           }
           break;
-          
+
         case 'image-enhancement':
           templateResult = await services.imageEnhancement.generateTemplate(aiConfig.config);
           if (templateResult.success && templateResult.data) {
             promptResult = await services.imageEnhancement.generatePrompt(templateResult.data, aiConfig.config);
           }
           break;
-          
+
         case 'style-transfer':
           templateResult = await services.styleTransfer.generateTemplate(aiConfig.config);
           if (templateResult.success && templateResult.data) {
             promptResult = await services.styleTransfer.generatePrompt(templateResult.data, aiConfig.config);
           }
           break;
-          
+
         case 'background-removal':
           templateResult = await services.backgroundRemoval.generateTemplate(aiConfig.config);
           if (templateResult.success && templateResult.data) {
             promptResult = await services.backgroundRemoval.generatePrompt(templateResult.data, aiConfig.config);
           }
           break;
-          
+
         case 'text-generation':
           templateResult = await services.textGeneration.generateTemplate(aiConfig.config);
           if (templateResult.success && templateResult.data) {
             promptResult = await services.textGeneration.generatePrompt(templateResult.data, aiConfig.config);
           }
           break;
-          
+
         case 'colorization':
           templateResult = await services.colorization.generateTemplate(aiConfig.config);
           if (templateResult.success && templateResult.data) {
             promptResult = await services.colorization.generatePrompt(templateResult.data, aiConfig.config);
           }
           break;
-          
+
         default:
           setError('Unknown AI service type');
           return;
       }
-      
+
       if (!templateResult?.success || !templateResult.data) {
         setError('Failed to generate template');
         return;
       }
-      
-      if (!promptResult?.success) {
+
+      if (!promptResult?.success || !promptResult.data) {
         setError('Failed to generate prompt');
         return;
       }
-      
+
       const newPrompt = createGeneratedPrompt({
         templateId: templateResult.data.id,
         generatedText: promptResult.data,
         variables: aiConfig.config as unknown as Record<string, unknown>,
       });
-      
+
       await repositories.history.save(newPrompt);
       setGeneratedPrompt(newPrompt);
-      
-    } catch (error) {
+
+    } catch {
       setError('An unexpected error occurred');
     } finally {
       setCurrentService(null);
@@ -182,7 +184,7 @@ export const useAIServices = (
         default:
           return [];
       }
-    } catch (error) {
+    } catch {
       setError('Failed to load available styles');
       return [];
     }

package/src/domains/prompts/presentation/hooks/useFaceSwap.ts

@@ -3,7 +3,6 @@ import type { FaceSwapConfig, FaceSwapGenerationResult } from '../../domain/enti
 import type { IFaceSwapService } from '../../domain/repositories/IAIPromptServices';
 import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
 import type { IPromptHistoryRepository } from '../../domain/repositories/IPromptHistoryRepository';
-import type { GeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
 import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
 import { useAsyncState } from './useAsyncState';
 
@@ -35,7 +34,7 @@ export const useFaceSwap = (
 
   const generateFaceSwapPrompt = useCallback(async (config: FaceSwapConfig): Promise<void> => {
     clearError();
-    
+
     try {
       const templateResult = await faceSwapService.generateTemplate(config);
       if (!templateResult.success || !templateResult.data) {

package/src/domains/prompts/presentation/hooks/usePromptGeneration.ts

@@ -1,5 +1,4 @@
 import { useState, useCallback } from 'react';
-import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
 import type { IPromptGenerationService } from '../../domain/repositories/IAIPromptServices';
 import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
 import type { IPromptHistoryRepository } from '../../domain/repositories/IPromptHistoryRepository';
@@ -43,7 +42,7 @@ export const usePromptGeneration = (
   const generatePrompt = useCallback(
     async (templateId: string, variables: Record<string, unknown>): Promise<void> => {
       clearError();
-      
+
       try {
         const templateResult = await templateRepository.findById(templateId);
         if (!templateResult.success || !templateResult.data) {
@@ -69,8 +68,8 @@ export const usePromptGeneration = (
 
         await historyRepository.save(newPrompt);
         setGeneratedPrompt(newPrompt);
-        
-        await loadHistory(50);
+
+        void loadHistory(50);
       } catch (error) {
         setError('An unexpected error occurred');
       }
@@ -110,7 +109,7 @@ export const usePromptGeneration = (
       clearError();
       try {
         await historyRepository.save(prompt);
-        await loadHistory(50);
+        void loadHistory(50);
       } catch (error) {
         setError('Failed to save to history');
       }

package/src/domains/prompts/presentation/hooks/useStyleTransfer.ts

@@ -109,7 +109,7 @@ export const useStyleTransfer = (
   }, [setResult, clearError]);
 
   useEffect(() => {
-    getAvailableStyles();
+    void getAvailableStyles();
   }, [getAvailableStyles]);
 
   return {

package/src/domains/prompts/presentation/hooks/useTemplateRepository.ts

@@ -1,6 +1,6 @@
 import { useState, useCallback } from 'react';
 import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
-import type { AIPromptCategory, AIPromptResult } from '../../domain/entities/types';
+import type { AIPromptCategory } from '../../domain/entities/types';
 import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
 import { useAsyncState } from './useAsyncState';
 
@@ -77,7 +77,7 @@ export const useTemplateRepository = (
     const result = await repository.save(template);
 
     if (result.success) {
-      loadAllTemplates();
+      void loadAllTemplates();
     } else {
       setError(('message' in result && result.message) || 'Failed to save template');
     }
@@ -91,7 +91,7 @@ export const useTemplateRepository = (
       if (currentTemplate?.id === id) {
         setCurrentTemplate(null);
       }
-      loadAllTemplates();
+      void loadAllTemplates();
     } else {
       setError(('message' in result && result.message) || 'Failed to delete template');
     }

package/src/domains/prompts/presentation/theme/utils.ts

@@ -1,7 +1,7 @@
 import type { Theme } from './types';
 import { useTheme } from './theme';
 
-export const createStyleSheet = <T extends Record<string, any>>(
+export const createStyleSheet = <T extends Record<string, unknown>>(
   styles: (theme: Theme) => T
 ): T => {
   const theme = useTheme();

package/src/features/audio-generation/domain/entities.ts

@@ -0,0 +1,39 @@
+/**
+ * Audio Generation Domain Entities
+ */
+
+export interface AudioGenerationConfig {
+    /**
+     * Duration of the audio in seconds
+     */
+    duration?: number;
+
+    /**
+     * Voice ID or style
+     */
+    voiceId?: string;
+}
+
+export interface AudioGenerationRequest {
+    /**
+     * The text prompt or description for audio generation
+     */
+    prompt: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: AudioGenerationConfig;
+}
+
+export interface AudioGenerationResult {
+    /**
+     * The generated audio file URL
+     */
+    audioUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

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

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

package/src/features/audio-generation/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 { 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,
+    };
+};