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

package/src/domains/creations/types.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Type declarations for external modules
+ */
+
+declare module "@umituz/react-native-firestore" {
+  import type { Firestore } from "firebase/firestore";
+
+  export class BaseRepository {
+    protected getDb(): Firestore | null;
+    protected getDbOrThrow(): Firestore;
+    protected isDbInitialized(): boolean;
+    protected isQuotaError(error: unknown): boolean;
+    protected handleQuotaError(error: unknown): never;
+    protected executeWithQuotaHandling<T>(
+      operation: () => Promise<T>,
+    ): Promise<T>;
+    protected trackRead(
+      collection: string,
+      count: number,
+      cached: boolean,
+    ): void;
+    protected trackWrite(
+      collection: string,
+      docId: string,
+      count: number,
+    ): void;
+    protected trackDelete(
+      collection: string,
+      docId: string,
+      count: number,
+    ): void;
+    destroy(): void;
+  }
+
+  export function getFirestore(): Firestore | null;
+  export function initializeFirestore(app: unknown): void;
+  export function isFirestoreInitialized(): boolean;
+}
+
+declare module "@umituz/react-native-design-system" {
+  import type { FC, ReactNode } from "react";
+  import type { StyleProp, ViewStyle, TextStyle } from "react-native";
+
+  export interface DesignTokens {
+    colors: {
+      primary: string;
+      secondary: string;
+      error: string;
+      warning: string;
+      success: string;
+      backgroundPrimary: string;
+      backgroundSecondary: string;
+      surface: string;
+      textPrimary: string;
+      textSecondary: string;
+      textInverse: string;
+      border: string;
+      [key: string]: string;
+    };
+    spacing: {
+      xs: number;
+      sm: number;
+      md: number;
+      lg: number;
+      xl: number;
+      xxl: number;
+      [key: string]: number;
+    };
+    typography: {
+      headingLarge: TextStyle;
+      headingMedium: TextStyle;
+      headingSmall: TextStyle;
+      bodyLarge: TextStyle;
+      bodyMedium: TextStyle;
+      bodySmall: TextStyle;
+      [key: string]: TextStyle;
+    };
+  }
+
+  export function useAppDesignTokens(): DesignTokens;
+
+  export interface AtomicTextProps {
+    children?: ReactNode;
+    style?: StyleProp<TextStyle>;
+  }
+  export const AtomicText: FC<AtomicTextProps>;
+
+  export interface AtomicIconProps {
+    name: string;
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    color?: string;
+  }
+  export const AtomicIcon: FC<AtomicIconProps>;
+}
+
+declare module "@umituz/react-native-sharing" {
+  export interface ShareOptions {
+    dialogTitle?: string;
+    mimeType?: string;
+  }
+
+  export interface UseSharingResult {
+    share: (uri: string, options?: ShareOptions) => Promise<void>;
+  }
+
+  export function useSharing(): UseSharingResult;
+}

package/src/domains/face-detection/domain/constants/faceDetectionConstants.ts

@@ -0,0 +1,16 @@
+/**
+ * Face Detection Constants
+ */
+
+export const FACE_DETECTION_CONFIG = {
+  minConfidence: 0.5,
+} as const;
+
+export const FACE_DETECTION_PROMPTS = {
+  analyze: `Look at this image and check if there is a human face visible.
+Reply with ONLY this JSON (no markdown, no explanation):
+{"hasFace": true, "confidence": 0.9, "reason": "face visible"}
+
+If no face is visible:
+{"hasFace": false, "confidence": 0.1, "reason": "no face found"}`,
+} as const;

package/src/domains/face-detection/domain/entities/FaceDetection.ts

@@ -0,0 +1,19 @@
+/**
+ * Face Detection Types
+ */
+
+export interface FaceDetectionResult {
+  hasFace: boolean;
+  confidence: number;
+  message: string;
+}
+
+export interface FaceValidationState {
+  isValidating: boolean;
+  result: FaceDetectionResult | null;
+  error: string | null;
+}
+
+export interface FaceDetectionConfig {
+  minConfidence: number;
+}

package/src/domains/face-detection/index.ts

@@ -0,0 +1,26 @@
+/**
+ * React Native AI Face Detection - Public API
+ *
+ * AI-powered face detection for React Native apps using Gemini Vision
+ */
+
+export type {
+  FaceDetectionResult,
+  FaceValidationState,
+  FaceDetectionConfig,
+} from "./domain/entities/FaceDetection";
+
+export { FACE_DETECTION_CONFIG, FACE_DETECTION_PROMPTS } from "./domain/constants/faceDetectionConstants";
+
+export {
+  isValidFace,
+  parseDetectionResponse,
+  createFailedResult,
+  createSuccessResult,
+} from "./infrastructure/validators/faceValidator";
+
+export { analyzeImageForFace } from "./infrastructure/analyzers/faceAnalyzer";
+
+export { useFaceDetection } from "./presentation/hooks/useFaceDetection";
+
+export { FaceValidationStatus } from "./presentation/components/FaceValidationStatus";

