@umituz/react-native-ai-generation-content 1.17.228 → 1.17.230

package/src/domains/prompts/README.md

@@ -0,0 +1,387 @@
+# Prompts Domain
+
+AI prompt management and generation system for AI features.
+
+## Overview
+
+The Prompts domain provides a comprehensive system for managing, generating, and templating AI prompts across all AI generation features. It includes services for prompt history, template management, and AI service processing.
+
+## Features
+
+- **Prompt Templates**: Pre-configured templates for various AI features
+- **Prompt History**: Track and manage generated prompts
+- **AI Service Processing**: Process prompts through AI services
+- **Type Safety**: Full TypeScript support with comprehensive types
+- **Extensible**: Easy to add new templates and services
+
+## Installation
+
+This domain is part of `@umituz/react-native-ai-generation-content`.
+
+```bash
+npm install @umituz/react-native-ai-generation-content
+```
+
+## Core Components
+
+### Entities
+
+#### AIPromptTemplate
+
+Base template for AI prompts:
+
+```tsx
+import { AIPromptTemplate } from '@umituz/react-native-ai-generation-content';
+
+const template: AIPromptTemplate = {
+  id: 'text-to-image-default',
+  name: 'Default Text to Image',
+  template: 'Create an image of {description}',
+  variables: ['description'],
+  category: 'image-generation',
+};
+```
+
+#### GeneratedPrompt
+
+Represents a generated prompt:
+
+```tsx
+import { GeneratedPrompt } from '@umituz/react-native-ai-generation-content';
+
+const generatedPrompt: GeneratedPrompt = {
+  id: 'prompt-123',
+  templateId: 'text-to-image-default',
+  content: 'Create an image of a beautiful sunset',
+  variables: {
+    description: 'a beautiful sunset',
+  },
+  createdAt: new Date(),
+};
+```
+
+#### Feature-Specific Configs
+
+##### FaceSwapConfig
+
+```tsx
+import { FaceSwapConfig } from '@umituz/react-native-ai-generation-content';
+
+const config: FaceSwapConfig = {
+  enhanceFace: true,
+  matchSkinTone: true,
+};
+```
+
+##### PhotoRestorationConfig
+
+```tsx
+import { PhotoRestorationConfig } from '@umituz/react-native-ai-generation-content';
+
+const config: PhotoRestorationConfig = {
+  removeScratches: true,
+  fixBlur: true,
+  colorize: false,
+};
+```
+
+##### StyleTransferConfig
+
+```tsx
+import { StyleTransferConfig } from '@umituz/react-native-ai-generation-content';
+
+const config: StyleTransferConfig = {
+  style: 'oil-painting',
+  intensity: 0.8,
+};
+```
+
+##### TextGenerationConfig
+
+```tsx
+import { TextGenerationConfig } from '@umituz/react-native-ai-generation-content';
+
+const config: TextGenerationConfig = {
+  model: 'gpt-4',
+  temperature: 0.7,
+  maxTokens: 1000,
+};
+```
+
+### Hooks
+
+#### usePromptGeneration
+
+Generate prompts from templates:
+
+```tsx
+import { usePromptGeneration } from '@umituz/react-native-ai-generation-content';
+
+function MyComponent() {
+  const { generatePrompt, isGenerating, error } = usePromptGeneration();
+
+  const handleGenerate = async () => {
+    const prompt = await generatePrompt({
+      templateId: 'text-to-image-default',
+      variables: {
+        description: 'a majestic mountain landscape',
+      },
+    });
+    console.log('Generated prompt:', prompt);
+  };
+
+  return <Button onPress={handleGenerate} title="Generate Prompt" />;
+}
+```
+
+#### useTemplateRepository
+
+Manage prompt templates:
+
+```tsx
+import { useTemplateRepository } from '@umituz/react-native-ai-generation-content';
+
+function TemplateManager() {
+  const { templates, addTemplate, updateTemplate, deleteTemplate } = useTemplateRepository();
+
+  const handleAddTemplate = async () => {
+    await addTemplate({
+      id: 'custom-template',
+      name: 'Custom Template',
+      template: 'Generate {style} image of {subject}',
+      variables: ['style', 'subject'],
+      category: 'custom',
+    });
+  };
+
+  return (
+    <View>
+      {templates.map(template => (
+        <Text key={template.id}>{template.name}</Text>
+      ))}
+      <Button onPress={handleAddTemplate} title="Add Template" />
+    </View>
+  );
+}
+```
+
+#### useFaceSwap
+
+Face swap specific prompt generation:
+
+```tsx
+import { useFaceSwap } from '@umituz/react-native-ai-generation-content';
+
+function FaceSwapComponent() {
+  const { generatePrompt, config } = useFaceSwap({
+    enhanceFace: true,
+    matchSkinTone: true,
+  });
+
+  const handleGenerate = async () => {
+    const prompt = await generatePrompt({
+      sourceImage: 'base64...',
+      targetImage: 'base64...',
+    });
+  };
+}
+```
+
+#### usePhotoRestoration
+
+Photo restoration prompt generation:
+
+```tsx
+import { usePhotoRestoration } from '@umituz/react-native-ai-generation-content';
+
+const { generatePrompt } = usePhotoRestoration({
+  removeScratches: true,
+  fixBlur: true,
+});
+```
+
+#### useStyleTransfer
+
+Style transfer prompt generation:
+
+```tsx
+import { useStyleTransfer } from '@umituz/react-native-ai-generation-content';
+
+const { generatePrompt } = useStyleTransfer({
+  style: 'oil-painting',
+  intensity: 0.8,
+});
+```
+
+#### useImageEnhancement
+
+Image enhancement prompt generation:
+
+```tsx
+import { useImageEnhancement } from '@umituz/react-native-ai-generation-content';
+
+const { generatePrompt } = useImageEnhancement({
+  enhanceDetails: true,
+  adjustColors: true,
+});
+```
+
+### Services
+
+#### PromptGenerationService
+
+Core service for generating prompts:
+
+```tsx
+import { PromptGenerationService } from '@umituz/react-native-ai-generation-content';
+
+const service = new PromptGenerationService();
+
+const prompt = await service.generatePrompt({
+  templateId: 'text-to-image-default',
+  variables: { description: 'beautiful sunset' },
+});
+```
+
+#### AIServiceProcessor
+
+Process prompts through AI services:
+
+```tsx
+import { AIServiceProcessor } from '@umituz/react-native-ai-generation-content';
+
+const processor = new AIServiceProcessor({
+  apiKey: 'your-api-key',
+  provider: 'openai',
+});
+
+const result = await processor.processPrompt({
+  prompt: 'Create an image of...',
+  service: 'text-to-image',
+});
+```
+
+### Repositories
+
+#### TemplateRepository
+
+Manage prompt templates:
+
+```tsx
+import { TemplateRepository } from '@umituz/react-native-ai-generation-content';
+
+const repository = new TemplateRepository();
+
+// Get all templates
+const templates = await repository.getAll();
+
+// Get template by ID
+const template = await repository.getById('text-to-image-default');
+
+// Save template
+await repository.save(template);
+
+// Delete template
+await repository.delete('text-to-image-default');
+```
+
+#### PromptHistoryRepository
+
+Track prompt generation history:
+
+```tsx
+import { PromptHistoryRepository } from '@umituz/react-native-ai-generation-content';
+
+const repository = new PromptHistoryRepository();
+
+// Add to history
+await repository.add({
+  promptId: 'prompt-123',
+  content: 'Create an image...',
+  createdAt: new Date(),
+});
+
+// Get history
+const history = await repository.getHistory({ limit: 10 });
+
+// Clear history
+await repository.clear();
+```
+
+## Sample Prompts
+
+Pre-configured example prompts:
+
+```tsx
+import {
+  DEFAULT_TEXT_TO_IMAGE_PROMPTS,
+  DEFAULT_TEXT_TO_VOICE_PROMPTS,
+} from '@umituz/react-native-ai-generation-content';
+
+// Text to image prompts
+DEFAULT_TEXT_TO_IMAGE_PROMPTS.forEach(prompt => {
+  console.log(prompt.id, prompt.fallbackText);
+  // Output:
+  // sunset, "A beautiful sunset over mountains with vibrant colors"
+  // cityscape, "Futuristic cityscape at night with neon lights"
+  // ...
+});
+
+// Text to voice prompts
+DEFAULT_TEXT_TO_VOICE_PROMPTS.forEach(prompt => {
+  console.log(prompt.id, prompt.fallbackText);
+  // Output:
+  // welcome, "Welcome to our amazing product!..."
+  // story, "Once upon a time..."
+  // ...
+});
+```
+
+## Custom Templates
+
+Create custom prompt templates:
+
+```tsx
+import { AIPromptTemplate } from '@umituz/react-native-ai-generation-content';
+
+const customTemplate: AIPromptTemplate = {
+  id: 'my-custom-template',
+  name: 'My Custom Template',
+  template: 'Create a {style} image of {subject} with {mood} mood',
+  variables: ['style', 'subject', 'mood'],
+  category: 'custom',
+  metadata: {
+    author: 'Your Name',
+    version: '1.0.0',
+  },
+};
+
+// Use custom template
+const prompt = await generatePrompt({
+  templateId: 'my-custom-template',
+  variables: {
+    style: 'realistic',
+    subject: 'a cat',
+    mood: 'playful',
+  },
+});
+// Result: "Create a realistic image of a cat with playful mood"
+```
+
+## Best Practices
+
+1. **Template Organization**: Group templates by category for easy management
+2. **Variable Naming**: Use clear, descriptive variable names
+3. **Prompt History**: Track prompt generation for analytics and debugging
+4. **Error Handling**: Always handle errors gracefully
+5. **Type Safety**: Leverage TypeScript types for type safety
+
+## Related Features
+
+- [Content Moderation](../content-moderation) - Moderate generated content
+- [Face Detection](../face-detection) - Detect faces in images
+- [Creations](../creations) - Manage AI-generated creations
+
+## License
+
+MIT

