@umituz/react-native-ai-generation-content 1.17.9 → 1.17.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.17.9",
+  "version": "1.17.11",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/features/hd-touch-up/domain/index.ts

@@ -0,0 +1 @@
+export * from "./types";

package/src/features/hd-touch-up/domain/types/hd-touch-up.types.ts

@@ -0,0 +1,69 @@
+/**
+ * HD Touch Up Feature Types
+ * Request, Result, Config types for HD enhancement
+ */
+
+export interface HDTouchUpOptions {
+  enhanceQuality?: boolean;
+  upscaleFactor?: 2 | 4;
+  sharpen?: boolean;
+}
+
+export interface HDTouchUpRequest {
+  imageUri: string;
+  imageBase64?: string;
+  userId: string;
+  options?: HDTouchUpOptions;
+}
+
+export interface HDTouchUpResult {
+  success: boolean;
+  imageUrl?: string;
+  imageBase64?: string;
+  error?: string;
+  requestId?: string;
+}
+
+export interface HDTouchUpFeatureState {
+  imageUri: string | null;
+  processedUrl: string | null;
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+}
+
+export interface HDTouchUpTranslations {
+  uploadTitle: string;
+  uploadSubtitle: string;
+  uploadChange: string;
+  uploadAnalyzing: string;
+  description: string;
+  processingText: string;
+  processButtonText: string;
+  successText: string;
+  saveButtonText: string;
+  tryAnotherText: string;
+  beforeLabel?: string;
+  afterLabel?: string;
+  compareHint?: string;
+}
+
+export type HDTouchUpInputBuilder = (
+  base64: string,
+  options?: HDTouchUpOptions,
+) => Record<string, unknown>;
+
+export type HDTouchUpResultExtractor = (result: unknown) => string | undefined;
+
+export interface HDTouchUpFeatureConfig {
+  providerId?: string;
+  creditCost?: number;
+  model: string;
+  buildInput: HDTouchUpInputBuilder;
+  extractResult?: HDTouchUpResultExtractor;
+  prepareImage: (imageUri: string) => Promise<string>;
+  onImageSelect?: (uri: string) => void;
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: HDTouchUpResult) => void;
+  onError?: (error: string) => void;
+}

package/src/features/hd-touch-up/domain/types/index.ts

@@ -0,0 +1,10 @@
+export type {
+  HDTouchUpOptions,
+  HDTouchUpRequest,
+  HDTouchUpResult,
+  HDTouchUpFeatureState,
+  HDTouchUpTranslations,
+  HDTouchUpInputBuilder,
+  HDTouchUpResultExtractor,
+  HDTouchUpFeatureConfig,
+} from "./hd-touch-up.types";

package/src/features/hd-touch-up/index.ts

@@ -0,0 +1,31 @@
+/**
+ * HD Touch Up Feature
+ * Provider-agnostic HD enhancement feature
+ */
+
+// Domain Types
+export type {
+  HDTouchUpOptions,
+  HDTouchUpRequest,
+  HDTouchUpResult,
+  HDTouchUpFeatureState,
+  HDTouchUpTranslations,
+  HDTouchUpFeatureConfig,
+  HDTouchUpInputBuilder,
+  HDTouchUpResultExtractor,
+} from "./domain";
+
+// Infrastructure Services
+export { executeHDTouchUp, hasHDTouchUpSupport } from "./infrastructure";
+export type { ExecuteHDTouchUpOptions } from "./infrastructure";
+
+// Presentation Hooks
+export { useHDTouchUpFeature } from "./presentation";
+export type {
+  UseHDTouchUpFeatureProps,
+  UseHDTouchUpFeatureReturn,
+} from "./presentation";
+
+// Presentation Components
+export { HDTouchUpFeature } from "./presentation";
+export type { HDTouchUpFeatureProps } from "./presentation";

package/src/features/hd-touch-up/infrastructure/index.ts

@@ -0,0 +1 @@
+export * from "./services";

package/src/features/hd-touch-up/infrastructure/services/hd-touch-up-executor.ts

