@umituz/react-native-ai-generation-content 1.37.28 → 1.37.30

package/package.json

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

package/src/domains/creations/domain/types/creation-categories.ts

@@ -21,31 +21,25 @@ export const IMAGE_CREATION_TYPES: CreationTypeId[] = [
   "background-replacement",
   "ai-brush",
   "hd-touch-up",
-  "ai-hug",
-  "ai-kiss",
   "anime-selfie",
 ];
 
 /**
- * Video-related creation types
+ * Video-related creation types (core types only)
+ * NOTE: All other video types (scenarios, ai-hug, ai-kiss, etc.)
+ * are dynamically determined by output content via isVideoUrl()
  */
 export const VIDEO_CREATION_TYPES: CreationTypeId[] = [
   "text-to-video",
   "image-to-video",
 ];
 
-/**
- * Voice-related creation types
- */
-export const VOICE_CREATION_TYPES: CreationTypeId[] = ["text-to-voice"];
-
 /**
  * All creation types
  */
 export const ALL_CREATION_TYPES: CreationTypeId[] = [
   ...IMAGE_CREATION_TYPES,
   ...VIDEO_CREATION_TYPES,
-  ...VOICE_CREATION_TYPES,
 ];
 
 /**
@@ -59,15 +53,15 @@ export function getTypesForCategory(
       return IMAGE_CREATION_TYPES;
     case "video":
       return VIDEO_CREATION_TYPES;
-    case "voice":
-      return VOICE_CREATION_TYPES;
     case "all":
       return ALL_CREATION_TYPES;
+    default:
+      return ALL_CREATION_TYPES;
   }
 }
 
 /**
- * Get category for a creation type
+ * Get category for a creation type (type-based fallback only)
  */
 export function getCategoryForType(type: CreationTypeId): CreationCategory {
   if (IMAGE_CREATION_TYPES.includes(type)) {
@@ -76,12 +70,46 @@ export function getCategoryForType(type: CreationTypeId): CreationCategory {
   if (VIDEO_CREATION_TYPES.includes(type)) {
     return "video";
   }
-  if (VOICE_CREATION_TYPES.includes(type)) {
-    return "voice";
-  }
   return "image"; // Default fallback
 }
 
+/**
+ * Get category for a creation based on its output content
+ * This is the PRIMARY method for categorization - OUTPUT determines category, not type
+ * Handles all scenarios (solo_martial_artist, ski_resort, ai-hug, ai-kiss, etc.)
+ *
+ * Strategy: API response already tells us the type via field names:
+ * - output.videoUrl exists → video
+ * - output.imageUrl exists → image
+ * No need to parse URLs or check extensions!
+ */
+export function getCategoryForCreation(creation: {
+  type?: string;
+  output?: {
+    videoUrl?: string;
+    imageUrl?: string;
+    imageUrls?: string[];
+  };
+  uri?: string;
+}): CreationCategory {
+  // PRIORITY 1: Check output field names (most reliable)
+  if (creation.output?.videoUrl) {
+    return "video";
+  }
+
+  if (creation.output?.imageUrl || creation.output?.imageUrls?.length) {
+    return "image";
+  }
+
+  // PRIORITY 2: Fallback to type-based (for known types)
+  if (creation.type) {
+    return getCategoryForType(creation.type as CreationTypeId);
+  }
+
+  // Final fallback
+  return "image";
+}
+
 /**
  * Check if a type belongs to a category
  */
@@ -110,24 +138,3 @@ export function isImageCreationType(type?: string): boolean {
   if (!type) return false;
   return IMAGE_CREATION_TYPES.includes(type as CreationTypeId);
 }
-
-/**
- * Check if creation type is voice
- */
-export function isVoiceCreationType(type?: string): boolean {
-  if (!type) return false;
-  return VOICE_CREATION_TYPES.includes(type as CreationTypeId);
-}
-
-/**
- * Get media type (image/video/audio) for a creation type
- */
-export function getMediaTypeForCreation(
-  type?: string
-): "image" | "video" | "audio" | "unknown" {
-  if (!type) return "unknown";
-  if (isVideoCreationType(type)) return "video";
-  if (isVoiceCreationType(type)) return "audio";
-  if (isImageCreationType(type)) return "image";
-  return "unknown";
-}

package/src/domains/creations/domain/types/creation-filter.ts

@@ -4,7 +4,6 @@
  */
 
 import type { CreationTypeId, CreationStatus, CreationCategory } from "./creation-types";
-import { IMAGE_CREATION_TYPES, VIDEO_CREATION_TYPES, VOICE_CREATION_TYPES } from "./creation-categories";
 
 /**
  * Filter options for querying creations
@@ -61,7 +60,6 @@ export const MEDIA_FILTER_OPTIONS: FilterOption[] = [
   { id: "all", label: "All", labelKey: "creations.filter.all", icon: "grid-outline" },
   { id: "image", label: "Images", labelKey: "creations.filter.images", icon: "image-outline" },
   { id: "video", label: "Videos", labelKey: "creations.filter.videos", icon: "videocam-outline" },
-  { id: "voice", label: "Voice", labelKey: "creations.filter.voice", icon: "mic-outline" },
 ];
 
 /**
@@ -89,11 +87,16 @@ export interface CreationStats {
  * Calculate stats from creations array
  */
 export function calculateCreationStats(
-  creations: Array<{ type?: string; status?: string }>
+  creations: Array<{
+    type?: string;
+    status?: string;
+    output?: { videoUrl?: string; imageUrl?: string; imageUrls?: string[] };
+    uri?: string;
+  }>
 ): CreationStats {
   const stats: CreationStats = {
     total: creations.length,
-    byCategory: { all: creations.length, image: 0, video: 0, voice: 0 },
+    byCategory: { all: creations.length, image: 0, video: 0 },
     byStatus: { pending: 0, queued: 0, processing: 0, completed: 0, failed: 0 },
     byType: {},
   };
@@ -114,15 +117,11 @@ export function calculateCreationStats(
     }
   }
 
-  // Calculate category counts from type counts
-  for (const [typeId, count] of Object.entries(stats.byType)) {
-    if ((IMAGE_CREATION_TYPES as string[]).includes(typeId)) {
-      stats.byCategory.image += count as number;
-    } else if ((VIDEO_CREATION_TYPES as string[]).includes(typeId)) {
-      stats.byCategory.video += count as number;
-    } else if ((VOICE_CREATION_TYPES as string[]).includes(typeId)) {
-      stats.byCategory.voice += count as number;
-    }
+  // Calculate category counts based on OUTPUT content (most reliable)
+  const { getCategoryForCreation } = require("./creation-categories");
+  for (const creation of creations) {
+    const category = getCategoryForCreation(creation) as Exclude<CreationCategory, "all">;
+    stats.byCategory[category]++;
   }
 
   return stats;

package/src/domains/creations/domain/types/creation-types.ts

@@ -10,7 +10,6 @@ export type CreationTypeId =
   | "text-to-image"
   | "text-to-video"
   | "image-to-video"
-  | "text-to-voice"
   | "upscale"
   | "remove-background"
   | "photo-restore"
@@ -39,7 +38,7 @@ export type CreationStatus =
 /**
  * Creation category for grouping types
  */
-export type CreationCategory = "image" | "video" | "voice" | "all";
+export type CreationCategory = "image" | "video" | "all";
 
 /**
  * All status values as array for iteration
@@ -59,5 +58,4 @@ export const ALL_CREATION_CATEGORIES: CreationCategory[] = [
   "all",
   "image",
   "video",
-  "voice",
 ];

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

@@ -18,15 +18,13 @@ export {
 export {
   IMAGE_CREATION_TYPES,
   VIDEO_CREATION_TYPES,
-  VOICE_CREATION_TYPES,
   ALL_CREATION_TYPES,
   getTypesForCategory,
   getCategoryForType,
+  getCategoryForCreation,
   isTypeInCategory,
   isVideoCreationType,
   isImageCreationType,
-  isVoiceCreationType,
-  getMediaTypeForCreation,
 } from "./creation-categories";
 
 // Filter types

package/src/domains/creations/domain/utils/creation-helpers.ts

@@ -26,8 +26,6 @@ export function getTypeIcon(type: CreationTypeId): IconName {
     case "text-to-video":
     case "image-to-video":
       return "film";
-    case "text-to-voice":
-      return "mic";
     case "style-transfer":
     case "colorization":
       return "color-palette";

package/src/domains/creations/index.ts

@@ -25,17 +25,15 @@ export {
   ALL_CREATION_TYPES,
   IMAGE_CREATION_TYPES,
   VIDEO_CREATION_TYPES,
-  VOICE_CREATION_TYPES,
   DEFAULT_CREATION_FILTER,
   MEDIA_FILTER_OPTIONS,
   STATUS_FILTER_OPTIONS,
   getTypesForCategory,
   getCategoryForType,
+  getCategoryForCreation,
   isTypeInCategory,
   isVideoCreationType,
   isImageCreationType,
-  isVoiceCreationType,
-  getMediaTypeForCreation,
   calculateCreationStats,
 } from "./domain/types";
 

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

@@ -1,22 +1,15 @@
 /**
  * CreationPreview Component
  * Smart wrapper that delegates to CreationImagePreview or CreationVideoPreview
- * based on creation type
+ * based on output content type (not creation type)
  */
 
 import React from "react";
+import { isVideoUrl } from "@umituz/react-native-design-system";
 import type { CreationStatus, CreationTypeId } from "../../domain/types";
 import { CreationImagePreview } from "./CreationImagePreview";
 import { CreationVideoPreview } from "./CreationVideoPreview";
 
-/** Video creation types */
-const VIDEO_TYPES: CreationTypeId[] = ["text-to-video", "image-to-video"];
-
-/** Check if creation type is a video type */
-function isVideoType(type?: CreationTypeId | string): boolean {
-  return VIDEO_TYPES.includes(type as CreationTypeId);
-}
-
 interface CreationPreviewProps {
   /** Preview image/thumbnail URL */
   readonly uri?: string | null;
@@ -43,11 +36,15 @@ export function CreationPreview({
   height,
   showLoadingIndicator = true,
 }: CreationPreviewProps) {
-  // For video types, use CreationVideoPreview
-  if (isVideoType(type)) {
+  // Determine preview type based on URI content, not creation type
+  // This handles scenario-based videos (solo_martial_artist, ski_resort, etc.)
+  const hasVideoContent = uri && isVideoUrl(uri);
+
+  // For video content, use CreationVideoPreview
+  if (hasVideoContent) {
     return (
       <CreationVideoPreview
-        thumbnailUrl={thumbnailUrl || uri}
+        thumbnailUrl={thumbnailUrl}
         videoUrl={uri}
         status={status}
         type={type as CreationTypeId}
@@ -58,7 +55,7 @@ export function CreationPreview({
     );
   }
 
-  // For image types, use CreationImagePreview
+  // For image content, use CreationImagePreview
   return (
     <CreationImagePreview
       uri={uri}