@umituz/react-native-ai-generation-content 1.12.2 → 1.12.4

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

@@ -0,0 +1,100 @@
+import { useCallback } from 'react';
+import type { ImageEnhancementConfig, EnhancementAdjustments } from '../../domain/entities/ImageEnhancementConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { IImageEnhancementService } from '../../domain/repositories/IAIPromptServices';
+import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
+import type { IPromptHistoryRepository } from '../../domain/repositories/IPromptHistoryRepository';
+import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
+import { useAsyncState } from './useAsyncState';
+
+export interface ImageEnhancementResult {
+  template: AIPromptTemplate;
+  config: ImageEnhancementConfig;
+  adjustments: EnhancementAdjustments;
+}
+
+export interface UseImageEnhancementState {
+  generatedPrompt: string | null;
+  lastResult: ImageEnhancementResult | null;
+  adjustments: EnhancementAdjustments | null;
+}
+
+export interface UseImageEnhancementActions {
+  enhanceImage: (config: ImageEnhancementConfig) => Promise<void>;
+  calculateAdjustments: (config: ImageEnhancementConfig) => EnhancementAdjustments;
+  clearPrompt: () => void;
+  reset: () => void;
+}
+
+export const useImageEnhancement = (
+  service: IImageEnhancementService,
+  templateRepository: ITemplateRepository,
+  historyRepository: IPromptHistoryRepository
+): UseImageEnhancementState & UseImageEnhancementActions => {
+  const {
+    data: lastResult,
+    setData: setResult,
+    clearError,
+    setError,
+  } = useAsyncState<ImageEnhancementResult>(null);
+
+  const enhanceImage = useCallback(async (config: ImageEnhancementConfig): Promise<void> => {
+    clearError();
+
+    try {
+      const templateResult = await service.generateTemplate(config);
+      if (!templateResult.success || !templateResult.data) {
+        setError('Failed to generate template');
+        return;
+      }
+
+      const promptResult = await service.generatePrompt(templateResult.data, config);
+      if (!promptResult.success) {
+        setError('Failed to generate enhancement prompt');
+        return;
+      }
+
+      const generatedPrompt = createGeneratedPrompt({
+        templateId: templateResult.data.id,
+        generatedText: promptResult.data,
+        variables: {} as Record<string, unknown>,
+      });
+
+      await historyRepository.save(generatedPrompt);
+
+      const enhancementResult: ImageEnhancementResult = {
+        template: templateResult.data,
+        config,
+        adjustments: service.calculateAdjustments(config),
+      };
+
+      setResult(enhancementResult);
+    } catch {
+      setError('An unexpected error occurred during image enhancement');
+    }
+  }, [service, historyRepository, setError, setResult, clearError]);
+
+  const calculateAdjustments = useCallback((config: ImageEnhancementConfig): EnhancementAdjustments => {
+    return service.calculateAdjustments(config);
+  }, [service]);
+
+  const clearPrompt = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  const reset = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  return {
+    generatedPrompt: null,
+    lastResult,
+    adjustments: lastResult?.adjustments || null,
+    enhanceImage,
+    calculateAdjustments,
+    clearPrompt,
+    reset,
+  };
+};

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

