@umituz/react-native-ai-generation-content 1.17.0 → 1.17.2

package/src/domains/creations/presentation/hooks/useAdvancedFilter.ts

@@ -0,0 +1,261 @@
+/**
+ * useAdvancedFilter Hook
+ * Advanced filtering with category, status, and search support
+ */
+
+import { useState, useMemo, useCallback } from "react";
+import type { CreationFilter, CreationStats, FilterOption } from "../../domain/types";
+import {
+  DEFAULT_CREATION_FILTER,
+  MEDIA_FILTER_OPTIONS,
+  STATUS_FILTER_OPTIONS,
+  calculateCreationStats,
+  isTypeInCategory,
+} from "../../domain/types";
+import type { CreationCategory, CreationStatus, CreationTypeId } from "../../domain/types";
+
+interface Creation {
+  id: string;
+  type?: string;
+  status?: string;
+  prompt?: string;
+  createdAt?: Date | number;
+  updatedAt?: Date | number;
+  metadata?: Record<string, unknown>;
+}
+
+interface UseAdvancedFilterProps<T extends Creation> {
+  creations: T[] | undefined;
+  initialFilter?: Partial<CreationFilter>;
+}
+
+interface UseAdvancedFilterReturn<T extends Creation> {
+  // Filtered results
+  filtered: T[];
+
+  // Current filter state
+  filter: CreationFilter;
+
+  // Stats
+  stats: CreationStats;
+
+  // Filter state
+  activeMediaFilter: string;
+  activeStatusFilter: string;
+  hasActiveFilters: boolean;
+
+  // Filter options with counts
+  mediaFilterOptions: FilterOption[];
+  statusFilterOptions: FilterOption[];
+
+  // Actions
+  setMediaFilter: (filter: CreationCategory | CreationTypeId) => void;
+  setStatusFilter: (status: CreationStatus | "all") => void;
+  setSearchQuery: (query: string) => void;
+  updateFilter: (update: Partial<CreationFilter>) => void;
+  resetFilters: () => void;
+}
+
+/**
+ * Advanced filtering hook for creations
+ * Supports category, status, search, and sorting
+ */
+export function useAdvancedFilter<T extends Creation>({
+  creations,
+  initialFilter,
+}: UseAdvancedFilterProps<T>): UseAdvancedFilterReturn<T> {
+  const [filter, setFilter] = useState<CreationFilter>({
+    ...DEFAULT_CREATION_FILTER,
+    ...initialFilter,
+  });
+
+  // Calculate stats from all creations
+  const stats = useMemo(() => {
+    if (!creations) {
+      return {
+        total: 0,
+        byCategory: { all: 0, image: 0, video: 0, voice: 0 },
+        byStatus: { pending: 0, queued: 0, processing: 0, completed: 0, failed: 0 },
+        byType: {},
+      };
+    }
+    return calculateCreationStats(creations);
+  }, [creations]);
+
+  // Filter creations
+  const filtered = useMemo(() => {
+    if (!creations) return [];
+
+    let result = [...creations];
+
+    // Filter by type/category
+    if (filter.type && filter.type !== "all") {
+      const filterType = filter.type;
+
+      // Check if it's a category
+      if (["image", "video", "voice"].includes(filterType)) {
+        const category = filterType as CreationCategory;
+        result = result.filter((c) =>
+          c.type && isTypeInCategory(c.type as CreationTypeId, category)
+        );
+      } else {
+        // It's a specific type
+        result = result.filter((c) => c.type === filterType);
+      }
+    }
+
+    // Filter by status
+    if (filter.status && filter.status !== "all") {
+      result = result.filter((c) => c.status === filter.status);
+    }
+
+    // Filter by search query
+    if (filter.searchQuery && filter.searchQuery.trim()) {
+      const query = filter.searchQuery.toLowerCase().trim();
+      result = result.filter((c) => {
+        const prompt = c.prompt?.toLowerCase() || "";
+        const type = c.type?.toLowerCase() || "";
+        return prompt.includes(query) || type.includes(query);
+      });
+    }
+
+    // Filter by date range
+    if (filter.startDate) {
+      result = result.filter((c) => {
+        const createdAt = c.createdAt instanceof Date
+          ? c.createdAt.getTime()
+          : (c.createdAt || 0);
+        return createdAt >= filter.startDate!;
+      });
+    }
+
+    if (filter.endDate) {
+      result = result.filter((c) => {
+        const createdAt = c.createdAt instanceof Date
+          ? c.createdAt.getTime()
+          : (c.createdAt || 0);
+        return createdAt <= filter.endDate!;
+      });
+    }
+
+    // Sort
+    if (filter.sortField) {
+      result.sort((a, b) => {
+        let aVal: string | number | Date | undefined;
+        let bVal: string | number | Date | undefined;
+
+        switch (filter.sortField) {
+          case "createdAt":
+            aVal = a.createdAt;
+            bVal = b.createdAt;
+            break;
+          case "updatedAt":
+            aVal = a.updatedAt;
+            bVal = b.updatedAt;
+            break;
+          case "type":
+            aVal = a.type;
+            bVal = b.type;
+            break;
+          case "status":
+            aVal = a.status;
+            bVal = b.status;
+            break;
+          default:
+            return 0;
+        }
+
+        // Convert dates to numbers for comparison
+        if (aVal instanceof Date) aVal = aVal.getTime();
+        if (bVal instanceof Date) bVal = bVal.getTime();
+
+        // Handle undefined values
+        if (aVal === undefined && bVal === undefined) return 0;
+        if (aVal === undefined) return 1;
+        if (bVal === undefined) return -1;
+
+        // Compare
+        if (typeof aVal === "string" && typeof bVal === "string") {
+          return filter.sortOrder === "desc"
+            ? bVal.localeCompare(aVal)
+            : aVal.localeCompare(bVal);
+        }
+
+        if (typeof aVal === "number" && typeof bVal === "number") {
+          return filter.sortOrder === "desc" ? bVal - aVal : aVal - bVal;
+        }
+
+        return 0;
+      });
+    }
+
+    // Apply limit
+    if (filter.limit && filter.limit > 0) {
+      result = result.slice(0, filter.limit);
+    }
+
+    return result;
+  }, [creations, filter]);
+
+  // Media filter options with counts
+  const mediaFilterOptions = useMemo<FilterOption[]>(() => {
+    return MEDIA_FILTER_OPTIONS.map((opt) => ({
+      ...opt,
+      count: opt.id === "all"
+        ? stats.total
+        : stats.byCategory[opt.id as CreationCategory] || 0,
+    }));
+  }, [stats]);
+
+  // Status filter options with counts
+  const statusFilterOptions = useMemo<FilterOption[]>(() => {
+    return STATUS_FILTER_OPTIONS.map((opt) => ({
+      ...opt,
+      count: opt.id === "all"
+        ? stats.total
+        : stats.byStatus[opt.id as CreationStatus] || 0,
+    }));
+  }, [stats]);
+
+  // Actions
+  const setMediaFilter = useCallback((type: CreationCategory | CreationTypeId) => {
+    setFilter((prev) => ({ ...prev, type }));
+  }, []);
+
+  const setStatusFilter = useCallback((status: CreationStatus | "all") => {
+    setFilter((prev) => ({ ...prev, status }));
+  }, []);
+
+  const setSearchQuery = useCallback((searchQuery: string) => {
+    setFilter((prev) => ({ ...prev, searchQuery }));
+  }, []);
+
+  const updateFilter = useCallback((update: Partial<CreationFilter>) => {
+    setFilter((prev) => ({ ...prev, ...update }));
+  }, []);
+
+  const resetFilters = useCallback(() => {
+    setFilter(DEFAULT_CREATION_FILTER);
+  }, []);
+
+  // Derived state
+  const hasActiveFilters = filter.type !== "all" || filter.status !== "all" || !!filter.searchQuery;
+  const activeMediaFilter = (filter.type as string) || "all";
+  const activeStatusFilter = (filter.status as string) || "all";
+
+  return {
+    filtered,
+    filter,
+    stats,
+    activeMediaFilter,
+    activeStatusFilter,
+    hasActiveFilters,
+    mediaFilterOptions,
+    statusFilterOptions,
+    setMediaFilter,
+    setStatusFilter,
+    setSearchQuery,
+    updateFilter,
+    resetFilters,
+  };
+}

