@umituz/react-native-ai-generation-content 1.15.0 → 1.15.2

package/package.json

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

package/src/features/audio-generation/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/colorization/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/face-swap/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/future-prediction/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/image-captioning/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/inpainting/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/photo-restoration/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/sketch-to-image/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/style-transfer/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/text-to-image/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/text-to-video/index.ts

@@ -1,2 +1 @@
 export * from './domain/entities';
-export * from './presentation/hooks';

package/src/features/upscaling/domain/index.ts

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

package/src/features/upscaling/domain/types/index.ts

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

package/src/features/upscaling/domain/types/provider.types.ts

@@ -0,0 +1,23 @@
+/**
+ * Upscale Provider Types
+ * Interface for provider implementations
+ */
+
+import type { UpscaleRequest, UpscaleResult } from "./upscale.types";
+
+export interface IUpscaleProvider {
+  readonly providerId: string;
+  readonly providerName: string;
+
+  isAvailable(): boolean;
+
+  upscale(
+    request: UpscaleRequest,
+    onProgress?: (progress: number) => void,
+  ): Promise<UpscaleResult>;
+}
+
+export interface UpscaleProviderEntry {
+  provider: IUpscaleProvider;
+  priority: number;
+}

package/src/features/upscaling/domain/types/upscale.types.ts

@@ -0,0 +1,56 @@
+/**
+ * Upscale Feature Types
+ * Request, Result, Config types for upscaling
+ */
+
+export type UpscaleScaleFactor = 2 | 4 | 8;
+
+export interface UpscaleOptions {
+  scaleFactor?: UpscaleScaleFactor;
+  enhanceFaces?: boolean;
+}
+
+export interface UpscaleRequest {
+  imageUri: string;
+  userId: string;
+  options?: UpscaleOptions;
+}
+
+export interface UpscaleResult {
+  success: boolean;
+  imageUrl?: string;
+  imageBase64?: string;
+  error?: string;
+  requestId?: string;
+}
+
+export interface UpscaleFeatureState {
+  imageUri: string | null;
+  processedUrl: string | null;
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+}
+
+export interface UpscaleTranslations {
+  uploadTitle: string;
+  uploadSubtitle: string;
+  uploadChange: string;
+  uploadAnalyzing: string;
+  description: string;
+  processingText: string;
+  processButtonText: string;
+  successText: string;
+  saveButtonText: string;
+  tryAnotherText: string;
+}
+
+export interface UpscaleFeatureConfig {
+  providerId?: string;
+  defaultScaleFactor?: UpscaleScaleFactor;
+  creditCost?: number;
+  onImageSelect?: (uri: string) => void;
+  onProcessingStart?: () => void;
+  onProcessingComplete?: (result: UpscaleResult) => void;
+  onError?: (error: string) => void;
+}

package/src/features/upscaling/index.ts

@@ -1,2 +1,40 @@
-export * from './domain/entities';
-export * from './presentation/hooks';
+/**
+ * Upscaling Feature
+ * Provider-agnostic image upscaling feature
+ */
+
+// Domain Types
+export type {
+  UpscaleScaleFactor,
+  UpscaleOptions,
+  UpscaleRequest,
+  UpscaleResult,
+  UpscaleFeatureState,
+  UpscaleTranslations,
+  UpscaleFeatureConfig,
+  IUpscaleProvider,
+  UpscaleProviderEntry,
+} from "./domain";
+
+// Infrastructure Services
+export {
+  upscaleProviderRegistry,
+  executeUpscale,
+  getAvailableProvider,
+  hasUpscaleProvider,
+} from "./infrastructure";
+export type { ExecuteUpscaleOptions } from "./infrastructure";
+
+// Presentation Hooks
+export { useUpscaleFeature } from "./presentation";
+export type {
+  UseUpscaleFeatureProps,
+  UseUpscaleFeatureReturn,
+} from "./presentation";
+
+// Presentation Components
+export { UpscaleFeature, UpscaleResultView } from "./presentation";
+export type {
+  UpscaleFeatureProps,
+  UpscaleResultViewProps,
+} from "./presentation";

package/src/features/upscaling/infrastructure/index.ts

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

package/src/features/upscaling/infrastructure/services/index.ts

@@ -0,0 +1,7 @@
+export { upscaleProviderRegistry } from "./upscale-provider-registry";
+export {
+  executeUpscale,
+  getAvailableProvider,
+  hasUpscaleProvider,
+} from "./upscale-executor";
+export type { ExecuteUpscaleOptions } from "./upscale-executor";

package/src/features/upscaling/infrastructure/services/upscale-executor.ts