package/src/domains/face-detection/infrastructure/analyzers/faceAnalyzer.ts

@@ -0,0 +1,36 @@
+/**
+ * Face Analyzer
+ *
+ * Analyzes images for face presence using Gemini AI.
+ */
+
+import { geminiProviderService } from "@umituz/react-native-ai-gemini-provider";
+import type { FaceDetectionResult } from "../../domain/entities/FaceDetection";
+import { FACE_DETECTION_PROMPTS } from "../../domain/constants/faceDetectionConstants";
+import {
+  parseDetectionResponse,
+  createFailedResult,
+} from "../validators/faceValidator";
+
+export const analyzeImageForFace = async (
+  base64Image: string,
+): Promise<FaceDetectionResult> => {
+  try {
+    const result = await geminiProviderService.run<{ text: string }>(
+      "gemini-2.0-flash-exp",
+      {
+        prompt: FACE_DETECTION_PROMPTS.analyze,
+        image_url: base64Image,
+      },
+    );
+
+    if (!result.text) {
+      return createFailedResult("No response from AI");
+    }
+
+    return parseDetectionResponse(result.text);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Analysis failed";
+    return createFailedResult(message);
+  }
+};

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

@@ -0,0 +1,52 @@
+/**
+ * Face Validator
+ *
+ * Pure functions for validating face detection results.
+ */
+
+import type { FaceDetectionResult } from "../../domain/entities/FaceDetection";
+import { FACE_DETECTION_CONFIG } from "../../domain/constants/faceDetectionConstants";
+
+export const isValidFace = (result: FaceDetectionResult): boolean => {
+  return (
+    result.hasFace && result.confidence >= FACE_DETECTION_CONFIG.minConfidence
+  );
+};
+
+export const parseDetectionResponse = (
+  response: string,
+): FaceDetectionResult => {
+  try {
+    let cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "");
+    cleaned = cleaned.trim();
+
+    const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      return createFailedResult("Invalid response format");
+    }
+
+    const parsed = JSON.parse(jsonMatch[0]);
+
+    return {
+      hasFace: Boolean(parsed.hasFace),
+      confidence: Number(parsed.confidence) || 0,
+      message: String(parsed.reason || ""),
+    };
+  } catch (error) {
+    return createFailedResult("Failed to parse response");
+  }
+};
+
+export const createFailedResult = (message: string): FaceDetectionResult => ({
+  hasFace: false,
+  confidence: 0,
+  message,
+});
+
+export const createSuccessResult = (
+  confidence: number,
+): FaceDetectionResult => ({
+  hasFace: true,
+  confidence,
+  message: "Face detected successfully",
+});

package/src/domains/face-detection/presentation/components/FaceValidationStatus.tsx

@@ -0,0 +1,111 @@
+/**
+ * FaceValidationStatus Component
+ *
+ * Displays face validation status with appropriate styling.
+ */
+
+import React from "react";
+import { View, StyleSheet, ActivityIndicator } from "react-native";
+import {
+  AtomicText,
+  AtomicIcon,
+  useAppDesignTokens,
+} from "@umituz/react-native-design-system";
+import { useLocalization } from "@umituz/react-native-localization";
+import type { FaceValidationState } from "../../domain/entities/FaceDetection";
+import { isValidFace } from "../../infrastructure/validators/faceValidator";
+
+interface FaceValidationStatusProps {
+  state: FaceValidationState;
+}
+
+export const FaceValidationStatus: React.FC<FaceValidationStatusProps> = ({
+  state,
+}) => {
+  const tokens = useAppDesignTokens();
+  const { t } = useLocalization();
+
+  if (state.isValidating) {
+    return (
+      <View
+        style={[styles.container, { backgroundColor: tokens.colors.surface }]}
+      >
+        <ActivityIndicator size="small" color={tokens.colors.primary} />
+        <AtomicText
+          style={[styles.text, { color: tokens.colors.textSecondary }]}
+        >
+          {t("faceDetection.analyzing")}
+        </AtomicText>
+      </View>
+    );
+  }
+
+  if (state.error) {
+    return (
+      <View
+        style={[
+          styles.container,
+          { backgroundColor: tokens.colors.errorContainer },
+        ]}
+      >
+        <AtomicIcon
+          name="alert-circle"
+          size={16}
+          customColor={tokens.colors.error}
+        />
+        <AtomicText style={[styles.text, { color: tokens.colors.error }]}>
+          {t("faceDetection.error")}
+        </AtomicText>
+      </View>
+    );
+  }
+
+  if (!state.result) {
+    return null;
+  }
+
+  const valid = isValidFace(state.result);
+
+  return (
+    <View
+      style={[
+        styles.container,
+        {
+          backgroundColor: valid
+            ? tokens.colors.successContainer
+            : tokens.colors.errorContainer,
+        },
+      ]}
+    >
+      <AtomicIcon
+        name={valid ? "checkmark-circle" : "close-circle"}
+        size={16}
+        customColor={valid ? tokens.colors.success : tokens.colors.error}
+      />
+      <AtomicText
+        style={[
+          styles.text,
+          { color: valid ? tokens.colors.success : tokens.colors.error },
+        ]}
+      >
+        {valid ? t("faceDetection.success") : t("faceDetection.noFace")}
+      </AtomicText>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flexDirection: "row",
+    alignItems: "center",
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    borderRadius: 8,
+    gap: 6,
+    marginTop: 8,
+  },
+  text: {
+    fontSize: 12,
+    fontWeight: "500",
+  },
+});

