@umituz/react-native-ai-generation-content 1.20.45 → 1.20.47

package/package.json

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

package/src/index.ts

@@ -56,11 +56,13 @@ export {
   extractAudioUrl, extractImageUrls, cleanBase64, addBase64Prefix, preparePhoto, preparePhotos,
   isValidBase64, getBase64Size, getBase64SizeMB, prepareImage, createDevCallbacks, createFeatureUtils,
   showVideoGenerationSuccess, handleGenerationError, showContentModerationWarning,
+  saveMediaToGallery, shareMedia, createSaveHandler, createShareHandler, createMediaHandlers,
 } from "./infrastructure/utils";
 
 export type {
   IntervalOptions, ProgressOptions, StatusCheckResult, ResultValidation, ValidateResultOptions,
   PhotoInput, PreparedImage, ImageSelector, VideoSaver, AlertFunction, FeatureUtilsConfig, VideoAlertFunction,
+  MediaActionResult, MediaActionTranslations, ToastConfig,
 } from "./infrastructure/utils";
 
 export { enhancePromptWithLanguage, getSupportedLanguages, getLanguageName, ModerationWrapper, generateSynchronously } from "./infrastructure/wrappers";
@@ -72,6 +74,7 @@ export {
   useAIGenerateState, AIGenerateStep,
   useGenerationOrchestrator, useImageGeneration, useVideoGeneration, useAIFeatureGeneration,
   createGenerationError, getAlertMessage, parseError,
+  useAIGenerateWizard, createWizardTranslations,
 } from "./presentation/hooks";
 
 export type {
@@ -84,6 +87,7 @@ export type {
   SingleImageInput, DualImageInput, ImageGenerationInput, ImageGenerationConfig,
   DualImageVideoInput, VideoGenerationConfig,
   UploadedImage,
+  AIGenerateWizardConfig, AIGenerateWizardTranslations, UseAIGenerateWizardReturn,
 } from "./presentation/hooks";
 
 export {

package/src/infrastructure/utils/index.ts

@@ -12,3 +12,4 @@ export * from "./photo-generation";
 export * from "./feature-utils";
 export * from "./video-helpers";
 export * from "./video-result-extractor.util";
+export * from "./media-actions.util";

package/src/infrastructure/utils/media-actions.util.ts

@@ -0,0 +1,206 @@
+/**
+ * Media Actions Utilities
+ * Provides save to gallery and share functionality for generated media
+ */
+
+export interface MediaActionResult {
+  readonly success: boolean;
+  readonly error?: string;
+}
+
+export interface MediaActionTranslations {
+  readonly success?: string;
+  readonly error?: string;
+  readonly permissionDenied?: string;
+  readonly saveFailed?: string;
+  readonly shareFailed?: string;
+  readonly shareNotAvailable?: string;
+}
+
+export interface ToastConfig {
+  readonly show: (config: {
+    type: "success" | "error";
+    text1: string;
+    text2?: string;
+  }) => void;
+}
+
+/**
+ * Downloads a file from URL to local storage
+ * @param uri - URL or local path
+ * @param prefix - File name prefix
+ * @returns Local file path
+ */
+const downloadToLocal = async (
+  uri: string,
+  prefix: string = "media"
+): Promise<string> => {
+  if (!uri.startsWith("http")) {
+    return uri;
+  }
+
+  const FileSystem = require("expo-file-system");
+  const fileExt = uri.split(".").pop()?.split("?")[0] || "jpg";
+  const fileRef =
+    FileSystem.documentDirectory + `${prefix}_${Date.now()}.${fileExt}`;
+  const { uri: downloadedUri } = await FileSystem.downloadAsync(uri, fileRef);
+  return downloadedUri;
+};
+
+/**
+ * Saves media to device gallery
+ * @param uri - URL or local path of the media
+ * @param translations - Optional translated messages
+ * @param toast - Optional toast instance for notifications
+ * @returns Result with success status
+ */
+export const saveMediaToGallery = async (
+  uri: string,
+  translations?: MediaActionTranslations,
+  toast?: ToastConfig
+): Promise<MediaActionResult> => {
+  try {
+    const MediaLibrary = require("expo-media-library");
+
+    const { status } = await MediaLibrary.requestPermissionsAsync();
+    if (status !== "granted") {
+      const errorMsg = translations?.permissionDenied || "Permission denied";
+      toast?.show({
+        type: "error",
+        text1: translations?.error || "Error",
+        text2: errorMsg,
+      });
+      return { success: false, error: errorMsg };
+    }
+
+    const localUri = await downloadToLocal(uri, "download");
+    await MediaLibrary.saveToLibraryAsync(localUri);
+
+    toast?.show({
+      type: "success",
+      text1: translations?.success || "Success",
+      text2: "Saved to gallery",
+    });
+
+    return { success: true };
+  } catch (error) {
+    // Debug logging in development
+    try {
+      if ((global as Record<string, unknown>).__DEV__) {
+        console.error("[MediaActions] Save failed:", error);
+      }
+    } catch {
+      // Ignore if __DEV__ check fails
+    }
+    const errorMsg = translations?.saveFailed || "Failed to save media";
+    toast?.show({
+      type: "error",
+      text1: translations?.error || "Error",
+      text2: errorMsg,
+    });
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : errorMsg,
+    };
+  }
+};
+
+/**
+ * Shares media using device share sheet
+ * @param uri - URL or local path of the media
+ * @param translations - Optional translated messages
+ * @param toast - Optional toast instance for notifications
+ * @returns Result with success status
+ */
+export const shareMedia = async (
+  uri: string,
+  translations?: MediaActionTranslations,
+  toast?: ToastConfig
+): Promise<MediaActionResult> => {
+  try {
+    const Sharing = require("expo-sharing");
+
+    const isAvailable = await Sharing.isAvailableAsync();
+    if (!isAvailable) {
+      const errorMsg =
+        translations?.shareNotAvailable ||
+        "Sharing is not available on this device";
+      toast?.show({
+        type: "error",
+        text1: translations?.error || "Error",
+        text2: errorMsg,
+      });
+      return { success: false, error: errorMsg };
+    }
+
+    const localUri = await downloadToLocal(uri, "share");
+    await Sharing.shareAsync(localUri);
+
+    return { success: true };
+  } catch (error) {
+    // Debug logging in development
+    try {
+      if ((global as Record<string, unknown>).__DEV__) {
+        console.error("[MediaActions] Share failed:", error);
+      }
+    } catch {
+      // Ignore if __DEV__ check fails
+    }
+    const errorMsg = translations?.shareFailed || "Failed to share media";
+    toast?.show({
+      type: "error",
+      text1: translations?.error || "Error",
+      text2: errorMsg,
+    });
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : errorMsg,
+    };
+  }
+};
+
+/**
+ * Creates save handler for use in wizard flows
+ * @param translations - Translated messages
+ * @param toast - Toast instance for notifications
+ * @returns Save handler function
+ */
+export const createSaveHandler = (
+  translations?: MediaActionTranslations,
+  toast?: ToastConfig
+) => {
+  return async (uri: string): Promise<void> => {
+    await saveMediaToGallery(uri, translations, toast);
+  };
+};
+
+/**
+ * Creates share handler for use in wizard flows
+ * @param translations - Translated messages
+ * @param toast - Toast instance for notifications
+ * @returns Share handler function
+ */
+export const createShareHandler = (
+  translations?: MediaActionTranslations,
+  toast?: ToastConfig
+) => {
+  return async (uri: string): Promise<void> => {
+    await shareMedia(uri, translations, toast);
+  };
+};
+
+/**
+ * Creates both save and share handlers
+ * @param translations - Translated messages
+ * @param toast - Toast instance for notifications
+ * @returns Object with onSave and onShare handlers
+ */
+export const createMediaHandlers = (
+  translations?: MediaActionTranslations,
+  toast?: ToastConfig
+) => {
+  return {
+    onSave: createSaveHandler(translations, toast),
+    onShare: createShareHandler(translations, toast),
+  };
+};

