@umituz/react-native-ai-gemini-provider 1.10.7 → 1.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "1.10.7",
+  "version": "1.12.0",
   "description": "Google Gemini AI provider for React Native applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Domains - DDD-organized features
+ */
+
+export * from "./upscaling";

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

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

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

@@ -0,0 +1,9 @@
+export type {
+  UpscaleScaleFactor,
+  UpscaleOptions,
+  UpscaleInput,
+  UpscaleResult,
+  PreparedImage,
+  UseUpscaleConfig,
+  UseUpscaleReturn,
+} from "./upscale.types";

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

@@ -0,0 +1,47 @@
+/**
+ * Upscale Types
+ */
+
+export type UpscaleScaleFactor = 2 | 4 | 8;
+
+export interface UpscaleOptions {
+  scaleFactor?: UpscaleScaleFactor;
+  enhanceFaces?: boolean;
+  enhanceDetails?: boolean;
+}
+
+export interface UpscaleInput {
+  base64: string;
+  mimeType: string;
+  options?: UpscaleOptions;
+}
+
+export interface UpscaleResult {
+  success: boolean;
+  imageUrl?: string;
+  imageBase64?: string;
+  mimeType?: string;
+  error?: string;
+}
+
+export interface PreparedImage {
+  base64: string;
+  mimeType: string;
+}
+
+export interface UseUpscaleConfig {
+  defaultScaleFactor?: UpscaleScaleFactor;
+  onSuccess?: (result: UpscaleResult) => void;
+  onError?: (error: string) => void;
+}
+
+export interface UseUpscaleReturn {
+  imageUri: string | null;
+  processedUrl: string | null;
+  isProcessing: boolean;
+  progress: number;
+  error: string | null;
+  setImageUri: (uri: string) => void;
+  process: () => Promise<void>;
+  reset: () => void;
+}

package/src/domains/upscaling/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Upscaling Domain - Public API
+ *
+ * Exports GeminiUpscaleProvider for use with content package registry
+ */
+
+// Provider (implements IUpscaleProvider)
+export {
+  geminiUpscaleProvider,
+  type IUpscaleProvider,
+  type UpscaleRequest,
+  type UpscaleResult,
+} from "./infrastructure/providers";
+
+// Internal types (for advanced usage)
+export type {
+  UpscaleScaleFactor,
+  UpscaleOptions,
+  UpscaleInput,
+  PreparedImage,
+} from "./domain/types";

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

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

package/src/domains/upscaling/infrastructure/providers/gemini-upscale.provider.ts

@@ -0,0 +1,109 @@
+/**
+ * Gemini Upscale Provider
+ * Implements IUpscaleProvider for content package integration
+ */
+
+import { upscaleService } from "../services/upscale.service";
+import { prepareImage } from "../utils/image-preparer.util";
+
+declare const __DEV__: boolean;
+
+/**
+ * Provider interface matching content package's IUpscaleProvider
+ * Re-defined here to avoid cross-package dependency
+ */
+export interface UpscaleRequest {
+  imageUri: string;
+  userId: string;
+  options?: {
+    scaleFactor?: 2 | 4 | 8;
+    enhanceFaces?: boolean;
+  };
+}
+
+export interface UpscaleResult {
+  success: boolean;
+  imageUrl?: string;
+  imageBase64?: string;
+  error?: string;
+  requestId?: string;
+}
+
+export interface IUpscaleProvider {
+  readonly providerId: string;
+  readonly providerName: string;
+  isAvailable(): boolean;
+  upscale(
+    request: UpscaleRequest,
+    onProgress?: (progress: number) => void
+  ): Promise<UpscaleResult>;
+}
+
+class GeminiUpscaleProvider implements IUpscaleProvider {
+  readonly providerId = "gemini";
+  readonly providerName = "Google Gemini";
+
+  isAvailable(): boolean {
+    return true;
+  }
+
+  async upscale(
+    request: UpscaleRequest,
+    onProgress?: (progress: number) => void
+  ): Promise<UpscaleResult> {
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiUpscaleProvider] Starting upscale");
+    }
+
+    try {
+      onProgress?.(10);
+
+      const prepared = await prepareImage(request.imageUri);
+      onProgress?.(30);
+
+      const result = await upscaleService.upscale({
+        base64: prepared.base64,
+        mimeType: prepared.mimeType,
+        options: {
+          scaleFactor: request.options?.scaleFactor || 2,
+          enhanceFaces: request.options?.enhanceFaces,
+        },
+      });
+
+      onProgress?.(90);
+
+      if (!result.success) {
+        return { success: false, error: result.error };
+      }
+
+      const imageUrl = result.imageBase64
+        ? `data:${result.mimeType || "image/png"};base64,${result.imageBase64}`
+        : result.imageUrl;
+
+      onProgress?.(100);
+
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[GeminiUpscaleProvider] Completed");
+      }
+
+      return {
+        success: true,
+        imageUrl,
+        imageBase64: result.imageBase64,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[GeminiUpscaleProvider] Error:", message);
+      }
+
+      return { success: false, error: message };
+    }
+  }
+}
+
+export const geminiUpscaleProvider = new GeminiUpscaleProvider();