package/src/domains/face-detection/presentation/hooks/useFaceDetection.ts

@@ -0,0 +1,58 @@
+/**
+ * useFaceDetection Hook
+ *
+ * React hook for face detection functionality.
+ */
+
+import { useState, useCallback } from "react";
+import type {
+  FaceValidationState,
+  FaceDetectionResult,
+} from "../../domain/entities/FaceDetection";
+import { analyzeImageForFace } from "../../infrastructure/analyzers/faceAnalyzer";
+import { isValidFace } from "../../infrastructure/validators/faceValidator";
+
+interface UseFaceDetectionReturn {
+  state: FaceValidationState;
+  validateImage: (base64Image: string) => Promise<FaceDetectionResult>;
+  isValid: boolean;
+  reset: () => void;
+}
+
+const initialState: FaceValidationState = {
+  isValidating: false,
+  result: null,
+  error: null,
+};
+
+export const useFaceDetection = (): UseFaceDetectionReturn => {
+  const [state, setState] = useState<FaceValidationState>(initialState);
+
+  const validateImage = useCallback(async (base64Image: string) => {
+    setState({ isValidating: true, result: null, error: null });
+
+    try {
+      const result = await analyzeImageForFace(base64Image);
+      setState({ isValidating: false, result, error: null });
+      return result;
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message : "Validation failed";
+      setState({ isValidating: false, result: null, error: message });
+      throw error;
+    }
+  }, []);
+
+  const reset = useCallback(() => {
+    setState(initialState);
+  }, []);
+
+  const isValid = state.result ? isValidFace(state.result) : false;
+
+  return {
+    state,
+    validateImage,
+    isValid,
+    reset,
+  };
+};

package/src/domains/feature-background/domain/entities/background.types.ts

@@ -0,0 +1,77 @@
+/**
+ * Background Feature Types
+ * @description Core type definitions for background feature
+ */
+
+/**
+ * Studio mode for background operations
+ */
+export type StudioMode =
+    | "transparent"
+    | "remove-object"
+    | "replace-object"
+    | "relight"
+    | "creative-scene"
+    | "enhance"
+    | "clean-white"
+    | "portrait-blur";
+
+/**
+ * Background processing request input
+ */
+export interface BackgroundProcessRequest {
+    readonly imageUri: string;
+    readonly prompt?: string;
+    readonly mode?: StudioMode;
+    readonly mask?: string;
+}
+
+/**
+ * Background processing result
+ */
+export interface BackgroundProcessResult {
+    readonly success: boolean;
+    readonly imageUrl?: string;
+    readonly error?: string;
+    readonly requestId?: string;
+}
+
+/**
+ * Background feature state
+ */
+export interface BackgroundFeatureState {
+    readonly imageUri: string | null;
+    readonly prompt: string;
+    readonly processedUrl: string | null;
+    readonly isProcessing: boolean;
+    readonly progress: number;
+    readonly error: string | null;
+    readonly mode: StudioMode;
+}
+
+/**
+ * Sample prompt configuration
+ */
+export interface SamplePrompt {
+    readonly id: string;
+    readonly text: string;
+}
+
+/**
+ * Studio mode configuration
+ */
+export interface StudioModeConfig {
+    readonly id: StudioMode;
+    readonly icon: string;
+    readonly requiresPrompt?: boolean;
+    readonly requiresMask?: boolean;
+}
+
+/**
+ * Comparison view state
+ */
+export interface ComparisonState {
+    readonly originalUri: string | null;
+    readonly processedUri: string | null;
+    readonly position: number;
+}

package/src/domains/feature-background/domain/entities/component.types.ts