@@ -0,0 +1,100 @@
+import { useCallback } from 'react';
+import type { PhotoRestorationConfig } from '../../domain/entities/PhotoRestorationConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { IPhotoRestorationService } from '../../domain/repositories/IAIPromptServices';
+import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
+import type { IPromptHistoryRepository } from '../../domain/repositories/IPromptHistoryRepository';
+import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
+import { useAsyncState } from './useAsyncState';
+
+export interface PhotoRestorationResult {
+  template: AIPromptTemplate;
+  config: PhotoRestorationConfig;
+  estimatedQuality: number;
+}
+
+export interface UsePhotoRestorationState {
+  generatedPrompt: string | null;
+  lastResult: PhotoRestorationResult | null;
+  estimatedQuality: number | null;
+}
+
+export interface UsePhotoRestorationActions {
+  restorePhoto: (config: PhotoRestorationConfig) => Promise<void>;
+  estimateQuality: (config: PhotoRestorationConfig) => number;
+  clearPrompt: () => void;
+  reset: () => void;
+}
+
+export const usePhotoRestoration = (
+  service: IPhotoRestorationService,
+  templateRepository: ITemplateRepository,
+  historyRepository: IPromptHistoryRepository
+): UsePhotoRestorationState & UsePhotoRestorationActions => {
+  const {
+    data: lastResult,
+    setData: setResult,
+    clearError,
+    setError,
+  } = useAsyncState<PhotoRestorationResult>(null);
+
+  const restorePhoto = useCallback(async (config: PhotoRestorationConfig): Promise<void> => {
+    clearError();
+
+    try {
+      const templateResult = await service.generateTemplate(config);
+      if (!templateResult.success || !templateResult.data) {
+        setError('Failed to generate template');
+        return;
+      }
+
+      const promptResult = await service.generatePrompt(templateResult.data, config);
+      if (!promptResult.success) {
+        setError('Failed to generate restoration prompt');
+        return;
+      }
+
+      const generatedPrompt = createGeneratedPrompt({
+        templateId: templateResult.data.id,
+        generatedText: promptResult.data,
+        variables: {} as Record<string, unknown>,
+      });
+
+      await historyRepository.save(generatedPrompt);
+
+      const restorationResult: PhotoRestorationResult = {
+        template: templateResult.data,
+        config,
+        estimatedQuality: service.estimateQuality(config),
+      };
+
+      setResult(restorationResult);
+    } catch {
+      setError('An unexpected error occurred during photo restoration');
+    }
+  }, [service, historyRepository, setError, setResult, clearError]);
+
+  const estimateQuality = useCallback((config: PhotoRestorationConfig): number => {
+    return service.estimateQuality(config);
+  }, [service]);
+
+  const clearPrompt = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  const reset = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  return {
+    generatedPrompt: null,
+    lastResult,
+    estimatedQuality: lastResult?.estimatedQuality || null,
+    restorePhoto,
+    estimateQuality,
+    clearPrompt,
+    reset,
+  };
+};

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

