@umituz/react-native-ai-generation-content 1.17.169 → 1.17.171

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

@@ -1,113 +1,46 @@
+/**
+ * Style Transfer Service
+ * AI prompt generation for artistic style transfer
+ */
+
 import type { IStyleTransferService } from '../../domain/repositories/IAIPromptServices';
-import type {
-  StyleTransferConfig,
-} from '../../domain/entities/StyleTransferConfig';
+import type { StyleTransferConfig } from '../../domain/entities/StyleTransferConfig';
 import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
-import type { AIPromptResult } from '../../domain/entities/types';
-import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
-import {
-  validateStyleTransferConfig,
-  getStyleStrengthValue,
-  getArtisticModeDescription
-} from '../../domain/entities/StyleTransferConfig';
-import { PromptGenerationService } from '../services/PromptGenerationService';
-
-const createStyleTransferBaseTemplate = (config?: {
-  artisticMode?: string;
-  preserveContent?: boolean;
-}): string => {
-  const {
-    artisticMode = 'artistic',
-    preserveContent = true
-  } = config || {};
-
-  return `
+import { validateStyleTransferConfig, getStyleStrengthValue } from '../../domain/entities/StyleTransferConfig';
+import { BasePromptService } from './base';
+
+const BASE_TEMPLATE = `
 You are an expert AI style transfer specialist.
 This is a STYLE TRANSFER task, applying artistic styles while maintaining content.
 
-STYLE TRANSFER PRINCIPLES:
+PRINCIPLES:
 - Apply target artistic style to the image
-- ${preserveContent ? 'Preserve original content and composition' : 'Allow creative reinterpretation'}
 - Maintain key features and subject recognition
 - Balance artistic expression with clarity
 
-ARTISTIC MODE: ${artisticMode}
-${getArtisticModeDescription(artisticMode as StyleTransferConfig['artisticMode'])}
-
-STYLE APPLICATION GUIDELINES:
-- Recognize and preserve important elements
-- Apply consistent style throughout the image
-- Maintain appropriate color relationships
-- Preserve facial features and expressions when present
-
-TECHNICAL REQUIREMENTS:
+TECHNICAL:
 - Smooth style transitions across the image
 - Appropriate detail preservation based on style
-- Consistent artistic treatment
 - Professional quality output
 
-CONTENT PRESERVATION:
-${preserveContent ?
-      '- Maintain key shapes and forms\n- Preserve facial features and expressions\n- Keep text readable if present\n- Maintain spatial relationships' :
-      '- Allow creative transformation\n- Artistic interpretation encouraged\n- Style over content fidelity'}
-
-SAFETY CONSTRAINTS:
+SAFETY:
 - Do not add inappropriate elements
-- Maintain appropriate content standards
 - Preserve important visual information
-- Avoid destructive transformations
-
-OUTPUT:
-A beautifully stylized image with the target artistic style,
-${preserveContent ? 'maintaining content integrity' : 'with artistic freedom'}.
-  `.trim();
-};
-
-export class StyleTransferService implements IStyleTransferService {
-  private promptService: PromptGenerationService;
-  private availableStyles: string[] = [];
-
-  constructor() {
-    this.promptService = new PromptGenerationService();
-    this.initializeDefaultStyles();
-  }
+`.trim();
 
-  generateTemplate(config: StyleTransferConfig): Promise<AIPromptResult<AIPromptTemplate>> {
-    try {
-      if (!this.validateConfig(config)) {
-        return Promise.resolve({
-          success: false,
-          error: 'VALIDATION_ERROR',
-          message: 'Invalid style transfer configuration'
-        });
-      }
-
-      const template = this.createStyleTransferTemplate(config);
-      return Promise.resolve({ success: true, data: template });
-    } catch {
-      return Promise.resolve({
-        success: false,
-        error: 'GENERATION_FAILED',
-        message: 'Failed to generate style transfer template'
-      });
-    }
-  }
+const DEFAULT_STYLES = [
+  'Impressionism', 'Cubism', 'Surrealism', 'Pop Art', 'Watercolor',
+  'Oil Painting', 'Pencil Sketch', 'Anime/Manga', 'Vintage Film', 'Cyberpunk',
+];
 
-  async generatePrompt(
-    template: AIPromptTemplate,
-    config: StyleTransferConfig
-  ): Promise<AIPromptResult<string>> {
-    const variables = {
-      targetStyle: config.targetStyle,
-      preserveContent: config.preserveContent,
-      styleStrength: config.styleStrength,
-      artisticMode: config.artisticMode,
-      maintainColors: config.maintainColors,
-      adaptToSubject: config.adaptToSubject,
-      strengthLevel: getStyleStrengthValue(config.styleStrength),
-    };
+export class StyleTransferService
+  extends BasePromptService<StyleTransferConfig>
+  implements IStyleTransferService
+{
+  private availableStyles: string[] = [...DEFAULT_STYLES];
 
-    return this.promptService.generateFromTemplate(template, variables);
+  protected getServiceName(): string {
+    return 'style transfer';
   }
 
   validateConfig(config: StyleTransferConfig): boolean {
@@ -125,70 +58,37 @@ export class StyleTransferService implements IStyleTransferService {
   }
 
   registerStyles(styles: string[]): void {
-    styles.forEach(style => this.registerStyle(style));
+    styles.forEach((s) => this.registerStyle(s));
   }
 
-  private initializeDefaultStyles(): void {
-    this.availableStyles = [
-      'Impressionism',
-      'Cubism',
-      'Surrealism',
-      'Pop Art',
-      'Watercolor',
-      'Oil Painting',
-      'Pencil Sketch',
-      'Anime/Manga',
-      'Vintage Film',
-      'Cyberpunk',
-      'Steampunk',
-    ];
+  protected buildVariables(config: StyleTransferConfig): Record<string, unknown> {
+    return {
+      targetStyle: config.targetStyle,
+      preserveContent: config.preserveContent,
+      styleStrength: config.styleStrength,
+      artisticMode: config.artisticMode,
+      maintainColors: config.maintainColors,
+      adaptToSubject: config.adaptToSubject,
+      strengthLevel: getStyleStrengthValue(config.styleStrength),
+    };
   }
 
-  private createStyleTransferTemplate(config: StyleTransferConfig): AIPromptTemplate {
-    const templateId = `style-transfer-${config.targetStyle.toLowerCase().replace(/\s+/g, '-')}`;
-
-    const baseTemplate = createStyleTransferBaseTemplate({
-      artisticMode: config.artisticMode,
-      preserveContent: config.preserveContent,
-    });
+  protected createTemplate(config: StyleTransferConfig): AIPromptTemplate {
+    const styleId = config.targetStyle.toLowerCase().replace(/\s+/g, '-');
+    const strength = getStyleStrengthValue(config.styleStrength);
 
-    return createAIPromptTemplate({
-      id: templateId,
+    return this.createTemplateWithDefaults({
+      id: `style-transfer-${styleId}`,
       name: `Style Transfer: ${config.targetStyle}`,
-      description: `Apply ${config.targetStyle} artistic style with ${config.artisticMode} mode`,
+      description: `Apply ${config.targetStyle} style with ${config.artisticMode} mode`,
       category: 'style-transfer',
-      template: `${baseTemplate}
-
-TARGET STYLE:
-${config.targetStyle}
-
-STYLE TRANSFER PARAMETERS:
-- Style Strength: ${getStyleStrengthValue(config.styleStrength)} (${Math.round(config.styleStrength * 100)}%)
-- Artistic Mode: ${config.artisticMode}
-- Preserve Content: ${config.preserveContent}
-- Maintain Colors: ${config.maintainColors}
-- Adapt to Subject: ${config.adaptToSubject}
-
-STYLE APPLICATION INSTRUCTIONS:
-Apply ${config.targetStyle} style with ${config.artisticMode} interpretation,
-using ${getStyleStrengthValue(config.styleStrength)} strength level.
-${config.preserveContent ? 'Focus on preserving content integrity while applying style.' : 'Allow artistic interpretation and transformation.'}
-${config.maintainColors ? 'Maintain original color palette where appropriate.' : 'Allow color changes to enhance style.'}
-
-EXPECTED RESULT:
-A beautifully stylized image in ${config.targetStyle} style,
-with ${config.artisticMode} artistic interpretation,
-using ${getStyleStrengthValue(config.styleStrength)} strength application.
-      `.trim(),
-      variables: [],
-      safety: {
-        contentFilter: true,
-        adultContentFilter: true,
-        violenceFilter: true,
-        hateSpeechFilter: true,
-        copyrightFilter: true,
-      },
-      version: '1.0.0',
+      template: `${BASE_TEMPLATE}
+
+STYLE: ${config.targetStyle}
+MODE: ${config.artisticMode}
+STRENGTH: ${strength} (${Math.round(config.styleStrength * 100)}%)
+PRESERVE CONTENT: ${config.preserveContent}
+MAINTAIN COLORS: ${config.maintainColors}`,
     });
   }
-}
+}

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

@@ -1,114 +1,41 @@
+/**
+ * Text Generation Service
+ * AI prompt generation for text content creation
+ */
+
 import type { ITextGenerationService } from '../../domain/repositories/IAIPromptServices';
-import type {
-  TextGenerationConfig,
-} from '../../domain/entities/TextGenerationConfig';
+import type { TextGenerationConfig } from '../../domain/entities/TextGenerationConfig';
 import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
-import type { AIPromptResult } from '../../domain/entities/types';
-import { createAIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
 import {
   validateTextGenerationConfig,
   getTokenCount,
   getTemperature,
-  getTopP
+  getTopP,
 } from '../../domain/entities/TextGenerationConfig';
-import { PromptGenerationService } from '../services/PromptGenerationService';
-
-const createTextGenerationBaseTemplate = (config?: {
-  promptType?: string;
-  tone?: string;
-  language?: string;
-}): string => {
-  const {
-    promptType = 'general',
-    tone = 'professional',
-    language = 'English'
-  } = config || {};
+import { BasePromptService } from './base';
 
-  return `
+const BASE_TEMPLATE = `
 You are an expert text generation specialist.
 This is a TEXT GENERATION task with specific requirements.
 
-GENERATION OBJECTIVES:
-- Generate ${promptType} content with ${tone} tone
-- Write in ${language} language
-- Follow provided context and constraints
-- Deliver high-quality, appropriate content
-
 CONTENT STANDARDS:
 - Clear, coherent, and well-structured text
 - Appropriate for the specified tone and purpose
 - Natural language flow and readability
-- Relevant and informative content
-
-STYLE REQUIREMENTS:
-- Maintain ${tone} tone throughout
-- Use appropriate vocabulary and expressions
-- Follow conventions for ${promptType} content
-- Adapt complexity to intended audience
-
-LANGUAGE REQUIREMENTS:
-- Write fluently in ${language}
-- Use proper grammar and syntax
-- Consider cultural and regional variations
-- Maintain consistency in language usage
 
-SAFETY AND QUALITY:
+SAFETY:
 - Generate appropriate, non-offensive content
 - Avoid harmful or misleading information
 - Ensure factual accuracy when applicable
 - Respect copyright and intellectual property
-
-OUTPUT:
-Professional ${promptType} content in ${language},
-written with ${tone} tone,
-meeting all specified requirements.
-  `.trim();
-};
-
-export class TextGenerationService implements ITextGenerationService {
-  private promptService: PromptGenerationService;
-
-  constructor() {
-    this.promptService = new PromptGenerationService();
-  }
-
-  generateTemplate(config: TextGenerationConfig): Promise<AIPromptResult<AIPromptTemplate>> {
-    try {
-      if (!this.validateConfig(config)) {
-        return Promise.resolve({
-          success: false,
-          error: 'VALIDATION_ERROR',
-          message: 'Invalid text generation configuration'
-        });
-      }
-
-      const template = this.createTextGenerationTemplate(config);
-      return Promise.resolve({ success: true, data: template });
-    } catch {
-      return Promise.resolve({
-        success: false,
-        error: 'GENERATION_FAILED',
-        message: 'Failed to generate text template'
-      });
-    }
-  }
-
-  async generatePrompt(
-    template: AIPromptTemplate,
-    config: TextGenerationConfig
-  ): Promise<AIPromptResult<string>> {
-    const parameters = this.getGenerationParameters(config);
-    const variables = {
-      promptType: config.promptType,
-      tone: config.tone,
-      length: config.length,
-      language: config.language,
-      context: config.context || '',
-      keywords: config.keywords?.join(', ') || '',
-      ...parameters,
-    };
-
-    return this.promptService.generateFromTemplate(template, variables);
+`.trim();
+
+export class TextGenerationService
+  extends BasePromptService<TextGenerationConfig>
+  implements ITextGenerationService
+{
+  protected getServiceName(): string {
+    return 'text generation';
   }
 
   validateConfig(config: TextGenerationConfig): boolean {
@@ -129,113 +56,35 @@ export class TextGenerationService implements ITextGenerationService {
     };
   }
 
-  private createTextGenerationTemplate(config: TextGenerationConfig): AIPromptTemplate {
-    const templateId = `text-generation-${config.promptType}`;
-
-    const baseTemplate = createTextGenerationBaseTemplate({
+  protected buildVariables(config: TextGenerationConfig): Record<string, unknown> {
+    return {
       promptType: config.promptType,
       tone: config.tone,
+      length: config.length,
       language: config.language,
-    });
+      context: config.context || '',
+      keywords: config.keywords?.join(', ') || '',
+      ...this.getGenerationParameters(config),
+    };
+  }
+
+  protected createTemplate(config: TextGenerationConfig): AIPromptTemplate {
+    const tokens = this.estimateTokens(config);
 
-    return createAIPromptTemplate({
-      id: templateId,
+    return this.createTemplateWithDefaults({
+      id: `text-generation-${config.promptType}`,
       name: `Text Generation: ${config.promptType}`,
       description: `Generate ${config.promptType} content in ${config.language}`,
       category: 'text-generation',
-      template: `${baseTemplate}
-
-GENERATION PARAMETERS:
-- Prompt Type: ${config.promptType}
-- Tone: ${config.tone}
-- Length: ${config.length}
-- Language: ${config.language}
-- Estimated Tokens: ${this.estimateTokens(config)}
-
-${config.context ? `CONTEXT:
-${config.context}
-
-` : ''}${config.keywords && config.keywords.length > 0 ? `KEYWORDS:
-${config.keywords.join(', ')}
-
-` : ''}CONTENT REQUIREMENTS:
-- Generate ${config.length} content appropriate for ${config.promptType}
-- Use ${config.tone} tone throughout the text
-- Follow conventions for ${config.promptType} writing
-- Write fluently in ${config.language}
-
-STYLE GUIDELINES:
-${this.getStyleGuidelines(config)}
-
-GENERATION PARAMETERS:
-- Temperature: ${getTemperature(config.promptType, config.tone)} (creativity level)
-- Max Tokens: ${this.estimateTokens(config)} (content length)
-- Top-P: ${getTopP(config.promptType)} (nucleus sampling)
-- Frequency Penalty: ${config.tone === 'formal' ? 0.3 : 0.1} (repetition reduction)
-- Presence Penalty: ${config.promptType === 'creative' ? 0.2 : 0.1} (new topic encouragement)
-
-EXPECTED OUTPUT:
-Professional ${config.promptType} content in ${config.language},
-approximately ${this.estimateTokens(config)} tokens long,
-with ${config.tone} tone and appropriate style.
-      `.trim(),
-      variables: [],
-      safety: {
-        contentFilter: true,
-        adultContentFilter: true,
-        violenceFilter: true,
-        hateSpeechFilter: true,
-        copyrightFilter: true,
-      },
-      version: '1.0.0',
+      template: `${BASE_TEMPLATE}
+
+TYPE: ${config.promptType}
+TONE: ${config.tone}
+LENGTH: ${config.length}
+LANGUAGE: ${config.language}
+TOKENS: ~${tokens}
+${config.context ? `CONTEXT: ${config.context}` : ''}
+${config.keywords?.length ? `KEYWORDS: ${config.keywords.join(', ')}` : ''}`,
     });
   }
-
-  private getStyleGuidelines(config: TextGenerationConfig): string {
-    const guidelines: string[] = [];
-
-    switch (config.promptType) {
-      case 'creative':
-        guidelines.push('- Use imaginative and engaging language');
-        guidelines.push('- Incorporate vivid descriptions and storytelling');
-        break;
-      case 'technical':
-        guidelines.push('- Use precise terminology and clear explanations');
-        guidelines.push('- Maintain logical structure and accuracy');
-        break;
-      case 'marketing':
-        guidelines.push('- Use persuasive and compelling language');
-        guidelines.push('- Include clear calls to action');
-        break;
-      case 'educational':
-        guidelines.push('- Present information clearly and progressively');
-        guidelines.push('- Include examples and explanations');
-        break;
-      case 'conversational':
-        guidelines.push('- Use natural, approachable language');
-        guidelines.push('- Include questions and engagement elements');
-        break;
-    }
-
-    switch (config.tone) {
-      case 'formal':
-        guidelines.push('- Maintain professional and respectful language');
-        guidelines.push('- Use proper grammar and complete sentences');
-        break;
-      case 'casual':
-        guidelines.push('- Use relaxed, natural language');
-        guidelines.push('- Include some conversational elements');
-        break;
-      case 'friendly':
-        guidelines.push('- Use warm and approachable tone');
-        guidelines.push('- Include encouraging and positive elements');
-        break;
-      case 'humorous':
-        guidelines.push('- Incorporate appropriate humor and wit');
-        guidelines.push('- Maintain lighthearted and engaging style');
-        break;
-    }
-
-    return guidelines.join('\n') || '- Follow standard writing conventions';
-  }
-}
+}

package/src/domains/prompts/infrastructure/services/base/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Base Services Index
+ */
+
+export { BasePromptService, DEFAULT_PROMPT_SAFETY } from './prompt-service.base';
+export type { TemplateParams } from './prompt-service.base';

package/src/domains/prompts/infrastructure/services/base/prompt-service.base.ts

@@ -0,0 +1,112 @@
+/**
+ * Base Prompt Service
+ * Abstract class for AI prompt generation services
+ * Eliminates code duplication across service implementations
+ */
+
+import type { AIPromptTemplate } from '../../../domain/entities/AIPromptTemplate';
+import type { AIPromptResult, AIPromptCategory } from '../../../domain/entities/types';
+import type { AIPromptSafety } from '../../../domain/entities/value-objects';
+import { createAIPromptTemplate } from '../../../domain/entities/AIPromptTemplate';
+import { PromptGenerationService } from '../PromptGenerationService';
+
+/**
+ * Default safety configuration for all AI prompt templates
+ */
+export const DEFAULT_PROMPT_SAFETY: AIPromptSafety = {
+  contentFilter: true,
+  adultContentFilter: true,
+  violenceFilter: true,
+  hateSpeechFilter: true,
+  copyrightFilter: true,
+};
+
+/**
+ * Template creation parameters
+ */
+export interface TemplateParams {
+  id: string;
+  name: string;
+  description: string;
+  category: AIPromptCategory;
+  template: string;
+}
+
+/**
+ * Base class for AI prompt generation services
+ * Provides common functionality for template generation
+ */
+export abstract class BasePromptService<TConfig> {
+  protected readonly promptService: PromptGenerationService;
+
+  constructor() {
+    this.promptService = new PromptGenerationService();
+  }
+
+  /**
+   * Generate template with standard error handling
+   */
+  generateTemplate(config: TConfig): Promise<AIPromptResult<AIPromptTemplate>> {
+    try {
+      if (!this.validateConfig(config)) {
+        return Promise.resolve({
+          success: false,
+          error: 'VALIDATION_ERROR',
+          message: `Invalid ${this.getServiceName()} configuration`,
+        });
+      }
+
+      const template = this.createTemplate(config);
+      return Promise.resolve({ success: true, data: template });
+    } catch {
+      return Promise.resolve({
+        success: false,
+        error: 'GENERATION_FAILED',
+        message: `Failed to generate ${this.getServiceName()} template`,
+      });
+    }
+  }
+
+  /**
+   * Generate prompt from template
+   */
+  async generatePrompt(
+    template: AIPromptTemplate,
+    config: TConfig,
+  ): Promise<AIPromptResult<string>> {
+    const variables = this.buildVariables(config);
+    return this.promptService.generateFromTemplate(template, variables);
+  }
+
+  /**
+   * Create template with default safety config
+   */
+  protected createTemplateWithDefaults(params: TemplateParams): AIPromptTemplate {
+    return createAIPromptTemplate({
+      ...params,
+      variables: [],
+      safety: DEFAULT_PROMPT_SAFETY,
+      version: '1.0.0',
+    });
+  }
+
+  /**
+   * Service name for error messages
+   */
+  protected abstract getServiceName(): string;
+
+  /**
+   * Validate configuration
+   */
+  abstract validateConfig(config: TConfig): boolean;
+
+  /**
+   * Create the template (service-specific)
+   */
+  protected abstract createTemplate(config: TConfig): AIPromptTemplate;
+
+  /**
+   * Build variables for prompt generation
+   */
+  protected abstract buildVariables(config: TConfig): Record<string, unknown>;
+}