@umituz/react-native-ai-generation-content 1.16.0 → 1.17.1

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

@@ -0,0 +1,262 @@
+/**
+ * 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,
+  getTypesForCategory,
+  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

@@ -196,14 +196,13 @@ function CreationsGalleryScreenContent({
     >
       {/* Main Content Grid - handles empty/loading via ListEmptyComponent */}
       <CreationsGrid
-        creations={filtered}
+        creations={filtered as any}
         isLoading={isLoading}
         onRefresh={() => void refetch()}
-        onView={handleView}
-        onShare={handleShare}
-        onDelete={handleDelete}
-        onFavorite={handleFavorite}
-        locale={locale}
+        onPress={handleView}
+        onShare={async (creation) => handleShare(creation as any)}
+        onDelete={(creation) => handleDelete(creation as any)}
+        onFavorite={(creation) => handleFavorite(creation as any, !(creation as any).isFavorite)}
         contentContainerStyle={{ paddingBottom: tokens.spacing.xl }}
         ListEmptyComponent={renderEmptyComponent}
       />

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";

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

@@ -0,0 +1,157 @@
+/**
+ * useAIHugFeature Hook
+ * Manages AI hug feature state and actions
+ */
+
+import { useState, useCallback } from "react";
+import { executeAIHug } from "../../infrastructure/services";
+import type {
+  AIHugFeatureState,
+  AIHugFeatureConfig,
+  AIHugResult,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface UseAIHugFeatureProps {
+  config: AIHugFeatureConfig;
+  userId: string;
+  onSelectSourceImage: () => Promise<string | null>;
+  onSelectTargetImage: () => Promise<string | null>;
+  onSaveImage: (imageUrl: string) => Promise<void>;
+}
+
+export interface UseAIHugFeatureReturn extends AIHugFeatureState {
+  selectSourceImage: () => Promise<void>;
+  selectTargetImage: () => Promise<void>;
+  process: () => Promise<void>;
+  save: () => Promise<void>;
+  reset: () => void;
+}
+
+const initialState: AIHugFeatureState = {
+  sourceImageUri: null,
+  targetImageUri: null,
+  processedUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export function useAIHugFeature(
+  props: UseAIHugFeatureProps,
+): UseAIHugFeatureReturn {
+  const { config, userId, onSelectSourceImage, onSelectTargetImage, onSaveImage } = props;
+  const [state, setState] = useState<AIHugFeatureState>(initialState);
+
+  const selectSourceImage = useCallback(async () => {
+    try {
+      const uri = await onSelectSourceImage();
+      if (uri) {
+        setState((prev) => ({ ...prev, sourceImageUri: uri, error: null }));
+        config.onSourceImageSelect?.(uri);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [onSelectSourceImage, config]);
+
+  const selectTargetImage = useCallback(async () => {
+    try {
+      const uri = await onSelectTargetImage();
+      if (uri) {
+        setState((prev) => ({ ...prev, targetImageUri: uri, error: null }));
+        config.onTargetImageSelect?.(uri);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [onSelectTargetImage, config]);
+
+  const handleProgress = useCallback((progress: number) => {
+    setState((prev) => ({ ...prev, progress }));
+  }, []);
+
+  const process = useCallback(async () => {
+    if (!state.sourceImageUri || !state.targetImageUri) return;
+
+    setState((prev) => ({
+      ...prev,
+      isProcessing: true,
+      progress: 0,
+      error: null,
+    }));
+
+    config.onProcessingStart?.();
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[useAIHugFeature] Starting AI hug process");
+    }
+
+    const sourceImageBase64 = await config.prepareImage(state.sourceImageUri);
+    const targetImageBase64 = await config.prepareImage(state.targetImageUri);
+
+    const result: AIHugResult = await executeAIHug(
+      {
+        sourceImageUri: state.sourceImageUri,
+        targetImageUri: state.targetImageUri,
+        sourceImageBase64,
+        targetImageBase64,
+        userId,
+      },
+      {
+        model: config.model,
+        buildInput: config.buildInput,
+        extractResult: config.extractResult,
+        onProgress: handleProgress,
+      },
+    );
+
+    if (result.success && result.imageUrl) {
+      const url = result.imageUrl;
+      setState((prev) => ({
+        ...prev,
+        isProcessing: false,
+        processedUrl: url,
+        progress: 100,
+      }));
+      config.onProcessingComplete?.(result);
+    } else {
+      const errorMessage = result.error || "Processing failed";
+      setState((prev) => ({
+        ...prev,
+        isProcessing: false,
+        error: errorMessage,
+        progress: 0,
+      }));
+      config.onError?.(errorMessage);
+    }
+  }, [state.sourceImageUri, state.targetImageUri, userId, config, handleProgress]);
+
+  const save = useCallback(async () => {
+    if (!state.processedUrl) return;
+
+    try {
+      await onSaveImage(state.processedUrl);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [state.processedUrl, onSaveImage]);
+
+  const reset = useCallback(() => {
+    setState(initialState);
+  }, []);
+
+  return {
+    ...state,
+    selectSourceImage,
+    selectTargetImage,
+    process,
+    save,
+    reset,
+  };
+}

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

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

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

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