@@ -0,0 +1,144 @@
+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';
+import type { GeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
+import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
+import { useAsyncState } from './useAsyncState';
+
+export interface UsePromptGenerationState {
+  generatedPrompt: GeneratedPrompt | null;
+  history: GeneratedPrompt[];
+}
+
+export interface UsePromptGenerationActions {
+  generatePrompt: (
+    templateId: string,
+    variables: Record<string, unknown>
+  ) => Promise<void>;
+  loadHistory: (limit?: number) => Promise<void>;
+  clearHistory: () => Promise<void>;
+  saveToHistory: (prompt: GeneratedPrompt) => Promise<void>;
+  clearPrompt: () => void;
+  reset: () => void;
+}
+
+export const usePromptGeneration = (
+  templateRepository: ITemplateRepository,
+  promptService: IPromptGenerationService,
+  historyRepository: IPromptHistoryRepository
+): UsePromptGenerationState & UsePromptGenerationActions => {
+  const {
+    data: generatedPrompt,
+    loading,
+    error,
+    setError,
+    setData: setGeneratedPrompt,
+    clearError,
+  } = useAsyncState<GeneratedPrompt>(null);
+
+  const [history, setHistory] = useState<GeneratedPrompt[]>([]);
+
+  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) {
+          setError('Template not found');
+          return;
+        }
+
+        const promptResult = await promptService.generateFromTemplate(
+          templateResult.data,
+          variables
+        );
+
+        if (!promptResult.success) {
+          setError(('message' in promptResult && promptResult.message) || 'Failed to generate prompt');
+          return;
+        }
+
+        const newPrompt = createGeneratedPrompt({
+          templateId,
+          generatedText: promptResult.data,
+          variables,
+        });
+
+        await historyRepository.save(newPrompt);
+        setGeneratedPrompt(newPrompt);
+        
+        await loadHistory(50);
+      } catch (error) {
+        setError('An unexpected error occurred');
+      }
+    },
+    [templateRepository, promptService, historyRepository, setGeneratedPrompt, setError, clearError]
+  );
+
+  const loadHistory = useCallback(
+    async (limit: number = 50): Promise<void> => {
+      clearError();
+      try {
+        const result = await historyRepository.findRecent(limit);
+        if (result.success) {
+          setHistory(result.data);
+        } else {
+          setError(('message' in result && result.message) || 'Failed to load history');
+        }
+      } catch (error) {
+        setError('Failed to load history');
+      }
+    },
+    [historyRepository, setHistory, setError, clearError]
+  );
+
+  const clearHistory = useCallback(async (): Promise<void> => {
+    clearError();
+    try {
+      await historyRepository.clear();
+      setHistory([]);
+    } catch (error) {
+      setError('Failed to clear history');
+    }
+  }, [historyRepository, setHistory, setError, clearError]);
+
+  const saveToHistory = useCallback(
+    async (prompt: GeneratedPrompt): Promise<void> => {
+      clearError();
+      try {
+        await historyRepository.save(prompt);
+        await loadHistory(50);
+      } catch (error) {
+        setError('Failed to save to history');
+      }
+    },
+    [historyRepository, loadHistory, setError, clearError]
+  );
+
+  const clearPrompt = useCallback(() => {
+    setGeneratedPrompt(null);
+    clearError();
+  }, [setGeneratedPrompt, clearError]);
+
+  const reset = useCallback(() => {
+    setGeneratedPrompt(null);
+    setHistory([]);
+    clearError();
+  }, [setGeneratedPrompt, setHistory, clearError]);
+
+  return {
+    generatedPrompt,
+    history,
+    loading,
+    error,
+    generatePrompt,
+    loadHistory,
+    clearHistory,
+    saveToHistory,
+    clearPrompt,
+    reset,
+  } as UsePromptGenerationState & UsePromptGenerationActions;
+};

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

@@ -0,0 +1,125 @@
+import { useState, useCallback, useEffect } from 'react';
+import type { StyleTransferConfig } from '../../domain/entities/StyleTransferConfig';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { IStyleTransferService } from '../../domain/repositories/IAIPromptServices';
+import { StyleTransferService } from '../../infrastructure/services/StyleTransferService';
+import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
+import type { IPromptHistoryRepository } from '../../domain/repositories/IPromptHistoryRepository';
+import { createGeneratedPrompt } from '../../domain/entities/GeneratedPrompt';
+import { useAsyncState } from './useAsyncState';
+
+export interface StyleTransferResult {
+  template: AIPromptTemplate;
+  config: StyleTransferConfig;
+  appliedStyle: string;
+  expectedQuality: number;
+}
+
+export interface UseStyleTransferState {
+  generatedPrompt: string | null;
+  lastResult: StyleTransferResult | null;
+  availableStyles: string[];
+}
+
+export interface UseStyleTransferActions {
+  transferStyle: (config: StyleTransferConfig) => Promise<void>;
+  getAvailableStyles: () => Promise<string[]>;
+  registerStyle: (style: string) => void;
+  clearPrompt: () => void;
+  reset: () => void;
+}
+
+export const useStyleTransfer = (
+  service: IStyleTransferService,
+  templateRepository: ITemplateRepository,
+  historyRepository: IPromptHistoryRepository
+): UseStyleTransferState & UseStyleTransferActions => {
+  const {
+    data: lastResult,
+    setData: setResult,
+    clearError,
+    setError,
+  } = useAsyncState<StyleTransferResult>(null);
+
+  const [availableStyles, setAvailableStyles] = useState<string[]>([]);
+
+  const transferStyle = useCallback(async (config: StyleTransferConfig): Promise<void> => {
+    clearError();
+
+    try {
+      const templateResult = await service.generateTemplate(config);
+      if (!templateResult.success || !templateResult.data) {
+        setError('Failed to generate template');
+        return;
+      }
+
+      const promptResult = await service.generatePrompt(templateResult.data, config);
+      if (!promptResult.success) {
+        setError('Failed to generate style transfer prompt');
+        return;
+      }
+
+      const generatedPrompt = createGeneratedPrompt({
+        templateId: templateResult.data.id,
+        generatedText: promptResult.data,
+        variables: {} as Record<string, unknown>,
+      });
+
+      await historyRepository.save(generatedPrompt);
+
+      const transferResult: StyleTransferResult = {
+        template: templateResult.data,
+        config,
+        appliedStyle: config.targetStyle,
+        expectedQuality: Math.round(config.styleStrength * 100),
+      };
+
+      setResult(transferResult);
+    } catch {
+      setError('An unexpected error occurred during style transfer');
+    }
+  }, [service, historyRepository, setError, setResult, clearError]);
+
+  const getAvailableStyles = useCallback(async (): Promise<string[]> => {
+    try {
+      const styles = await service.getAvailableStyles();
+      setAvailableStyles(styles);
+      return styles;
+    } catch {
+      setError('Failed to load available styles');
+      return [];
+    }
+  }, [service, setError]);
+
+  const registerStyle = useCallback((style: string): void => {
+    if (service instanceof StyleTransferService) {
+      service.registerStyle(style);
+      setAvailableStyles(prev => [...prev, style]);
+    }
+  }, [service]);
+
+  const clearPrompt = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  const reset = useCallback(() => {
+    setResult(null);
+    clearError();
+  }, [setResult, clearError]);
+
+  useEffect(() => {
+    getAvailableStyles();
+  }, [getAvailableStyles]);
+
+  return {
+    generatedPrompt: null,
+    lastResult,
+    availableStyles,
+    transferStyle,
+    getAvailableStyles,
+    registerStyle,
+    clearPrompt,
+    reset,
+  };
+};

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