package/src/domains/creations/presentation/screens/CreationsGalleryScreen.tsx

@@ -55,7 +55,7 @@ function CreationsGalleryScreenContent({
   repository,
   config,
   t,
-  locale = "en-US",
+  locale: _locale = "en-US",
   enableEditing = false,
   onImageEdit,
   onEmptyAction,
@@ -199,11 +199,13 @@ function CreationsGalleryScreenContent({
         creations={filtered}
         isLoading={isLoading}
         onRefresh={() => void refetch()}
-        onView={handleView}
-        onShare={handleShare}
-        onDelete={handleDelete}
-        onFavorite={handleFavorite}
-        locale={locale}
+        onPress={(creation) => handleView(creation as Creation)}
+        onShare={async (creation) => handleShare(creation as Creation)}
+        onDelete={(creation) => handleDelete(creation as Creation)}
+        onFavorite={(creation) => {
+          const c = creation as Creation;
+          handleFavorite(c, !c.isFavorite);
+        }}
         contentContainerStyle={{ paddingBottom: tokens.spacing.xl }}
         ListEmptyComponent={renderEmptyComponent}
       />

package/src/domains/face-detection/infrastructure/validators/faceValidator.ts

@@ -32,7 +32,7 @@ export const parseDetectionResponse = (
       confidence: Number(parsed.confidence) || 0,
       message: String(parsed.reason || ""),
     };
-  } catch (error) {
+  } catch {
     return createFailedResult("Failed to parse response");
   }
 };

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

@@ -17,7 +17,7 @@ export class PromptGenerationService implements IPromptGenerationService {
 
         const generatedText = this.replaceTemplateVariables(template.template, variables);
         resolve({ success: true, data: generatedText });
-      } catch (error) {
+      } catch {
         resolve({
           success: false,
           error: 'GENERATION_FAILED',

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

@@ -62,7 +62,7 @@ export const useFaceSwap = (
       };
 
       setResult(generationResult);
-    } catch (error) {
+    } catch {
       setError('An unexpected error occurred');
     }
   }, [faceSwapService, historyRepository, setError, setResult, clearError]);
@@ -70,7 +70,7 @@ export const useFaceSwap = (
   const getAvailableStyles = useCallback(async (): Promise<string[]> => {
     try {
       return await faceSwapService.getAvailableStyles();
-    } catch (error) {
+    } catch {
       setError('Failed to load available styles');
       return [];
     }

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

@@ -70,7 +70,7 @@ export const usePromptGeneration = (
         setGeneratedPrompt(newPrompt);
 
         void loadHistory(50);
-      } catch (error) {
+      } catch {
         setError('An unexpected error occurred');
       }
     },
@@ -87,7 +87,7 @@ export const usePromptGeneration = (
         } else {
           setError(('message' in result && result.message) || 'Failed to load history');
         }
-      } catch (error) {
+      } catch {
         setError('Failed to load history');
       }
     },
@@ -99,7 +99,7 @@ export const usePromptGeneration = (
     try {
       await historyRepository.clear();
       setHistory([]);
-    } catch (error) {
+    } catch {
       setError('Failed to clear history');
     }
   }, [historyRepository, setHistory, setError, clearError]);
@@ -110,7 +110,7 @@ export const usePromptGeneration = (
       try {
         await historyRepository.save(prompt);
         void loadHistory(50);
-      } catch (error) {
+      } catch {
         setError('Failed to save to history');
       }
     },

package/src/features/ai-hug/domain/index.ts

@@ -0,0 +1,5 @@
+/**
+ * AI Hug Domain Index
+ */
+
+export * from "./types";

package/src/features/ai-hug/domain/types/ai-hug.types.ts

@@ -0,0 +1,72 @@
+/**
+ * AI Hug Feature Types
+ * Request, Result, Config types for AI hug generation
+ */
+
+export interface AIHugOptions {
+  intensity?: "gentle" | "warm" | "tight";
+  preserveFaces?: boolean;
+}
+
+export interface AIHugRequest {
+  sourceImageUri: string;
+  targetImageUri: string;
+  sourceImageBase64?: string;
+  targetImageBase64?: string;
+  userId: string;
+  options?: AIHugOptions;
+}
+
+export interface AIHugResult {
+  success: boolean;
+  imageUrl?: string;
+  imageBase64?: string;
+  error?: string;
+  requestId?: string;
+}
+
+export interface AIHugFeatureState {
+  sourceImageUri: string | null;
+  targetImageUri: string | null;
+  processedUrl: string | null;
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+}
+
+export interface AIHugTranslations {
+  sourceUploadTitle: string;
+  sourceUploadSubtitle: string;
+  targetUploadTitle: string;
+  targetUploadSubtitle: string;
+  uploadChange: string;
+  uploadAnalyzing: string;
+  description: string;
+  processingText: string;
+  processButtonText: string;
+  successText: string;
+  saveButtonText: string;
+  tryAnotherText: string;
+}
+
+export type AIHugInputBuilder = (
+  sourceBase64: string,
+  targetBase64: string,
+  options?: AIHugOptions,
+) => Record<string, unknown>;
+
+export type AIHugResultExtractor = (result: unknown) => string | undefined;
+
+export interface AIHugFeatureConfig {
+  providerId?: string;
+  creditCost?: number;
+  model: string;
+  buildInput: AIHugInputBuilder;
+  extractResult?: AIHugResultExtractor;
+  prepareImage: (imageUri: string) => Promise<string>;
+  onSourceImageSelect?: (uri: string) => void;
+  onTargetImageSelect?: (uri: string) => void;
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: AIHugResult) => void;
+  onError?: (error: string) => void;
+}