package/src/domains/upscaling/infrastructure/providers/index.ts

@@ -0,0 +1,6 @@
+export {
+  geminiUpscaleProvider,
+  type IUpscaleProvider,
+  type UpscaleRequest,
+  type UpscaleResult,
+} from "./gemini-upscale.provider";

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

@@ -0,0 +1 @@
+export { upscaleService } from "./upscale.service";

package/src/domains/upscaling/infrastructure/services/upscale.service.ts

@@ -0,0 +1,77 @@
+/**
+ * Upscale Service
+ */
+
+import { geminiImageEditService } from "../../../../infrastructure/services/gemini-image-edit.service";
+import type {
+  UpscaleInput,
+  UpscaleResult,
+  UpscaleOptions,
+} from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+function buildPrompt(options?: UpscaleOptions): string {
+  const scale = options?.scaleFactor || 2;
+  const parts = [
+    `Upscale this image by ${scale}x while maintaining quality.`,
+    "Preserve all original details and colors.",
+    "Enhance sharpness and clarity.",
+  ];
+
+  if (options?.enhanceFaces) {
+    parts.push("Pay special attention to enhancing facial features.");
+  }
+
+  if (options?.enhanceDetails) {
+    parts.push("Enhance fine details and textures.");
+  }
+
+  return parts.join(" ");
+}
+
+class UpscaleService {
+  async upscale(input: UpscaleInput): Promise<UpscaleResult> {
+    if (__DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[UpscaleService] Starting", {
+        scaleFactor: input.options?.scaleFactor || 2,
+      });
+    }
+
+    try {
+      const prompt = buildPrompt(input.options);
+
+      const result = await geminiImageEditService.editImage(prompt, [
+        { base64: input.base64, mimeType: input.mimeType },
+      ]);
+
+      if (!result.imageBase64 && !result.imageUrl) {
+        return { success: false, error: "No image returned" };
+      }
+
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[UpscaleService] Completed successfully");
+      }
+
+      return {
+        success: true,
+        imageUrl: result.imageUrl,
+        imageBase64: result.imageBase64,
+        mimeType: result.mimeType,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+
+      if (__DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[UpscaleService] Error:", message);
+      }
+
+      return { success: false, error: message };
+    }
+  }
+}
+
+export const upscaleService = new UpscaleService();

package/src/domains/upscaling/infrastructure/utils/image-preparer.util.ts