@@ -0,0 +1,64 @@
+/**
+ * Upscale Executor
+ * Executes upscale operations using registered providers
+ */
+
+import { upscaleProviderRegistry } from "./upscale-provider-registry";
+import type { UpscaleRequest, UpscaleResult } from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+export interface ExecuteUpscaleOptions {
+  providerId?: string;
+  onProgress?: (progress: number) => void;
+}
+
+export async function executeUpscale(
+  request: UpscaleRequest,
+  options?: ExecuteUpscaleOptions,
+): Promise<UpscaleResult> {
+  const provider = upscaleProviderRegistry.get(options?.providerId);
+
+  if (!provider) {
+    return {
+      success: false,
+      error: "No upscale provider available",
+    };
+  }
+
+  if (!provider.isAvailable()) {
+    return {
+      success: false,
+      error: `Provider ${provider.providerId} is not available`,
+    };
+  }
+
+  if (__DEV__) {
+    // eslint-disable-next-line no-console
+    console.log(`[UpscaleExecutor] Using provider: ${provider.providerId}`);
+  }
+
+  try {
+    return await provider.upscale(request, options?.onProgress);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.error("[UpscaleExecutor] Error:", message);
+    }
+
+    return {
+      success: false,
+      error: message,
+    };
+  }
+}
+
+export function getAvailableProvider(providerId?: string) {
+  return upscaleProviderRegistry.get(providerId);
+}
+
+export function hasUpscaleProvider(providerId: string): boolean {
+  return upscaleProviderRegistry.hasProvider(providerId);
+}

package/src/features/upscaling/infrastructure/services/upscale-provider-registry.ts

@@ -0,0 +1,77 @@
+/**
+ * Upscale Provider Registry
+ * Manages registered upscale providers
+ */
+
+import type {
+  IUpscaleProvider,
+  UpscaleProviderEntry,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+class UpscaleProviderRegistry {
+  private providers: Map<string, UpscaleProviderEntry> = new Map();
+  private defaultProviderId: string | null = null;
+
+  register(provider: IUpscaleProvider, priority = 0): void {
+    this.providers.set(provider.providerId, { provider, priority });
+
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log(
+        `[UpscaleRegistry] Registered provider: ${provider.providerId}`,
+      );
+    }
+  }
+
+  unregister(providerId: string): void {
+    this.providers.delete(providerId);
+  }
+
+  setDefault(providerId: string): void {
+    if (!this.providers.has(providerId)) {
+      throw new Error(`Provider ${providerId} not registered`);
+    }
+    this.defaultProviderId = providerId;
+  }
+
+  get(providerId?: string): IUpscaleProvider | null {
+    const id = providerId || this.defaultProviderId;
+    if (!id) return this.getHighestPriority();
+
+    const entry = this.providers.get(id);
+    return entry?.provider || null;
+  }
+
+  getAvailable(): IUpscaleProvider | null {
+    const sorted = this.getSortedProviders();
+    return sorted.find((p) => p.isAvailable()) || null;
+  }
+
+  hasProvider(providerId: string): boolean {
+    return this.providers.has(providerId);
+  }
+
+  getProviderIds(): string[] {
+    return Array.from(this.providers.keys());
+  }
+
+  private getHighestPriority(): IUpscaleProvider | null {
+    const sorted = this.getSortedProviders();
+    return sorted[0] || null;
+  }
+
+  private getSortedProviders(): IUpscaleProvider[] {
+    return Array.from(this.providers.values())
+      .sort((a, b) => b.priority - a.priority)
+      .map((entry) => entry.provider);
+  }
+
+  reset(): void {
+    this.providers.clear();
+    this.defaultProviderId = null;
+  }
+}
+
+export const upscaleProviderRegistry = new UpscaleProviderRegistry();

package/src/features/upscaling/presentation/components/UpscaleFeature.tsx