@@ -0,0 +1,113 @@
+import { useState, useCallback } from 'react';
+import type { AIPromptTemplate } from '../../domain/entities/AIPromptTemplate';
+import type { AIPromptCategory, AIPromptResult } from '../../domain/entities/types';
+import type { ITemplateRepository } from '../../domain/repositories/ITemplateRepository';
+import { useAsyncState } from './useAsyncState';
+
+export interface UseTemplateState {
+  templates: AIPromptTemplate[];
+  currentTemplate: AIPromptTemplate | null;
+}
+
+export interface UseTemplateActions {
+  loadAllTemplates: () => Promise<void>;
+  loadTemplateById: (id: string) => Promise<AIPromptTemplate | null>;
+  loadTemplatesByCategory: (category: AIPromptCategory) => Promise<AIPromptTemplate[]>;
+  saveTemplate: (template: AIPromptTemplate) => Promise<void>;
+  deleteTemplate: (id: string) => Promise<void>;
+  setCurrentTemplate: (template: AIPromptTemplate | null) => void;
+}
+
+export const useTemplateRepository = (
+  repository: ITemplateRepository
+): UseTemplateState & UseTemplateActions => {
+  const {
+    data: templates,
+    setData: setTemplates,
+    loading,
+    error,
+    setError,
+    clearError,
+  } = useAsyncState<AIPromptTemplate[]>([]);
+
+  const [currentTemplate, setCurrentTemplate] = useState<AIPromptTemplate | null>(null);
+
+  const loadAllTemplates = useCallback(async (): Promise<void> => {
+    clearError();
+    const result = await repository.findAll();
+
+    if (result.success) {
+      setTemplates(result.data);
+    } else {
+      setError(('message' in result && result.message) || 'Failed to load templates');
+    }
+  }, [repository, setTemplates, setError, clearError]);
+
+  const loadTemplateById = useCallback(async (id: string): Promise<AIPromptTemplate | null> => {
+    clearError();
+    const result = await repository.findById(id);
+
+    if (result.success) {
+      setCurrentTemplate(result.data);
+      return result.data;
+    } else {
+      setError(('message' in result && result.message) || 'Failed to load template');
+      return null;
+    }
+  }, [repository, setError, clearError]);
+
+  const loadTemplatesByCategory = useCallback(
+    async (category: AIPromptCategory): Promise<AIPromptTemplate[]> => {
+      clearError();
+      const result = await repository.findByCategory(category);
+
+      if (result.success) {
+        setTemplates(result.data);
+        return result.data;
+      } else {
+        setError(('message' in result && result.message) || 'Failed to load templates by category');
+        return [];
+      }
+    },
+    [repository, setTemplates, setError, clearError]
+  );
+
+  const saveTemplate = useCallback(async (template: AIPromptTemplate): Promise<void> => {
+    clearError();
+    const result = await repository.save(template);
+
+    if (result.success) {
+      loadAllTemplates();
+    } else {
+      setError(('message' in result && result.message) || 'Failed to save template');
+    }
+  }, [repository, loadAllTemplates, setError, clearError]);
+
+  const deleteTemplate = useCallback(async (id: string): Promise<void> => {
+    clearError();
+    const result = await repository.delete(id);
+
+    if (result.success) {
+      if (currentTemplate?.id === id) {
+        setCurrentTemplate(null);
+      }
+      loadAllTemplates();
+    } else {
+      setError(('message' in result && result.message) || 'Failed to delete template');
+    }
+  }, [repository, currentTemplate, loadAllTemplates, setError, clearError]);
+
+  return {
+    templates: templates || [],
+    currentTemplate,
+    loading,
+    error,
+    loadAllTemplates,
+    loadTemplateById,
+    loadTemplatesByCategory,
+    saveTemplate,
+    deleteTemplate,
+    setCurrentTemplate,
+    clearError,
+  } as UseTemplateState & UseTemplateActions;
+};

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

