@umituz/react-native-ai-generation-content 1.12.20 → 1.12.23

package/src/domains/prompts/infrastructure/repositories/TemplateRepository.ts

@@ -5,73 +5,73 @@ import type { AIPromptCategory, AIPromptResult } from '../../domain/entities/typ
 export class TemplateRepository implements ITemplateRepository {
   private storage = new Map<string, AIPromptTemplate>();
 
-  async findById(id: string): Promise<AIPromptResult<AIPromptTemplate | null>> {
+  findById(id: string): Promise<AIPromptResult<AIPromptTemplate | null>> {
     try {
       const template = this.storage.get(id) || null;
-      return { success: true, data: template };
-    } catch (error) {
-      return { 
-        success: false, 
-        error: 'STORAGE_ERROR', 
-        message: 'Failed to retrieve template' 
-      };
+      return Promise.resolve({ success: true, data: template });
+    } catch {
+      return Promise.resolve({
+        success: false,
+        error: 'STORAGE_ERROR',
+        message: 'Failed to retrieve template'
+      });
     }
   }
 
-  async findByCategory(category: AIPromptCategory): Promise<AIPromptResult<AIPromptTemplate[]>> {
+  findByCategory(category: AIPromptCategory): Promise<AIPromptResult<AIPromptTemplate[]>> {
     try {
       const templates = Array.from(this.storage.values())
         .filter(template => template.category === category);
-      return { success: true, data: templates };
-    } catch (error) {
-      return { 
-        success: false, 
-        error: 'STORAGE_ERROR', 
-        message: 'Failed to retrieve templates by category' 
-      };
+      return Promise.resolve({ success: true, data: templates });
+    } catch {
+      return Promise.resolve({
+        success: false,
+        error: 'STORAGE_ERROR',
+        message: 'Failed to retrieve templates by category'
+      });
     }
   }
 
-  async findAll(): Promise<AIPromptResult<AIPromptTemplate[]>> {
+  findAll(): Promise<AIPromptResult<AIPromptTemplate[]>> {
     try {
       const templates = Array.from(this.storage.values());
-      return { success: true, data: templates };
-    } catch (error) {
-      return { 
-        success: false, 
-        error: 'STORAGE_ERROR', 
-        message: 'Failed to retrieve all templates' 
-      };
+      return Promise.resolve({ success: true, data: templates });
+    } catch {
+      return Promise.resolve({
+        success: false,
+        error: 'STORAGE_ERROR',
+        message: 'Failed to retrieve all templates'
+      });
     }
   }
 
-  async save(template: AIPromptTemplate): Promise<AIPromptResult<void>> {
+  save(template: AIPromptTemplate): Promise<AIPromptResult<void>> {
     try {
       this.storage.set(template.id, template);
-      return { success: true, data: undefined };
-    } catch (error) {
-      return { 
-        success: false, 
-        error: 'STORAGE_ERROR', 
-        message: 'Failed to save template' 
-      };
+      return Promise.resolve({ success: true, data: undefined });
+    } catch {
+      return Promise.resolve({
+        success: false,
+        error: 'STORAGE_ERROR',
+        message: 'Failed to save template'
+      });
     }
   }
 
-  async delete(id: string): Promise<AIPromptResult<void>> {
+  delete(id: string): Promise<AIPromptResult<void>> {
     try {
       this.storage.delete(id);
-      return { success: true, data: undefined };
-    } catch (error) {
-      return { 
-        success: false, 
-        error: 'STORAGE_ERROR', 
-        message: 'Failed to delete template' 
-      };
+      return Promise.resolve({ success: true, data: undefined });
+    } catch {
+      return Promise.resolve({
+        success: false,
+        error: 'STORAGE_ERROR',
+        message: 'Failed to delete template'
+      });
     }
   }
 
-  async exists(id: string): Promise<boolean> {
-    return this.storage.has(id);
+  exists(id: string): Promise<boolean> {
+    return Promise.resolve(this.storage.has(id));
   }
 }

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

@@ -83,24 +83,24 @@ export class BackgroundRemovalService implements IBackgroundRemovalService {
     this.promptService = new PromptGenerationService();
   }
 
-  async generateTemplate(config: BackgroundRemovalConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+  generateTemplate(config: BackgroundRemovalConfig): Promise<AIPromptResult<AIPromptTemplate>> {
     try {
       if (!this.validateConfig(config)) {
-        return {
+        return Promise.resolve({
           success: false,
           error: 'VALIDATION_ERROR',
           message: 'Invalid background removal configuration'
-        };
+        });
       }
 
       const template = this.createBackgroundRemovalTemplate(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 background removal template'
-      };
+      });
     }
   }
 

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

@@ -87,24 +87,24 @@ export class ColorizationService implements IColorizationService {
     this.promptService = new PromptGenerationService();
   }
 
-  async generateTemplate(config: ColorizationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+  generateTemplate(config: ColorizationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
     try {
       if (!this.validateConfig(config)) {
-        return {
+        return Promise.resolve({
           success: false,
           error: 'VALIDATION_ERROR',
           message: 'Invalid colorization configuration'
-        };
+        });
       }
 
       const template = this.createColorizationTemplate(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 colorization template'
-      };
+      });
     }
   }
 

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

@@ -1,10 +1,9 @@
 import type { IFaceSwapService } from '../../domain/repositories/IAIPromptServices';
-import type { 
+import type {
   AIPromptTemplate
 } from '../../domain/entities/AIPromptTemplate';
-import type { 
-  FaceSwapConfig, 
-  FaceSwapGenerationResult,
+import type {
+  FaceSwapConfig,
   FaceSwapSafety
 } from '../../domain/entities/FaceSwapConfig';
 import type { AIPromptCategory } from '../../domain/entities/types';
@@ -82,29 +81,29 @@ export class FaceSwapService implements IFaceSwapService {
     this.initializeDefaultStyles();
   }
 
-  async generateTemplate(config: FaceSwapConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+  generateTemplate(config: FaceSwapConfig): Promise<AIPromptResult<AIPromptTemplate>> {
     try {
       if (!this.validateConfig(config)) {
-        return { 
-          success: false, 
-          error: 'INVALID_VARIABLES', 
-          message: 'Invalid face swap configuration' 
-        };
+        return Promise.resolve({
+          success: false,
+          error: 'INVALID_VARIABLES',
+          message: 'Invalid face swap configuration'
+        });
       }
 
       const template = this.createFaceSwapTemplate(config);
-      return { success: true, data: template };
-    } catch (error) {
-      return { 
-        success: false, 
-        error: 'GENERATION_FAILED', 
-        message: 'Failed to generate face swap template' 
-      };
+      return Promise.resolve({ success: true, data: template });
+    } catch {
+      return Promise.resolve({
+        success: false,
+        error: 'GENERATION_FAILED',
+        message: 'Failed to generate face swap template'
+      });
     }
   }
 
   async generatePrompt(
-    template: AIPromptTemplate, 
+    template: AIPromptTemplate,
     config: FaceSwapConfig
   ): Promise<AIPromptResult<string>> {
     const variables = {
@@ -123,7 +122,7 @@ export class FaceSwapService implements IFaceSwapService {
     return validateFaceSwapConfig(config);
   }
 
-  async getAvailableStyles(): Promise<string[]> {
+  getAvailableStyles(): Promise<string[]> {
     return Promise.resolve([...this.availableStyles]);
   }
 
@@ -147,7 +146,7 @@ export class FaceSwapService implements IFaceSwapService {
 
   private createFaceSwapTemplate(config: FaceSwapConfig): AIPromptTemplate {
     const templateId = `face-swap-${config.styleName.toLowerCase().replace(/\s+/g, '-')}`;
-    
+
     return createAIPromptTemplate({
       id: templateId,
       name: `Face Swap: ${config.styleName}`,

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

@@ -12,6 +12,54 @@ import {
 } from '../../domain/entities/FuturePredictionConfig';
 import { PromptGenerationService } from './PromptGenerationService';
 
+/**
+ * Core preservation instruction for photorealistic couple/family transformations
+ */
+export const IDENTITY_INSTRUCTION = `CRITICAL PRESERVATION LOCK:
+{
+  "policy": "PRESERVE BOTH SUBJECTS' IDENTITIES & ENFORCE STRICT PHOTOREALISM",
+  "rule_1": "The output MUST depict the EXACT SAME TWO PEOPLE from the input photos.",
+  "rule_2": "STYLE: Always render as a HIGH-END PHOTOREALISTIC photograph. 8k resolution, cinematic lighting, ultra-detailed textures.",
+  "rule_3": "STRICTLY PROHIBITED: Anime, cartoons, illustrations, sketches, or 3D character renders. NO non-human stylization.",
+  "rule_4": "Preserve both persons' facial layouts, eye colors, skin tones, and unique features while placing them in the new scenario.",
+  "rule_5": "Both subjects must appear naturally together in the same frame with realistic proportions."
+}`;
+
+/**
+ * Creates a scenario transformation prompt with structured JSON-like format
+ */
+export const createScenarioPrompt = (
+    scenarioName: string,
+    subjectA: string,
+    subjectB: string,
+    costume: string,
+    environment: string,
+    additionalDetails?: string,
+) => `
+${IDENTITY_INSTRUCTION}
+
+TRANSFORMATION_REQUEST:
+{
+  "target_scenario": "${scenarioName}",
+  "subjects": {
+    "person_A": "${subjectA}",
+    "person_B": "${subjectB}"
+  },
+  "modifications": {
+    "appearance_update": "${costume.replace(/\n/g, " ").trim()}",
+    "environment_update": "${environment.replace(/\n/g, " ").trim()}"
+    ${additionalDetails ? `,"additional_details": "${additionalDetails.replace(/\n/g, " ").trim()}"` : ""}
+  },
+  "visual_constraints": {
+    "style_matching": "Render as a premium DSLR photograph",
+    "face_preservation": "Maintain 100% identity of BOTH persons from input photos",
+    "lighting": "Realistic professional studio or outdoor cinematic lighting",
+    "composition": "Both subjects prominently visible, natural poses"
+  }
+}
+
+FINAL COMMAND: Create a strictly photorealistic image of these two specific people in a ${scenarioName} scenario. No matter what the input style is, the result MUST be real-life looking people in a premium quality photograph.`;
+
 const IMAGE_PROMPT_TEMPLATE = `
 Generate a single high-quality, photorealistic image of {{subjectA}}{{#if subjectB}} and {{subjectB}}{{/if}}.
 Role/Relationship: {{subjectRole}}
@@ -48,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,
@@ -89,7 +137,7 @@ export class FuturePredictionService implements IFuturePredictionService {
                     generatedAt: Date.now(),
                 },
             },
-        };
+        });
     }
 
     validateConfig(config: FuturePredictionConfig): boolean {
@@ -123,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, '');
@@ -153,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'
-      };
+      });
     }
   }