package/src/presentation/hooks/index.ts

@@ -63,3 +63,10 @@ export type {
 
 export { useAIGenerateState, AIGenerateStep } from "./generation/useAIGenerateState";
 export type { UploadedImage } from "./generation/useAIGenerateState";
+
+export { useAIGenerateWizard, createWizardTranslations } from "./useAIGenerateWizard";
+export type {
+  AIGenerateWizardConfig,
+  AIGenerateWizardTranslations,
+  UseAIGenerateWizardReturn,
+} from "./useAIGenerateWizard";

package/src/presentation/hooks/useAIGenerateWizard.ts

@@ -0,0 +1,164 @@
+/**
+ * useAIGenerateWizard Hook
+ * Provides all necessary logic for AI generation wizard screens
+ * Centralizes save, share, and generation handling
+ */
+
+import { useCallback, useMemo } from "react";
+import {
+  saveMediaToGallery,
+  shareMedia,
+  type MediaActionTranslations,
+  type ToastConfig,
+} from "../../infrastructure/utils/media-actions.util";
+import { useAIFeatureGeneration } from "./generation";
+import type { AlertMessages } from "./generation";
+
+export interface AIGenerateWizardConfig {
+  readonly featureType: string;
+  readonly userId?: string;
+  readonly alertMessages?: AlertMessages;
+}
+
+export interface AIGenerateWizardTranslations {
+  readonly headerTitle: string;
+  readonly uploadSubtitle: string;
+  readonly uploadSubtitle2: string;
+  readonly continue: string;
+  readonly tapToUpload: string;
+  readonly selectPhoto: string;
+  readonly change: string;
+  readonly analyzing: string;
+  readonly error: string;
+  readonly uploadFailed: string;
+  readonly aiDisclosure: string;
+  readonly heroTitle: string;
+  readonly heroSubtitle: string;
+  readonly presetsTitle: string;
+  readonly showAdvancedLabel: string;
+  readonly hideAdvancedLabel: string;
+  readonly promptTitle: string;
+  readonly promptPlaceholder: string;
+  readonly styleTitle: string;
+  readonly durationTitle: string;
+  readonly generateButton: string;
+  readonly generatingButton: string;
+  readonly processingTitle: string;
+  readonly processingMessage: string;
+  readonly processingHint: string;
+  readonly successTitle: string;
+  readonly saveButton: string;
+  readonly shareButton: string;
+  readonly tryAgainButton: string;
+  readonly fileTooLarge: string;
+  readonly maxFileSize: string;
+}
+
+export interface UseAIGenerateWizardReturn {
+  readonly generate: (data: {
+    prompt: string;
+    style: string;
+    duration: number;
+    images: { uri: string }[];
+  }) => Promise<string | null | void>;
+  readonly handleSave: (uri: string) => Promise<void>;
+  readonly handleShare: (uri: string) => Promise<void>;
+}
+
+/**
+ * Hook that provides all AI generation wizard functionality
+ * Handles generation, save, and share operations
+ */
+export function useAIGenerateWizard(
+  config: AIGenerateWizardConfig,
+  translations: { error?: string; success?: string },
+  toast?: ToastConfig
+): UseAIGenerateWizardReturn {
+  const { generate } = useAIFeatureGeneration({
+    featureType: config.featureType as never,
+    alertMessages: config.alertMessages ?? {
+      success: translations.success ?? "Generation successful",
+      error: translations.error ?? "Error",
+      creditLimit: "Insufficient credits",
+    },
+    userId: config.userId,
+  });
+
+  const mediaTranslations: MediaActionTranslations = useMemo(
+    () => ({
+      success: translations.success,
+      error: translations.error,
+      permissionDenied: "Permission denied",
+      saveFailed: "Failed to save media",
+      shareFailed: "Failed to share media",
+      shareNotAvailable: "Sharing is not available on this device",
+    }),
+    [translations]
+  );
+
+  const handleSave = useCallback(
+    async (uri: string): Promise<void> => {
+      await saveMediaToGallery(uri, mediaTranslations, toast);
+    },
+    [mediaTranslations, toast]
+  );
+
+  const handleShare = useCallback(
+    async (uri: string): Promise<void> => {
+      await shareMedia(uri, mediaTranslations, toast);
+    },
+    [mediaTranslations, toast]
+  );
+
+  return {
+    generate,
+    handleSave,
+    handleShare,
+  };
+}
+
+/**
+ * Creates translations object from t function
+ * @param t - Translation function
+ * @param featureType - Feature type for feature-specific keys
+ * @returns Translations object for AIGenerateWizardFlow
+ */
+export function createWizardTranslations(
+  t: (key: string) => string,
+  featureType: string
+): AIGenerateWizardTranslations {
+  const featureKey = featureType.replace(/-/g, "_");
+  return {
+    headerTitle: t(`home.ai_features.${featureKey}.title`),
+    uploadSubtitle: t("imageProcessing.upload.subtitle"),
+    uploadSubtitle2: t("imageProcessing.upload.subtitle_2"),
+    continue: t("common.actions.continue"),
+    tapToUpload: t("imageProcessing.upload.tapToUpload"),
+    selectPhoto: t("imageProcessing.upload.selectPhoto"),
+    change: t("imageProcessing.upload.change"),
+    analyzing: t("imageProcessing.upload.analyzing"),
+    error: t("common.error"),
+    uploadFailed: t("common.errors.upload_failed"),
+    aiDisclosure: t("imageProcessing.upload.aiDisclosure"),
+    heroTitle: "",
+    heroSubtitle: "",
+    presetsTitle: t("common.generation.presets.title"),
+    showAdvancedLabel: t("common.generation.advanced.show"),
+    hideAdvancedLabel: t("common.generation.advanced.hide"),
+    promptTitle: t("common.prompts.custom_prompt"),
+    promptPlaceholder: t("common.prompts.placeholder"),
+    styleTitle: t("common.generation.style_selector.video_title"),
+    durationTitle: t("common.generation.duration_selector.title"),
+    generateButton: t("common.actions.generate"),
+    generatingButton: t("common.actions.generating"),
+    processingTitle: t("common.generation.progress.title"),
+    processingMessage: t("common.generation.progress.hint"),
+    processingHint: t("common.generation.progress.backgroundHint"),
+    successTitle: t("common.generation.success"),
+    saveButton: t("common.actions.save"),
+    shareButton: t("common.actions.share"),
+    tryAgainButton: t("common.actions.try_again"),
+    fileTooLarge: t("common.errors.file_too_large"),
+    maxFileSize: t("common.errors.max_file_size"),
+  };
+}