@@ -0,0 +1,16 @@
+import type { Theme } from './types';
+import { defaultTheme } from './types';
+
+let currentTheme = defaultTheme;
+
+export const useTheme = (): Theme => currentTheme;
+
+export const setTheme = (theme: Partial<Theme>): void => {
+  currentTheme = { ...currentTheme, ...theme };
+};
+
+export const getTheme = (): Theme => currentTheme;
+
+export const resetTheme = (): void => {
+  currentTheme = defaultTheme;
+};

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

@@ -0,0 +1,82 @@
+export interface ThemeColors {
+  primary: string;
+  secondary: string;
+  background: string;
+  surface: string;
+  text: string;
+  textSecondary: string;
+  border: string;
+  error: string;
+  warning: string;
+  success: string;
+}
+
+export interface ThemeSpacing {
+  xs: number;
+  sm: number;
+  md: number;
+  lg: number;
+  xl: number;
+}
+
+export interface ThemeTypography {
+  heading: {
+    fontSize: number;
+    fontWeight: string;
+  };
+  body: {
+    fontSize: number;
+    fontWeight: string;
+  };
+  caption: {
+    fontSize: number;
+    fontWeight: string;
+  };
+}
+
+export interface Theme {
+  colors: ThemeColors;
+  spacing: ThemeSpacing;
+  typography: ThemeTypography;
+}
+
+export const createTheme = (customTheme?: Partial<Theme>): Theme => ({
+  colors: {
+    primary: '#007AFF',
+    secondary: '#5856D6',
+    background: '#FFFFFF',
+    surface: '#F2F2F7',
+    text: '#000000',
+    textSecondary: '#8E8E93',
+    border: '#C6C6C8',
+    error: '#FF3B30',
+    warning: '#FF9500',
+    success: '#34C759',
+    ...customTheme?.colors,
+  },
+  spacing: {
+    xs: 4,
+    sm: 8,
+    md: 16,
+    lg: 24,
+    xl: 32,
+    ...customTheme?.spacing,
+  },
+  typography: {
+    heading: {
+      fontSize: 24,
+      fontWeight: 'bold',
+    },
+    body: {
+      fontSize: 16,
+      fontWeight: 'normal',
+    },
+    caption: {
+      fontSize: 12,
+      fontWeight: 'normal',
+    },
+    ...customTheme?.typography,
+  },
+});
+
+export const defaultTheme = createTheme();