@umituz/react-native-ai-generation-content 1.83.86 → 1.83.87

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

@@ -1,56 +0,0 @@
-import { useState, useCallback } from 'react';
-
-export interface AsyncState<T> {
-  data: T | null;
-  loading: boolean;
-  error: string | null;
-}
-
-export interface AsyncActions<T> {
-  setLoading: (loading: boolean) => void;
-  setError: (error: string | null) => void;
-  setData: (data: T | null) => void;
-  clearError: () => void;
-  reset: () => void;
-}
-
-export const useAsyncState = <T>(initialData: T | null = null): AsyncState<T> & AsyncActions<T> => {
-  const [state, setState] = useState<AsyncState<T>>({
-    data: initialData,
-    loading: false,
-    error: null,
-  });
-
-  const setLoading = useCallback((loading: boolean) => {
-    setState(prev => ({ ...prev, loading }));
-  }, []);
-
-  const setError = useCallback((error: string | null) => {
-    setState(prev => ({ ...prev, error, loading: false }));
-  }, []);
-
-  const setData = useCallback((data: T | null) => {
-    setState(prev => ({ ...prev, data, loading: false, error: null }));
-  }, []);
-
-  const clearError = useCallback(() => {
-    setState(prev => ({ ...prev, error: null }));
-  }, []);
-
-  const reset = useCallback(() => {
-    setState({
-      data: initialData,
-      loading: false,
-      error: null,
-    });
-  }, [initialData]);
-
-  return {
-    ...state,
-    setLoading,
-    setError,
-    setData,
-    clearError,
-    reset,
-  };
-};

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

@@ -1,143 +0,0 @@
-import { useState, useCallback } from 'react';
-import type {ITemplateRepository} from '../../domain/repositories/ITemplateRepository';
-import type {IPromptHistoryRepository} from '../../domain/repositories/IPromptHistoryRepository';
-import type {GeneratedPrompt} from '../../domain/entities/GeneratedPrompt';
-import type {IPromptGenerationService} from '../../domain/repositories/IAIPromptServices';
-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);
-
-        void loadHistory(50);
-      } catch {
-        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 {
-        setError('Failed to load history');
-      }
-    },
-    [historyRepository, setHistory, setError, clearError]
-  );
-
-  const clearHistory = useCallback(async (): Promise<void> => {
-    clearError();
-    try {
-      await historyRepository.clear();
-      setHistory([]);
-    } catch {
-      setError('Failed to clear history');
-    }
-  }, [historyRepository, setHistory, setError, clearError]);
-
-  const saveToHistory = useCallback(
-    async (prompt: GeneratedPrompt): Promise<void> => {
-      clearError();
-      try {
-        await historyRepository.save(prompt);
-        void loadHistory(50);
-      } catch {
-        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/useTemplateRepository.ts

@@ -1,113 +0,0 @@
-import { useState, useCallback } from 'react';
-import type {AIPromptTemplate} from '../../domain/entities/AIPromptTemplate';
-import type {AIPromptCategory} 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) {
-      void 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);
-      }
-      void 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;
-};