@@ -0,0 +1,97 @@
+/**
+ * HD Touch Up Executor
+ * Executes HD enhancement using the configured provider
+ */
+
+import { providerRegistry } from "../../../../infrastructure/services";
+import type {
+  HDTouchUpRequest,
+  HDTouchUpResult,
+  HDTouchUpInputBuilder,
+  HDTouchUpResultExtractor,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface ExecuteHDTouchUpOptions {
+  model: string;
+  buildInput: HDTouchUpInputBuilder;
+  extractResult?: HDTouchUpResultExtractor;
+  onProgress?: (progress: number) => void;
+}
+
+export async function executeHDTouchUp(
+  request: HDTouchUpRequest,
+  options: ExecuteHDTouchUpOptions,
+): Promise<HDTouchUpResult> {
+  const { model, buildInput, extractResult, onProgress } = options;
+
+  try {
+    const provider = providerRegistry.getActiveProvider();
+    if (!provider) {
+      return {
+        success: false,
+        error: "No AI provider configured",
+      };
+    }
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[HDTouchUp] Starting HD enhancement with model:", model);
+    }
+
+    onProgress?.(10);
+
+    const imageBase64 = request.imageBase64;
+    if (!imageBase64) {
+      return {
+        success: false,
+        error: "Image base64 is required",
+      };
+    }
+
+    const input = buildInput(imageBase64, request.options);
+
+    onProgress?.(30);
+
+    const result = await provider.generate(model, input, request.userId);
+
+    onProgress?.(80);
+
+    const imageUrl = extractResult
+      ? extractResult(result)
+      : (result as { imageUrl?: string })?.imageUrl ||
+        (result as { image?: string })?.image ||
+        (result as { output?: string })?.output;
+
+    onProgress?.(100);
+
+    if (imageUrl) {
+      return {
+        success: true,
+        imageUrl,
+        requestId: (result as { requestId?: string })?.requestId,
+      };
+    }
+
+    return {
+      success: false,
+      error: "No image URL in response",
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.error("[HDTouchUp] Error:", message);
+    }
+    return {
+      success: false,
+      error: message,
+    };
+  }
+}
+
+export function hasHDTouchUpSupport(): boolean {
+  const provider = providerRegistry.getActiveProvider();
+  return !!provider;
+}

package/src/features/hd-touch-up/infrastructure/services/index.ts

@@ -0,0 +1,2 @@
+export { executeHDTouchUp, hasHDTouchUpSupport } from "./hd-touch-up-executor";
+export type { ExecuteHDTouchUpOptions } from "./hd-touch-up-executor";

package/src/features/hd-touch-up/presentation/components/HDTouchUpFeature.tsx