package/src/features/ai-hug/domain/types/index.ts

@@ -0,0 +1,14 @@
+/**
+ * AI Hug Domain Types Index
+ */
+
+export type {
+  AIHugOptions,
+  AIHugRequest,
+  AIHugResult,
+  AIHugFeatureState,
+  AIHugTranslations,
+  AIHugInputBuilder,
+  AIHugResultExtractor,
+  AIHugFeatureConfig,
+} from "./ai-hug.types";

package/src/features/ai-hug/index.ts

@@ -0,0 +1,27 @@
+/**
+ * AI Hug Feature
+ * Provider-agnostic AI hug generation feature
+ */
+
+// Domain Types
+export type {
+  AIHugOptions,
+  AIHugRequest,
+  AIHugResult,
+  AIHugFeatureState,
+  AIHugTranslations,
+  AIHugFeatureConfig,
+  AIHugInputBuilder,
+  AIHugResultExtractor,
+} from "./domain";
+
+// Infrastructure Services
+export { executeAIHug, hasAIHugSupport } from "./infrastructure";
+export type { ExecuteAIHugOptions } from "./infrastructure";
+
+// Presentation Hooks
+export { useAIHugFeature } from "./presentation";
+export type {
+  UseAIHugFeatureProps,
+  UseAIHugFeatureReturn,
+} from "./presentation";