@@ -0,0 +1,55 @@
+/**
+ * Image Preparer Utility
+ */
+
+import type { PreparedImage } from "../../domain/types";
+
+declare const __DEV__: boolean;
+
+function getMimeType(uri: string): string {
+  const ext = uri.split(".").pop()?.toLowerCase();
+  const types: Record<string, string> = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+  };
+  return types[ext || ""] || "image/jpeg";
+}
+
+function extractBase64(dataUrl: string): string {
+  const match = dataUrl.match(/^data:[^;]+;base64,(.+)$/);
+  return match ? match[1] : dataUrl;
+}
+
+export async function prepareImage(uri: string): Promise<PreparedImage> {
+  if (__DEV__) {
+    // eslint-disable-next-line no-console
+    console.log("[ImagePreparer] Preparing image");
+  }
+
+  if (uri.startsWith("data:")) {
+    const mimeMatch = uri.match(/^data:([^;]+);base64,/);
+    return {
+      base64: extractBase64(uri),
+      mimeType: mimeMatch ? mimeMatch[1] : "image/jpeg",
+    };
+  }
+
+  const response = await fetch(uri);
+  const blob = await response.blob();
+
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      const dataUrl = reader.result as string;
+      resolve({
+        base64: extractBase64(dataUrl),
+        mimeType: blob.type || getMimeType(uri),
+      });
+    };
+    reader.onerror = () => reject(new Error("Failed to read image"));
+    reader.readAsDataURL(blob);
+  });
+}

package/src/domains/upscaling/infrastructure/utils/index.ts

@@ -0,0 +1 @@
+export { prepareImage } from "./image-preparer.util";

package/src/index.ts

@@ -109,6 +109,20 @@ export type {
   UseGeminiReturn,
 } from "./presentation/hooks";
 
+// =============================================================================
+// DOMAINS - DDD-organized features
+// =============================================================================
+
+// Upscaling Domain - Provider for content package registry
+export { geminiUpscaleProvider } from "./domains/upscaling";
+
+export type {
+  IUpscaleProvider,
+  UpscaleRequest as GeminiUpscaleRequest,
+  UpscaleResult as GeminiUpscaleResult,
+  PreparedImage,
+} from "./domains/upscaling";
+
 // =============================================================================
 // PROVIDER CONFIGURATION - Tier-based Setup
 // =============================================================================

package/src/infrastructure/utils/image-preparer.util.ts

@@ -0,0 +1,65 @@
+/**
+ * Image Preparer Utility
+ * Prepares images for Gemini API
+ */
+
+import type { PreparedImage } from "../../domains/upscaling/domain/types";
+
+declare const __DEV__: boolean;
+
+function getMimeTypeFromUri(uri: string): string {
+  const extension = uri.split(".").pop()?.toLowerCase();
+  const mimeTypes: Record<string, string> = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+  };
+  return mimeTypes[extension || ""] || "image/jpeg";
+}
+
+function extractBase64FromDataUrl(dataUrl: string): string {
+  const match = dataUrl.match(/^data:[^;]+;base64,(.+)$/);
+  return match ? match[1] : dataUrl;
+}
+
+export async function prepareImageFromUri(
+  uri: string,
+): Promise<PreparedImage> {
+  if (__DEV__) {
+    // eslint-disable-next-line no-console
+    console.log("[ImagePreparer] Preparing image from URI");
+  }
+
+  if (uri.startsWith("data:")) {
+    const mimeMatch = uri.match(/^data:([^;]+);base64,/);
+    const mimeType = mimeMatch ? mimeMatch[1] : "image/jpeg";
+    const base64 = extractBase64FromDataUrl(uri);
+    return { base64, mimeType };
+  }
+
+  const response = await fetch(uri);
+  const blob = await response.blob();
+
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      const dataUrl = reader.result as string;
+      const base64 = extractBase64FromDataUrl(dataUrl);
+      const mimeType = blob.type || getMimeTypeFromUri(uri);
+      resolve({ base64, mimeType });
+    };
+    reader.onerror = () => reject(new Error("Failed to read image"));
+    reader.readAsDataURL(blob);
+  });
+}
+
+export function isValidBase64(str: string): boolean {
+  if (!str || str.length === 0) return false;
+  try {
+    return btoa(atob(str)) === str;
+  } catch {
+    return false;
+  }
+}