package/src/features/ai-hug/README.md

@@ -0,0 +1,276 @@
+# AI Hug
+
+Generate AI-powered hug images between two people.
+
+## Features
+
+- Create realistic hug images from two photos
+- Automatic pose and body detection
+- Natural arm positioning and embrace
+- Support for various hug types
+- High-quality facial matching
+
+## Installation
+
+This feature is part of `@umituz/react-native-ai-generation-content`.
+
+```bash
+npm install @umituz/react-native-ai-generation-content
+```
+
+## Basic Usage
+
+### Using the Hook
+
+```tsx
+import { useAIHugFeature } from '@umituz/react-native-ai-generation-content';
+import * as ImagePicker from 'react-native-image-picker';
+
+function AIHugScreen() {
+  const [person1, setPerson1] = useState<string | null>(null);
+  const [person2, setPerson2] = useState<string | null>(null);
+
+  const feature = useAIHugFeature({
+    config: {
+      hugType: 'romantic',
+      onProcessingStart: () => console.log('Generating hug...'),
+      onProcessingComplete: (result) => console.log('Complete:', result),
+      onError: (error) => console.error('Error:', error),
+    },
+    onSelectPerson1: async () => {
+      const result = await ImagePicker.launchImageLibrary({ mediaType: 'photo' });
+      if (result.assets && result.assets[0].uri) {
+        const base64 = await convertToBase64(result.assets[0].uri);
+        setPerson1(base64);
+        return base64;
+      }
+      return null;
+    },
+    onSelectPerson2: async () => {
+      const result = await ImagePicker.launchImageLibrary({ mediaType: 'photo' });
+      if (result.assets && result.assets[0].uri) {
+        const base64 = await convertToBase64(result.assets[0].uri);
+        setPerson2(base64);
+        return base64;
+      }
+      return null;
+    },
+    onSaveResult: async (imageUrl) => {
+      await saveToGallery(imageUrl);
+    },
+  });
+
+  return (
+    <View>
+      <DualImagePicker
+        sourceImage={person1}
+        targetImage={person2}
+        onSelectSourceImage={feature.selectPerson1}
+        onSelectTargetImage={feature.selectPerson2}
+        sourceLabel="Person 1"
+        targetLabel="Person 2"
+      />
+
+      <HugTypeSelector
+        selectedType={feature.state.hugType}
+        onSelectType={feature.setHugType}
+      />
+
+      <Button
+        title="Generate AI Hug"
+        onPress={feature.process}
+        disabled={!feature.isReady || feature.state.isProcessing}
+      />
+
+      {feature.state.isProcessing && (
+        <View>
+          <Text>Creating your hug image...</Text>
+          <ProgressBar progress={feature.state.progress} />
+        </View>
+      )}
+
+      {feature.state.result && (
+        <Image source={{ uri: feature.state.result.imageUrl }} />
+      )}
+    </View>
+  );
+}
+```
+
+### Using the Unified AI Feature Screen
+
+```tsx
+import { AIFeatureScreen } from '@umituz/react-native-ai-generation-content';
+
+function App() {
+  return (
+    <AIFeatureScreen
+      featureId="ai-hug"
+      userId="user-123"
+    />
+  );
+}
+```
+
+## Configuration Options
+
+### Feature Config
+
+```tsx
+interface AIHugFeatureConfig {
+  hugType?: 'romantic' | 'friendly' | 'family' | 'cute';
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: AIHugResult) => void;
+  onError?: (error: string) => void;
+}
+```
+
+### Generation Options
+
+```tsx
+interface AIHugOptions {
+  hugType: 'romantic' | 'friendly' | 'family' | 'cute';
+  preserveFaces?: boolean; // Maintain facial features (default: true)
+  enhanceQuality?: boolean; // Enhance output quality (default: true)
+}
+```
+
+## Hug Types
+
+### Romantic Hug
+
+```tsx
+const result = await feature.process({
+  hugType: 'romantic',
+});
+```
+
+### Friendly Hug
+
+```tsx
+const result = await feature.process({
+  hugType: 'friendly',
+});
+```
+
+### Family Hug
+
+```tsx
+const result = await feature.process({
+  hugType: 'family',
+});
+```
+
+### Cute Hug
+
+```tsx
+const result = await feature.process({
+  hugType: 'cute',
+});
+```
+
+## Usage Flow
+
+1. Select **Person 1** - Choose the first person's photo
+2. Select **Person 2** - Choose the second person's photo
+3. Choose **Hug Type** - Select the style of hug
+4. Tap **Generate** - Start the AI generation
+5. View Result - See the generated hug image
+6. Save or Share - Save to gallery or share
+
+## Component Examples
+
+### Hug Type Selector
+
+```tsx
+import { StylePresetsGrid } from '@umituz/react-native-ai-generation-content';
+
+const hugTypes = [
+  { id: 'romantic', name: 'Romantic', preview: '...' },
+  { id: 'friendly', name: 'Friendly', preview: '...' },
+  { id: 'family', name: 'Family', preview: '...' },
+  { id: 'cute', name: 'Cute', preview: '...' },
+];
+
+<StylePresetsGrid
+  styles={hugTypes}
+  selectedStyle={selectedHugType}
+  onSelectStyle={setSelectedHugType}
+/>
+```
+
+### Result Display with Actions
+
+```tsx
+import { ResultImageCard } from '@umituz/react-native-ai-generation-content';
+
+{feature.state.result && (
+  <ResultImageCard
+    imageUrl={feature.state.result.imageUrl}
+    onSave={() => feature.saveResult()}
+    onShare={() => shareImage(feature.state.result.imageUrl)}
+    onRegenerate={() => feature.process()}
+  />
+)}
+```
+
+## Best Practices
+
+1. **Photo Quality**: Use high-quality, well-lit photos
+2. **Full Body**: Photos showing full body work best
+3. **Facing Forward**: Forward-facing photos produce better results
+4. **Clear Faces**: Ensure both faces are clearly visible
+5. **Similar Lighting**: Similar lighting in both photos creates more natural results
+
+## Use Cases
+
+### Couple Photos
+
+```tsx
+// Create romantic hug images for couples
+const result = await feature.process({
+  hugType: 'romantic',
+  preserveFaces: true,
+});
+```
+
+### Family Moments
+
+```tsx
+// Generate family hug photos
+const result = await feature.process({
+  hugType: 'family',
+  enhanceQuality: true,
+});
+```
+
+### Fun with Friends
+
+```tsx
+// Create fun hug images with friends
+const result = await feature.process({
+  hugType: 'friendly',
+});
+```
+
+## Error Handling
+
+```tsx
+const { state, process } = useAIHugFeature({ ...config });
+
+useEffect(() => {
+  if (state.error) {
+    Alert.alert('Generation Failed', state.error);
+  }
+}, [state.error]);
+```
+
+## Related Features
+
+- [AI Kiss](../ai-kiss) - Generate AI kiss images
+- [Couple Future](../couple-future) - Generate future couple predictions
+- [Face Swap](../face-swap) - Swap faces between images
+
+## License
+
+MIT