package/src/features/ai-hug/infrastructure/index.ts

@@ -0,0 +1,5 @@
+/**
+ * AI Hug Infrastructure Index
+ */
+
+export * from "./services";

package/src/features/ai-hug/infrastructure/services/ai-hug-executor.ts

@@ -0,0 +1,96 @@
+/**
+ * AI Hug Executor
+ * Provider-agnostic AI hug execution using active AI provider
+ * Model and input format are provided via options from app level
+ */
+
+import { providerRegistry } from "../../../../infrastructure/services";
+import { cleanBase64 } from "../../../../infrastructure/utils";
+import type {
+  AIHugRequest,
+  AIHugResult,
+  AIHugInputBuilder,
+  AIHugResultExtractor,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface ExecuteAIHugOptions {
+  model: string;
+  buildInput: AIHugInputBuilder;
+  extractResult?: AIHugResultExtractor;
+  onProgress?: (progress: number) => void;
+}
+
+function defaultExtractResult(result: unknown): string | undefined {
+  if (typeof result !== "object" || result === null) return undefined;
+
+  const r = result as Record<string, unknown>;
+
+  if (typeof r.image === "string") return r.image;
+  if (Array.isArray(r.images) && r.images[0]?.url) return r.images[0].url;
+
+  return undefined;
+}
+
+export async function executeAIHug(
+  request: AIHugRequest,
+  options: ExecuteAIHugOptions,
+): Promise<AIHugResult> {
+  const provider = providerRegistry.getActiveProvider();
+
+  if (!provider) {
+    return { success: false, error: "No AI provider configured" };
+  }
+
+  if (!provider.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  if (!request.sourceImageBase64 || !request.targetImageBase64) {
+    return { success: false, error: "Both source and target image base64 are required" };
+  }
+
+  const { model, buildInput, extractResult, onProgress } = options;
+
+  if (__DEV__) {
+    // eslint-disable-next-line no-console
+    console.log(`[AIHug] Provider: ${provider.providerId}, Model: ${model}`);
+  }
+
+  try {
+    onProgress?.(10);
+
+    const sourceBase64 = cleanBase64(request.sourceImageBase64);
+    const targetBase64 = cleanBase64(request.targetImageBase64);
+    onProgress?.(30);
+
+    const input = buildInput(sourceBase64, targetBase64, request.options);
+    onProgress?.(40);
+
+    const result = await provider.run(model, input);
+    onProgress?.(90);
+
+    const extractor = extractResult || defaultExtractResult;
+    const imageUrl = extractor(result);
+    onProgress?.(100);
+
+    if (!imageUrl) {
+      return { success: false, error: "No image in response" };
+    }
+
+    return { success: true, imageUrl };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.error("[AIHug] Error:", message);
+    }
+    return { success: false, error: message };
+  }
+}
+
+export function hasAIHugSupport(): boolean {
+  const provider = providerRegistry.getActiveProvider();
+  return provider !== null && provider.isInitialized();
+}

package/src/features/ai-hug/infrastructure/services/index.ts

@@ -0,0 +1,6 @@
+/**
+ * AI Hug Infrastructure Services Index
+ */
+
+export { executeAIHug, hasAIHugSupport } from "./ai-hug-executor";
+export type { ExecuteAIHugOptions } from "./ai-hug-executor";

package/src/features/ai-hug/presentation/hooks/index.ts

@@ -0,0 +1,9 @@
+/**
+ * AI Hug Presentation Hooks Index
+ */
+
+export { useAIHugFeature } from "./useAIHugFeature";
+export type {
+  UseAIHugFeatureProps,
+  UseAIHugFeatureReturn,
+} from "./useAIHugFeature";