@@ -0,0 +1,199 @@
+/**
+ * HDTouchUpFeature Component
+ * Self-contained HD touch up feature UI component
+ * Uses hook internally, only requires config and translations
+ */
+
+import React, { useCallback, useMemo } from "react";
+import { View, ScrollView, StyleSheet, Image, Dimensions } from "react-native";
+import {
+  useAppDesignTokens,
+  AtomicText,
+  AtomicButton,
+} from "@umituz/react-native-design-system";
+import { PhotoUploadCard } from "../../../../presentation/components/PhotoUploadCard";
+import { ErrorDisplay } from "../../../../presentation/components/display/ErrorDisplay";
+import { useHDTouchUpFeature } from "../hooks";
+import type {
+  HDTouchUpTranslations,
+  HDTouchUpFeatureConfig,
+} from "../../domain/types";
+
+export interface HDTouchUpFeatureProps {
+  config: HDTouchUpFeatureConfig;
+  userId: string;
+  translations: HDTouchUpTranslations;
+  onSelectImage: () => Promise<string | null>;
+  onSaveImage: (imageUrl: string) => Promise<void>;
+  renderProcessingModal?: (props: {
+    visible: boolean;
+    progress: number;
+  }) => React.ReactNode;
+}
+
+export const HDTouchUpFeature: React.FC<HDTouchUpFeatureProps> = ({
+  config,
+  userId,
+  translations,
+  onSelectImage,
+  onSaveImage,
+  renderProcessingModal,
+}) => {
+  const tokens = useAppDesignTokens();
+
+  const feature = useHDTouchUpFeature({
+    config,
+    userId,
+    onSelectImage,
+    onSaveImage,
+  });
+
+  const photoTranslations = useMemo(
+    () => ({
+      tapToUpload: translations.uploadTitle,
+      selectPhoto: translations.uploadSubtitle,
+      change: translations.uploadChange,
+      analyzing: translations.uploadAnalyzing,
+    }),
+    [translations],
+  );
+
+  const handleProcess = useCallback(() => {
+    void feature.process();
+  }, [feature]);
+
+  const handleSave = useCallback(() => {
+    void feature.save();
+  }, [feature]);
+
+  const handleSelectImage = useCallback(() => {
+    void feature.selectImage();
+  }, [feature]);
+
+  if (feature.processedUrl) {
+    const screenWidth = Dimensions.get("window").width;
+    const imageSize = screenWidth - 48;
+
+    return (
+      <ScrollView
+        style={[styles.container, { backgroundColor: tokens.colors.backgroundPrimary }]}
+        contentContainerStyle={styles.content}
+        showsVerticalScrollIndicator={false}
+      >
+        <AtomicText
+          type="headlineMedium"
+          style={[styles.successText, { color: tokens.colors.success }]}
+        >
+          {translations.successText}
+        </AtomicText>
+
+        <View style={styles.resultImageContainer}>
+          <Image
+            source={{ uri: feature.processedUrl }}
+            style={[styles.resultImage, { width: imageSize, height: imageSize }]}
+            resizeMode="contain"
+          />
+        </View>
+
+        <View style={styles.resultActions}>
+          <AtomicButton
+            title={translations.saveButtonText}
+            onPress={handleSave}
+            variant="primary"
+            size="lg"
+          />
+          <AtomicButton
+            title={translations.tryAnotherText}
+            onPress={feature.reset}
+            variant="secondary"
+            size="lg"
+          />
+        </View>
+      </ScrollView>
+    );
+  }
+
+  return (
+    <>
+      <ScrollView
+        style={[styles.container, { backgroundColor: tokens.colors.backgroundPrimary }]}
+        contentContainerStyle={styles.content}
+        showsVerticalScrollIndicator={false}
+      >
+        <AtomicText
+          type="bodyLarge"
+          style={[styles.description, { color: tokens.colors.textSecondary }]}
+        >
+          {translations.description}
+        </AtomicText>
+
+        <PhotoUploadCard
+          imageUri={feature.imageUri}
+          onPress={handleSelectImage}
+          isValidating={feature.isProcessing}
+          disabled={feature.isProcessing}
+          translations={photoTranslations}
+          config={{
+            aspectRatio: 1,
+            borderRadius: 24,
+            showValidationStatus: false,
+            allowChange: true,
+          }}
+        />
+
+        <ErrorDisplay error={feature.error} />
+
+        <View style={styles.buttonContainer}>
+          <AtomicButton
+            title={
+              feature.isProcessing
+                ? translations.processingText
+                : translations.processButtonText
+            }
+            onPress={handleProcess}
+            disabled={!feature.imageUri || feature.isProcessing}
+            variant="primary"
+            size="lg"
+          />
+        </View>
+      </ScrollView>
+
+      {renderProcessingModal?.({ visible: feature.isProcessing, progress: feature.progress })}
+    </>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+  content: {
+    paddingVertical: 16,
+  },
+  description: {
+    textAlign: "center",
+    marginHorizontal: 24,
+    marginBottom: 24,
+    lineHeight: 24,
+  },
+  successText: {
+    textAlign: "center",
+    marginBottom: 24,
+  },
+  resultImageContainer: {
+    alignItems: "center",
+    marginHorizontal: 24,
+    marginBottom: 24,
+  },
+  resultImage: {
+    borderRadius: 16,
+  },
+  resultActions: {
+    marginHorizontal: 24,
+    gap: 12,
+  },
+  buttonContainer: {
+    marginHorizontal: 24,
+    marginTop: 8,
+  },
+});

package/src/features/hd-touch-up/presentation/components/index.ts

@@ -0,0 +1,2 @@
+export { HDTouchUpFeature } from "./HDTouchUpFeature";
+export type { HDTouchUpFeatureProps } from "./HDTouchUpFeature";

