@umituz/react-native-ai-generation-content 1.36.2 → 1.37.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.36.2",
+  "version": "1.37.1",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -66,7 +66,7 @@
     "@types/react": "~19.1.10",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
-    "@umituz/react-native-design-system": "^2.9.44",
+    "@umituz/react-native-design-system": "^2.9.50",
     "@umituz/react-native-firebase": "^1.13.87",
     "@umituz/react-native-localization": "*",
     "@umituz/react-native-subscription": "*",

package/src/domains/creations/infrastructure/repositories/CreationsWriter.ts

@@ -5,216 +5,141 @@ import type { Creation, CreationDocument } from "../../domain/entities/Creation"
 
 declare const __DEV__: boolean;
 
+const UPDATABLE_FIELDS = [
+  "metadata", "isShared", "uri", "type", "prompt", "status",
+  "output", "rating", "ratedAt", "isFavorite", "deletedAt",
+] as const;
+
 /**
  * Handles write operations for creations
- * Single Responsibility: Write operations
  */
 export class CreationsWriter {
-    constructor(private readonly pathResolver: FirestorePathResolver) { }
-
-    async create(userId: string, creation: Creation): Promise<void> {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-             
-            console.log("[CreationsWriter] create() start", { userId, creationId: creation.id });
-        }
-
-        const docRef = this.pathResolver.getDocRef(userId, creation.id);
-        if (!docRef) throw new Error("Firestore not initialized");
-
-        const data: CreationDocument = {
-            type: creation.type,
-            uri: creation.uri,
-            createdAt: creation.createdAt,
-            metadata: creation.metadata || {},
-            isShared: creation.isShared || false,
-            isFavorite: creation.isFavorite || false,
-            ...(creation.status !== undefined && { status: creation.status }),
-            ...(creation.output !== undefined && { output: creation.output }),
-            ...(creation.prompt !== undefined && { prompt: creation.prompt }),
-        };
-
-        try {
-            await setDoc(docRef, data);
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-                 
-                console.log("[CreationsWriter] create() success", { creationId: creation.id });
-            }
-        } catch (error) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-                 
-                console.error("[CreationsWriter] create() error", error);
-            }
-            throw error;
-        }
-    }
+  constructor(private readonly pathResolver: FirestorePathResolver) {}
 
-    async update(
-        userId: string,
-        id: string,
-        updates: Partial<Creation>,
-    ): Promise<boolean> {
-        if (__DEV__) {
-             
-            console.log("[CreationsRepository] update()", { userId, id, updates });
-        }
-
-        const docRef = this.pathResolver.getDocRef(userId, id);
-        if (!docRef) return false;
-
-        try {
-            const updateData: Record<string, unknown> = {};
-
-            if (updates.metadata !== undefined) {
-                updateData.metadata = updates.metadata;
-            }
-            if (updates.isShared !== undefined) {
-                updateData.isShared = updates.isShared;
-            }
-            if (updates.uri !== undefined) {
-                updateData.uri = updates.uri;
-            }
-            if (updates.type !== undefined) {
-                updateData.type = updates.type;
-            }
-            if (updates.prompt !== undefined) {
-                updateData.prompt = updates.prompt;
-            }
-            if (updates.status !== undefined) {
-                updateData.status = updates.status;
-            }
-            if (updates.output !== undefined) {
-                updateData.output = updates.output;
-            }
-            if (updates.rating !== undefined) {
-                updateData.rating = updates.rating;
-            }
-            if (updates.ratedAt !== undefined) {
-                updateData.ratedAt = updates.ratedAt;
-            }
-            if (updates.isFavorite !== undefined) {
-                updateData.isFavorite = updates.isFavorite;
-            }
-            if (updates.deletedAt !== undefined) {
-                updateData.deletedAt = updates.deletedAt;
-            }
-
-            await updateDoc(docRef, updateData);
-            return true;
-        } catch (error) {
-            if (__DEV__) {
-                 
-                console.error("[CreationsRepository] update() ERROR", error);
-            }
-            return false;
-        }
+  async create(userId: string, creation: Creation): Promise<void> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[CreationsWriter] create()", { userId, creationId: creation.id });
     }
 