@@ -0,0 +1,168 @@
+/**
+ * UpscaleFeature Component
+ * Main upscale feature UI component
+ */
+
+import React, { useCallback, useMemo } from "react";
+import { View, ScrollView, StyleSheet } from "react-native";
+import {
+  useAppDesignTokens,
+  PhotoUploadCard,
+  AtomicText,
+  AtomicButton,
+} from "@umituz/react-native-design-system";
+import { UpscaleResultView } from "./UpscaleResultView";
+import type {
+  UpscaleTranslations,
+  UpscaleFeatureConfig,
+} from "../../domain/types";
+
+export interface UpscaleFeatureProps {
+  imageUri: string | null;
+  processedUrl: string | null;
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+  translations: UpscaleTranslations;
+  config?: UpscaleFeatureConfig;
+  onSelectImage: () => void;
+  onProcess: () => void;
+  onSave: () => void;
+  onReset: () => void;
+  renderProcessingModal?: (props: {
+    visible: boolean;
+    progress: number;
+  }) => React.ReactNode;
+}
+
+export const UpscaleFeature: React.FC<UpscaleFeatureProps> = ({
+  imageUri,
+  processedUrl,
+  isProcessing,
+  progress,
+  error,
+  translations,
+  onSelectImage,
+  onProcess,
+  onSave,
+  onReset,
+  renderProcessingModal,
+}) => {
+  const tokens = useAppDesignTokens();
+
+  const photoTranslations = useMemo(
+    () => ({
+      tapToUpload: translations.uploadTitle,
+      selectPhoto: translations.uploadSubtitle,
+      change: translations.uploadChange,
+      analyzing: translations.uploadAnalyzing,
+    }),
+    [translations],
+  );
+
+  const handleProcess = useCallback(() => {
+    onProcess();
+  }, [onProcess]);
+
+  if (processedUrl) {
+    return (
+      <ScrollView
+        style={[styles.container, { backgroundColor: tokens.colors.backgroundPrimary }]}
+        contentContainerStyle={styles.content}
+        showsVerticalScrollIndicator={false}
+      >
+        <UpscaleResultView
+          imageUrl={processedUrl}
+          translations={translations}
+          onSave={onSave}
+          onReset={onReset}
+        />
+      </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={imageUri}
+          onPress={onSelectImage}
+          isValidating={isProcessing}
+          disabled={isProcessing}
+          translations={photoTranslations}
+          config={{
+            aspectRatio: 1,
+            borderRadius: 24,
+            showValidationStatus: false,
+            allowChange: true,
+          }}
+        />
+
+        {error && (
+          <View
+            style={[
+              styles.errorContainer,
+              { backgroundColor: `${tokens.colors.error}15` },
+            ]}
+          >
+            <AtomicText type="bodyMedium" style={{ color: tokens.colors.error }}>
+              {error}
+            </AtomicText>
+          </View>
+        )}
+
+        <View style={styles.buttonContainer}>
+          <AtomicButton
+            title={
+              isProcessing
+                ? translations.processingText
+                : translations.processButtonText
+            }
+            onPress={handleProcess}
+            disabled={!imageUri || isProcessing}
+            variant="primary"
+            size="lg"
+          />
+        </View>
+      </ScrollView>
+
+      {renderProcessingModal?.({ visible: isProcessing, progress })}
+    </>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+  content: {
+    paddingVertical: 16,
+  },
+  description: {
+    textAlign: "center",
+    marginHorizontal: 24,
+    marginBottom: 24,
+    lineHeight: 24,
+  },
+  errorContainer: {
+    marginHorizontal: 24,
+    marginBottom: 16,
+    padding: 16,
+    borderRadius: 12,
+  },
+  buttonContainer: {
+    marginHorizontal: 24,
+    marginTop: 8,
+  },
+});

package/src/features/upscaling/presentation/components/UpscaleResultView.tsx

@@ -0,0 +1,94 @@
+/**
+ * UpscaleResultView Component
+ * Displays the upscaled image result
+ */
+
+import React from "react";
+import { View, Image, StyleSheet } from "react-native";
+import {
+  AtomicText,
+  AtomicButton,
+  useAppDesignTokens,
+} from "@umituz/react-native-design-system";
+import type { UpscaleTranslations } from "../../domain/types";
+
+export interface UpscaleResultViewProps {
+  imageUrl: string;
+  translations: Pick<
+    UpscaleTranslations,
+    "successText" | "saveButtonText" | "tryAnotherText"
+  >;
+  onSave: () => void;
+  onReset: () => void;
+}
+
+export const UpscaleResultView: React.FC<UpscaleResultViewProps> = ({
+  imageUrl,
+  translations,
+  onSave,
+  onReset,
+}) => {
+  const tokens = useAppDesignTokens();
+
+  return (
+    <View style={styles.container}>
+      <AtomicText
+        type="headlineMedium"
+        style={[styles.title, { color: tokens.colors.success }]}
+      >
+        {translations.successText}
+      </AtomicText>
+
+      <View
+        style={[
+          styles.imageCard,
+          { backgroundColor: tokens.colors.surfaceSecondary },
+        ]}
+      >
+        <Image
+          source={{ uri: imageUrl }}
+          style={styles.image}
+          resizeMode="contain"
+        />
+      </View>
+
+      <View style={styles.actions}>
+        <AtomicButton
+          title={translations.saveButtonText}
+          onPress={onSave}
+          variant="primary"
+          size="lg"
+        />
+        <AtomicButton
+          title={translations.tryAnotherText}
+          onPress={onReset}
+          variant="secondary"
+          size="lg"
+        />
+      </View>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    paddingHorizontal: 24,
+  },
+  title: {
+    textAlign: "center",
+    marginBottom: 24,
+  },
+  imageCard: {
+    borderRadius: 24,
+    overflow: "hidden",
+    marginBottom: 24,
+  },
+  image: {
+    width: "100%",
+    aspectRatio: 1,
+  },
+  actions: {
+    gap: 12,
+  },
+});

package/src/features/upscaling/presentation/components/index.ts

@@ -0,0 +1,4 @@
+export { UpscaleFeature } from "./UpscaleFeature";
+export { UpscaleResultView } from "./UpscaleResultView";
+export type { UpscaleFeatureProps } from "./UpscaleFeature";
+export type { UpscaleResultViewProps } from "./UpscaleResultView";

package/src/features/upscaling/presentation/hooks/index.ts

@@ -0,0 +1,5 @@
+export { useUpscaleFeature } from "./useUpscaleFeature";
+export type {
+  UseUpscaleFeatureProps,
+  UseUpscaleFeatureReturn,
+} from "./useUpscaleFeature";