package/src/features/hd-touch-up/presentation/hooks/index.ts

@@ -0,0 +1,5 @@
+export { useHDTouchUpFeature } from "./useHDTouchUpFeature";
+export type {
+  UseHDTouchUpFeatureProps,
+  UseHDTouchUpFeatureReturn,
+} from "./useHDTouchUpFeature";

package/src/features/hd-touch-up/presentation/hooks/useHDTouchUpFeature.ts

@@ -0,0 +1,137 @@
+/**
+ * useHDTouchUpFeature Hook
+ * Manages HD touch up feature state and actions
+ */
+
+import { useState, useCallback } from "react";
+import { executeHDTouchUp } from "../../infrastructure/services";
+import type {
+  HDTouchUpFeatureState,
+  HDTouchUpFeatureConfig,
+  HDTouchUpResult,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface UseHDTouchUpFeatureProps {
+  config: HDTouchUpFeatureConfig;
+  userId: string;
+  onSelectImage: () => Promise<string | null>;
+  onSaveImage: (imageUrl: string) => Promise<void>;
+}
+
+export interface UseHDTouchUpFeatureReturn extends HDTouchUpFeatureState {
+  selectImage: () => Promise<void>;
+  process: () => Promise<void>;
+  save: () => Promise<void>;
+  reset: () => void;
+}
+
+const initialState: HDTouchUpFeatureState = {
+  imageUri: null,
+  processedUrl: null,
+  isProcessing: false,
+  progress: 0,
+  error: null,
+};
+
+export function useHDTouchUpFeature(
+  props: UseHDTouchUpFeatureProps,
+): UseHDTouchUpFeatureReturn {
+  const { config, userId, onSelectImage, onSaveImage } = props;
+  const [state, setState] = useState<HDTouchUpFeatureState>(initialState);
+
+  const selectImage = useCallback(async () => {
+    try {
+      const uri = await onSelectImage();
+      if (uri) {
+        setState((prev) => ({ ...prev, imageUri: uri, error: null }));
+        config.onImageSelect?.(uri);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      setState((prev) => ({ ...prev, error: message }));
+    }
+  }, [onSelectImage, config]);
+
+  const handleProgress = useCallback((progress: number) => {
+    setState((prev) => ({ ...prev, progress }));
+  }, []);
+
+  const process = useCallback(async () => {
+    if (!state.imageUri) return;
+
+    setState((prev) => ({
+      ...prev,
+      isProcessing: true,
+      progress: 0,
+      error: null,
+    }));
+
+    config.onProcessingStart?.();
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[useHDTouchUpFeature] Starting HD enhancement");
+    }
+
+    const imageBase64 = await config.prepareImage(state.imageUri);
+
+    const result: HDTouchUpResult = await executeHDTouchUp(
+      {
+        imageUri: state.imageUri,
+        imageBase64,
+        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.imageUri, 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,
+    selectImage,
+    process,
+    save,
+    reset,
+  };
+}

package/src/features/hd-touch-up/presentation/index.ts

@@ -0,0 +1,2 @@
+export * from "./hooks";
+export * from "./components";

package/src/features/photo-restoration/presentation/components/PhotoRestoreResultView.tsx

@@ -10,7 +10,7 @@ import {
   AtomicButton,
   useAppDesignTokens,
 } from "@umituz/react-native-design-system";
-import { ComparisonSlider } from "../../../background/presentation/components/ComparisonSlider";
+import { ComparisonSlider } from "../../../replace-background/presentation/components/ComparisonSlider";
 import type { PhotoRestoreTranslations } from "../../domain/types";
 
 export interface PhotoRestoreResultViewProps {

package/src/index.ts

@@ -329,7 +329,7 @@ export * from "./domains/face-detection";
 // FEATURES - Background
 // =============================================================================
 
-export * from "./features/background";
+export * from "./features/replace-background";
 
 // =============================================================================
 // FEATURES - Upscaling
@@ -403,3 +403,9 @@ export * from "./features/image-to-video";
 
 export * from "./features/text-to-voice";
 
+// =============================================================================
+// FEATURES - HD Touch Up
+// =============================================================================
+
+export * from "./features/hd-touch-up";
+