-    async delete(userId: string, creationId: string): Promise<boolean> {
-        const docRef = this.pathResolver.getDocRef(userId, creationId);
-        if (!docRef) return false;
-
-        try {
-            // Soft delete: set deletedAt timestamp instead of hard delete
-            await updateDoc(docRef, { deletedAt: new Date() });
-            return true;
-        } catch {
-            return false;
-        }
+    const docRef = this.pathResolver.getDocRef(userId, creation.id);
+    if (!docRef) throw new Error("Firestore not initialized");
+
+    const data: CreationDocument = {
+      type: creation.type,
+      uri: creation.uri,
+      createdAt: creation.createdAt,
+      metadata: creation.metadata || {},
+      isShared: creation.isShared || false,
+      isFavorite: creation.isFavorite || false,
+      ...(creation.status !== undefined && { status: creation.status }),
+      ...(creation.output !== undefined && { output: creation.output }),
+      ...(creation.prompt !== undefined && { prompt: creation.prompt }),
+    };
+
+    try {
+      await setDoc(docRef, data);
+      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[CreationsWriter] create() success");
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[CreationsWriter] create() error", error);
+      throw error;
     }
-
-    async hardDelete(userId: string, creationId: string): Promise<boolean> {
-        const docRef = this.pathResolver.getDocRef(userId, creationId);
-        if (!docRef) return false;
-
-        try {
-            await deleteDoc(docRef);
-            return true;
-        } catch {
-            return false;
-        }
+  }
+
+  async update(userId: string, id: string, updates: Partial<Creation>): Promise<boolean> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[CreationsWriter] update()", { userId, id });
+
+    const docRef = this.pathResolver.getDocRef(userId, id);
+    if (!docRef) return false;
+
+    try {
+      const updateData: Record<string, unknown> = {};
+      for (const field of UPDATABLE_FIELDS) {
+        if (updates[field] !== undefined) updateData[field] = updates[field];
+      }
+      await updateDoc(docRef, updateData);
+      return true;
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[CreationsWriter] update() error", error);
+      return false;
     }
-
-    async restore(userId: string, creationId: string): Promise<boolean> {
-        const docRef = this.pathResolver.getDocRef(userId, creationId);
-        if (!docRef) return false;
-
-        try {
-            // Remove deletedAt to restore the creation
-            await updateDoc(docRef, { deletedAt: null });
-            return true;
-        } catch {
-            return false;
-        }
+  }
+
+  async delete(userId: string, creationId: string): Promise<boolean> {
+    const docRef = this.pathResolver.getDocRef(userId, creationId);
+    if (!docRef) return false;
+    try {
+      await updateDoc(docRef, { deletedAt: new Date() });
+      return true;
+    } catch {
+      return false;
     }
-
-    async updateShared(
-        userId: string,
-        creationId: string,
-        isShared: boolean,
-    ): Promise<boolean> {
-        const docRef = this.pathResolver.getDocRef(userId, creationId);
-        if (!docRef) return false;
-
-        try {
-            await updateDoc(docRef, { isShared });
-            return true;
-        } catch {
-            return false;
-        }
+  }
+
+  async hardDelete(userId: string, creationId: string): Promise<boolean> {
+    const docRef = this.pathResolver.getDocRef(userId, creationId);
+    if (!docRef) return false;
+    try {
+      await deleteDoc(docRef);
+      return true;
+    } catch {
+      return false;
     }
-
-    async updateFavorite(
-        userId: string,
-        creationId: string,
-        isFavorite: boolean,
-    ): Promise<boolean> {
-        const docRef = this.pathResolver.getDocRef(userId, creationId);
-        if (!docRef) return false;
-
-        try {
-            await updateDoc(docRef, { isFavorite });
-            return true;
-        } catch {
-            return false;
-        }
+  }
+
+  async restore(userId: string, creationId: string): Promise<boolean> {
+    const docRef = this.pathResolver.getDocRef(userId, creationId);
+    if (!docRef) return false;
+    try {
+      await updateDoc(docRef, { deletedAt: null });
+      return true;
+    } catch {
+      return false;
     }
-
-    async rate(
-        userId: string,
-        creationId: string,
-        rating: number,
-        description?: string,
-    ): Promise<boolean> {
-        const docRef = this.pathResolver.getDocRef(userId, creationId);
-        if (!docRef) return false;
-
-        try {
-            // Update creation document with rating
-            await updateDoc(docRef, {
-                rating,
-                ratedAt: new Date(),
-            });
-
-            // If description exists or we want to log every rating as feedback
-            // we submit to feedback collection
-            if (description || rating) {
-                await submitFeedback({
-                    userId,
-                    userEmail: null, // We don't have email here, but standard is userId
-                    type: "creation_rating",
-                    title: `Creation Rating: ${rating} Stars`,
-                    description: description || `User rated creation ${rating} stars`,
-                    rating,
-                    status: "pending",
-                });
-            }
-
-            return true;
-        } catch (error) {
-            if (__DEV__) {
-                 console.error("[CreationsWriter] rate() error", error);
-            }
-            return false;
-        }
+  }
+
+  async updateShared(userId: string, creationId: string, isShared: boolean): Promise<boolean> {
+    const docRef = this.pathResolver.getDocRef(userId, creationId);
+    if (!docRef) return false;
+    try {
+      await updateDoc(docRef, { isShared });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async updateFavorite(userId: string, creationId: string, isFavorite: boolean): Promise<boolean> {
+    const docRef = this.pathResolver.getDocRef(userId, creationId);
+    if (!docRef) return false;
+    try {
+      await updateDoc(docRef, { isFavorite });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async rate(userId: string, creationId: string, rating: number, description?: string): Promise<boolean> {
+    const docRef = this.pathResolver.getDocRef(userId, creationId);
+    if (!docRef) return false;
+
+    try {
+      await updateDoc(docRef, { rating, ratedAt: new Date() });
+      if (description || rating) {
+        await submitFeedback({
+          userId,
+          userEmail: null,
+          type: "creation_rating",
+          title: `Creation Rating: ${rating} Stars`,
+          description: description || `User rated creation ${rating} stars`,
+          rating,
+          status: "pending",
+        });
+      }
+      return true;
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[CreationsWriter] rate() error", error);
+      return false;
     }
+  }
 }

package/src/domains/creations/presentation/components/GalleryResultPreview.tsx

@@ -0,0 +1,88 @@
+/**
+ * Gallery Result Preview Component
+ * Displays result preview when a creation is selected in gallery
+ */
+
+import React from "react";
+import { useAlert, AlertType, AlertMode } from "@umituz/react-native-design-system";
+import { ResultPreviewScreen } from "../../../result-preview/presentation/components/ResultPreviewScreen";
+import { StarRatingPicker } from "../../../result-preview/presentation/components/StarRatingPicker";
+import { useResultActions } from "../../../result-preview/presentation/hooks/useResultActions";
+import type { Creation } from "../../domain/entities/Creation";
+import type { CreationsConfig } from "../../domain/value-objects/CreationsConfig";
+
+interface GalleryResultPreviewProps {
+  readonly selectedCreation: Creation;
+  readonly imageUrl?: string;
+  readonly videoUrl?: string;
+  readonly showRatingPicker: boolean;
+  readonly config: CreationsConfig;
+  readonly t: (key: string) => string;
+  readonly onBack: () => void;
+  readonly onTryAgain: () => void;
+  readonly onRate: () => void;
+  readonly onSubmitRating: (rating: number, description: string) => void;
+  readonly onCloseRating: () => void;
+}
+
+export function GalleryResultPreview({
+  selectedCreation,
+  imageUrl,
+  videoUrl,
+  showRatingPicker,
+  config,
+  t,
+  onBack,
+  onTryAgain,
+  onRate,
+  onSubmitRating,
+  onCloseRating,
+}: GalleryResultPreviewProps) {
+  const alert = useAlert();
+
+  const { isSaving, isSharing, handleDownload, handleShare } = useResultActions({
+    imageUrl,
+    videoUrl,
+    onSaveSuccess: () => alert.show(AlertType.SUCCESS, AlertMode.TOAST, t("result.saveSuccess"), t("result.saveSuccessMessage")),
+    onSaveError: () => alert.show(AlertType.ERROR, AlertMode.TOAST, t("common.error"), t("result.saveError")),
+  });
+
+  const hasRating = selectedCreation.rating !== undefined && selectedCreation.rating !== null;
+
+  return (
+    <>
+      <ResultPreviewScreen
+        imageUrl={videoUrl ? undefined : imageUrl}
+        videoUrl={videoUrl}
+        isSaving={isSaving}
+        isSharing={isSharing}
+        onDownload={handleDownload}
+        onShare={handleShare}
+        onTryAgain={onTryAgain}
+        onNavigateBack={onBack}
+        onRate={onRate}
+        hideLabel
+        iconOnly
+        showTryAgain
+        showRating={!hasRating}
+        translations={{
+          title: t(config.translations.title),
+          saveButton: t("result.saveButton"),
+          saving: t("result.saving"),
+          shareButton: t("result.shareButton"),
+          sharing: t("result.sharing"),
+          tryAnother: t("result.tryAnother"),
+        }}
+      />
+      <StarRatingPicker
+        visible={showRatingPicker}
+        onClose={onCloseRating}
+        onRate={onSubmitRating}
+        title={t("result.rateTitle")}
+        submitLabel={t("common.submit")}
+        cancelLabel={t("common.cancel")}
+        descriptionPlaceholder={t("result.feedbackPlaceholder")}
+      />
+    </>
+  );
+}

package/src/domains/creations/presentation/hooks/useGalleryCallbacks.ts

@@ -0,0 +1,127 @@
+/**
+ * Gallery Callbacks Hook
+ * Extracts callback handlers from CreationsGalleryScreen
+ */
+
+import { useCallback } from "react";
+import { useAlert, AlertType, AlertMode, useSharing } from "@umituz/react-native-design-system";
+import type { Creation } from "../../domain/entities/Creation";
+import type { CreationsConfig } from "../../domain/value-objects/CreationsConfig";
+import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
+
+export interface UseGalleryCallbacksProps {
+  readonly userId: string | null;
+  readonly repository: ICreationsRepository;
+  readonly config: CreationsConfig;
+  readonly t: (key: string) => string;
+  readonly deleteMutation: { mutateAsync: (id: string) => Promise<boolean> };
+  readonly refetch: () => Promise<void>;
+  readonly setSelectedCreation: (creation: Creation | null) => void;
+  readonly setShowRatingPicker: (show: boolean) => void;
+  readonly selectedCreation: Creation | null;
+}
+
+export function useGalleryCallbacks(props: UseGalleryCallbacksProps) {
+  const {
+    userId,
+    repository,
+    config,
+    t,
+    deleteMutation,
+    refetch,
+    setSelectedCreation,
+    setShowRatingPicker,
+    selectedCreation,
+  } = props;
+
+  const { share } = useSharing();
+  const alert = useAlert();
+
+  const handleShareCard = useCallback(
+    (c: Creation) => {
+      void share(c.uri, { dialogTitle: t("common.share") });
+    },
+    [share, t],
+  );
+
+  const handleDelete = useCallback(
+    (c: Creation) => {
+      alert.show(
+        AlertType.WARNING,
+        AlertMode.MODAL,
+        t(config.translations.deleteTitle),
+        t(config.translations.deleteMessage),
+        {
+          actions: [
+            { id: "cancel", label: t("common.cancel"), onPress: () => {} },
+            {
+              id: "delete",
+              label: t("common.delete"),
+              style: "destructive",
+              onPress: async () => {
+                await deleteMutation.mutateAsync(c.id);
+              },
+            },
+          ],
+        },
+      );
+    },
+    [alert, config, deleteMutation, t],
+  );
+
+  const handleFavorite = useCallback(
+    (c: Creation, isFavorite: boolean) => {
+      void (async () => {
+        if (!userId) return;
+        const success = await repository.updateFavorite(userId, c.id, isFavorite);
+        if (success) void refetch();
+      })();
+    },
+    [userId, repository, refetch],
+  );
+
+  const handleCardPress = useCallback(
+    (item: Creation) => {
+      setSelectedCreation(item);
+    },
+    [setSelectedCreation],
+  );
+
+  const handleBack = useCallback(() => {
+    setSelectedCreation(null);
+  }, [setSelectedCreation]);
+
+  const handleTryAgain = useCallback(() => {
+    setSelectedCreation(null);
+  }, [setSelectedCreation]);
+
+  const handleOpenRatingPicker = useCallback(() => {
+    setShowRatingPicker(true);
+  }, [setShowRatingPicker]);
+
+  const handleSubmitRating = useCallback(
+    (rating: number, description: string) => {
+      if (!userId || !selectedCreation) return;
+      void (async () => {
+        const success = await repository.rate(userId, selectedCreation.id, rating, description);
+        if (success) {
+          setSelectedCreation({ ...selectedCreation, rating, ratedAt: new Date() });
+          alert.show(AlertType.SUCCESS, AlertMode.TOAST, t("result.rateSuccessTitle"), t("result.rateSuccessMessage"));
+          void refetch();
+        }
+      })();
+    },
+    [userId, selectedCreation, repository, alert, t, refetch, setSelectedCreation],
+  );
+
+  return {
+    handleShareCard,
+    handleDelete,
+    handleFavorite,
+    handleCardPress,
+    handleBack,
+    handleTryAgain,
+    handleOpenRatingPicker,
+    handleSubmitRating,
+  };
+}