@@ -0,0 +1,96 @@
+/**
+ * Component Props Types
+ * @description Props definitions for background feature components
+ */
+
+import type { ImageSourcePropType } from "react-native";
+import type { SamplePrompt, StudioMode, StudioModeConfig } from "./background.types";
+
+/**
+ * Image picker component props
+ */
+export interface ImagePickerProps {
+    readonly imageUri: string | null;
+    readonly isProcessing: boolean;
+    readonly onSelectImage: () => void;
+    readonly placeholderText?: string;
+}
+
+/**
+ * Prompt input component props
+ */
+export interface PromptInputProps {
+    readonly value: string;
+    readonly onChangeText: (text: string) => void;
+    readonly isProcessing: boolean;
+    readonly label?: string;
+    readonly placeholder?: string;
+    readonly samplePrompts?: readonly SamplePrompt[];
+    readonly samplePromptsLabel?: string;
+}
+
+/**
+ * Generate button component props
+ */
+export interface GenerateButtonProps {
+    readonly isDisabled: boolean;
+    readonly isProcessing: boolean;
+    readonly onPress: () => void;
+    readonly buttonText?: string;
+}
+
+/**
+ * Result display component props
+ */
+export interface ResultDisplayProps {
+    readonly imageUrl: string | null;
+    readonly isProcessing: boolean;
+    readonly onSave: () => void;
+    readonly onReset: () => void;
+    readonly saveButtonText?: string;
+    readonly resetButtonText?: string;
+}
+
+/**
+ * Error display component props
+ */
+export interface ErrorDisplayProps {
+    readonly error: string | null;
+}
+
+/**
+ * Processing modal component props
+ */
+export interface ProcessingModalProps {
+    readonly visible: boolean;
+    readonly progress?: number;
+    readonly title?: string;
+}
+
+/**
+ * Feature header component props
+ */
+export interface FeatureHeaderProps {
+    readonly heroImage?: ImageSourcePropType;
+    readonly description?: string;
+}
+
+/**
+ * Mode selector component props
+ */
+export interface ModeSelectorProps {
+    readonly activeMode: StudioMode;
+    readonly onModeChange: (mode: StudioMode) => void;
+    readonly isProcessing: boolean;
+    readonly modes: readonly StudioModeConfig[];
+}
+
+/**
+ * Comparison slider component props
+ */
+export interface ComparisonSliderProps {
+    readonly originalUri: string;
+    readonly processedUri: string;
+    readonly beforeLabel?: string;
+    readonly afterLabel?: string;
+}

package/src/domains/feature-background/domain/entities/config.types.ts

@@ -0,0 +1,41 @@
+/**
+ * Configuration Types
+ * @description Configuration interfaces for background feature
+ */
+
+import type {
+    BackgroundProcessRequest,
+    BackgroundProcessResult,
+    StudioMode,
+} from "./background.types";
+
+/**
+ * Process request callback parameters
+ */
+export interface ProcessRequestParams extends BackgroundProcessRequest {
+    readonly onProgress?: (progress: number) => void;
+}
+
+/**
+ * Background feature configuration
+ */
+export interface BackgroundFeatureConfig {
+    readonly onProcess: (
+        params: ProcessRequestParams
+    ) => Promise<BackgroundProcessResult>;
+    readonly onSave?: (imageUrl: string) => Promise<void>;
+    readonly onError?: (error: Error) => void;
+    readonly onSuccess?: (result: BackgroundProcessResult) => void;
+    readonly defaultMode?: StudioMode;
+}
+
+/**
+ * Hook configuration
+ */
+export interface UseBackgroundFeatureConfig {
+    readonly processRequest: (
+        params: ProcessRequestParams
+    ) => Promise<BackgroundProcessResult>;
+    readonly onSelectImage?: () => Promise<string | null>;
+    readonly defaultMode?: StudioMode;
+}

package/src/domains/feature-background/domain/entities/index.ts

@@ -0,0 +1,31 @@
+/**
+ * Domain Entities Export
+ */
+
+export type {
+    BackgroundProcessRequest,
+    BackgroundProcessResult,
+    BackgroundFeatureState,
+    SamplePrompt,
+    StudioMode,
+    StudioModeConfig,
+    ComparisonState,
+} from "./background.types";
+
+export type {
+    ImagePickerProps,
+    PromptInputProps,
+    GenerateButtonProps,
+    ResultDisplayProps,
+    ErrorDisplayProps,
+    ProcessingModalProps,
+    FeatureHeaderProps,
+    ModeSelectorProps,
+    ComparisonSliderProps,
+} from "./component.types";
+
+export type {
+    ProcessRequestParams,
+    BackgroundFeatureConfig,
+    UseBackgroundFeatureConfig,
+} from "./config.types";