@umituz/react-native-ai-generation-content 1.16.0 → 1.17.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.16.0",
+  "version": "1.17.1",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -59,24 +59,23 @@
     "@react-native-async-storage/async-storage": "^2.2.0",
     "@react-native-community/datetimepicker": "^8.5.1",
     "@react-navigation/bottom-tabs": "^7.9.0",
-    "@react-navigation/native": "^6.1.18",
+    "@react-navigation/native": "^7.1.26",
     "@react-navigation/stack": "^7.6.13",
     "@tanstack/react-query": "^5.0.0",
     "@types/react": "~19.1.10",
-    "@types/react-native": "^0.73.0",
-    "@typescript-eslint/eslint-plugin": "^7.0.0",
-    "@typescript-eslint/parser": "^7.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
     "@umituz/react-native-animation": "*",
-    "@umituz/react-native-design-system": "^2.4.1",
-    "@umituz/react-native-firebase": "^1.13.20",
-    "@umituz/react-native-haptics": "^1.0.2",
+    "@umituz/react-native-design-system": "latest",
+    "@umituz/react-native-firebase": "latest",
+    "@umituz/react-native-haptics": "latest",
     "@umituz/react-native-image": "*",
-    "@umituz/react-native-localization": "^3.5.36",
+    "@umituz/react-native-localization": "latest",
     "@umituz/react-native-offline": "*",
-    "@umituz/react-native-storage": "^2.4.5",
-    "@umituz/react-native-timezone": "^1.3.4",
+    "@umituz/react-native-storage": "latest",
+    "@umituz/react-native-timezone": "latest",
     "@umituz/react-native-uuid": "*",
-    "eslint": "^8.57.0",
+    "eslint": "^9.0.0",
     "expo-application": "^7.0.8",
     "expo-clipboard": "^8.0.8",
     "expo-crypto": "^15.0.8",
@@ -87,7 +86,7 @@
     "expo-linear-gradient": "~15.0.7",
     "expo-localization": "^17.0.8",
     "expo-sharing": "^14.0.8",
-    "firebase": "^11.1.0",
+    "firebase": "^12.6.0",
     "i18next": "^25.7.3",
     "react": "19.1.0",
     "react-i18next": "^16.5.0",
@@ -96,7 +95,7 @@
     "react-native-reanimated": "^4.2.1",
     "react-native-safe-area-context": "^5.6.2",
     "rn-emoji-keyboard": "^1.7.0",
-    "typescript": "^5.3.0",
+    "typescript": "^5.9.0",
     "zustand": "^5.0.2"
   },
   "publishConfig": {

package/src/domains/creations/domain/entities/Creation.ts

@@ -3,6 +3,23 @@
  * Represents an AI-generated creation
  */
 
+import type { CreationStatus } from "../types/creation-types";
+
+/**
+ * Creation output containing media URLs
+ */
+export interface CreationOutput {
+  readonly imageUrl?: string;
+  readonly imageUrls?: string[];
+  readonly videoUrl?: string;
+  readonly audioUrl?: string;
+  readonly thumbnailUrl?: string;
+}
+
+/**
+ * Main Creation entity
+ * Supports both simple (uri-based) and complex (output-based) creations
+ */
 export interface Creation {
   readonly id: string;
   readonly uri: string;
@@ -13,6 +30,9 @@ export interface Creation {
   readonly createdAt: Date;
   readonly isShared: boolean;
   readonly isFavorite: boolean;
+  // Extended fields for job-based creations
+  readonly status?: CreationStatus;
+  readonly output?: CreationOutput;
 }
 
 export interface CreationDocument {
@@ -26,9 +46,10 @@ export interface CreationDocument {
   readonly transformationType?: string;
   readonly type?: string;
   readonly status?: string;
+  readonly output?: CreationOutput;
   readonly isShared: boolean;
   readonly isFavorite?: boolean;
-  readonly createdAt: FirebaseTimestamp | Date; // Allow Date for writing
+  readonly createdAt: FirebaseTimestamp | Date;
   readonly completedAt?: FirebaseTimestamp | Date;
 }
 
@@ -49,9 +70,17 @@ export function mapDocumentToCreation(
     creationDate = new Date();
   }
 
+  // Get URI from output or direct fields
+  const uri = data.output?.imageUrl ||
+              data.output?.videoUrl ||
+              data.transformedImageUrl ||
+              data.transformedImage ||
+              data.uri ||
+              "";
+
   return {
     id,
-    uri: data.transformedImageUrl || data.transformedImage || data.uri || "",
+    uri,
     type: data.transformationType || data.type || "unknown",
     prompt: data.prompt,
     metadata: data.metadata,
@@ -59,5 +88,7 @@ export function mapDocumentToCreation(
     createdAt: creationDate,
     isShared: data.isShared ?? false,
     isFavorite: data.isFavorite ?? false,
+    status: data.status as CreationStatus | undefined,
+    output: data.output,
   };
 }

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

@@ -2,5 +2,5 @@
  * Domain Entities
  */
 
-export type { Creation, CreationDocument } from "./Creation";
+export type { Creation, CreationDocument, CreationOutput } from "./Creation";
 export { mapDocumentToCreation } from "./Creation";

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

@@ -0,0 +1,133 @@
+/**
+ * Creation Categories
+ * Maps creation types to categories for filtering and organization
+ */
+
+import type { CreationTypeId, CreationCategory } from "./creation-types";
+
+/**
+ * Image-related creation types
+ */
+export const IMAGE_CREATION_TYPES: CreationTypeId[] = [
+  "text-to-image",
+  "upscale",
+  "remove-background",
+  "photo-restore",
+  "inpainting",
+  "style-transfer",
+  "colorization",
+  "face-swap",
+  "object-removal",
+  "background-replacement",
+  "ai-brush",
+  "hd-touch-up",
+  "ai-hug",
+  "ai-kiss",
+  "anime-selfie",
+];
+
+/**
+ * Video-related creation types
+ */
+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,
+];
+
+/**
+ * Get creation types for a category
+ */
+export function getTypesForCategory(
+  category: CreationCategory
+): CreationTypeId[] {
+  switch (category) {
+    case "image":
+      return IMAGE_CREATION_TYPES;
+    case "video":
+      return VIDEO_CREATION_TYPES;
+    case "voice":
+      return VOICE_CREATION_TYPES;
+    case "all":
+      return ALL_CREATION_TYPES;
+  }
+}
+
+/**
+ * Get category for a creation type
+ */
+export function getCategoryForType(type: CreationTypeId): CreationCategory {
+  if (IMAGE_CREATION_TYPES.includes(type)) {
+    return "image";
+  }
+  if (VIDEO_CREATION_TYPES.includes(type)) {
+    return "video";
+  }
+  if (VOICE_CREATION_TYPES.includes(type)) {
+    return "voice";
+  }
+  return "image"; // Default fallback
+}
+
+/**
+ * Check if a type belongs to a category
+ */
+export function isTypeInCategory(
+  type: CreationTypeId,
+  category: CreationCategory
+): boolean {
+  if (category === "all") {
+    return true;
+  }
+  return getTypesForCategory(category).includes(type);
+}
+
+/**
+ * Check if creation type is video
+ */
+export function isVideoCreationType(type?: string): boolean {
+  if (!type) return false;
+  return VIDEO_CREATION_TYPES.includes(type as CreationTypeId);
+}
+
+/**
+ * Check if creation type is image
+ */
+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

@@ -0,0 +1,131 @@
+/**
+ * Creation Filter Types
+ * Advanced filtering options for creations
+ */
+
+import type { CreationTypeId, CreationStatus, CreationCategory } from "./creation-types";
+
+/**
+ * Filter options for querying creations
+ */
+export interface CreationFilter {
+  /** Filter by specific type, category, or all */
+  type?: CreationTypeId | CreationCategory;
+  /** Filter by status */
+  status?: CreationStatus | "all";
+  /** Filter by date range start (timestamp in ms) */
+  startDate?: number;
+  /** Filter by date range end (timestamp in ms) */
+  endDate?: number;
+  /** Search query for prompt or metadata */
+  searchQuery?: string;
+  /** Sort field */
+  sortField?: "createdAt" | "updatedAt" | "type" | "status";
+  /** Sort order */
+  sortOrder?: "asc" | "desc";
+  /** Limit number of results */
+  limit?: number;
+  /** Cursor for pagination (timestamp in ms) */
+  cursor?: number;
+}
+
+/**
+ * Default filter configuration
+ */
+export const DEFAULT_CREATION_FILTER: CreationFilter = {
+  type: "all",
+  status: "all",
+  sortField: "createdAt",
+  sortOrder: "desc",
+  limit: 50,
+};
+
+/**
+ * Filter option for UI display
+ */
+export interface FilterOption {
+  id: string;
+  /** Display label (use labelKey for i18n) */
+  label?: string;
+  /** i18n key for label */
+  labelKey?: string;
+  icon?: string;
+  count?: number;
+}
+
+/**
+ * Media filter options
+ */
+export const MEDIA_FILTER_OPTIONS: FilterOption[] = [
+  { id: "all", labelKey: "creations.filter.all", icon: "Grid" },
+  { id: "image", labelKey: "creations.filter.images", icon: "Image" },
+  { id: "video", labelKey: "creations.filter.videos", icon: "Video" },
+  { id: "voice", labelKey: "creations.filter.voice", icon: "Mic" },
+];
+
+/**
+ * Status filter options
+ */
+export const STATUS_FILTER_OPTIONS: FilterOption[] = [
+  { id: "all", labelKey: "creations.filter.allStatus", icon: "List" },
+  { id: "completed", labelKey: "creations.filter.completed", icon: "CheckCircle" },
+  { id: "processing", labelKey: "creations.filter.processing", icon: "Loader" },
+  { id: "failed", labelKey: "creations.filter.failed", icon: "XCircle" },
+  { id: "pending", labelKey: "creations.filter.pending", icon: "Clock" },
+];
+
+/**
+ * Creation statistics
+ */
+export interface CreationStats {
+  total: number;
+  byCategory: Record<CreationCategory, number>;
+  byStatus: Record<CreationStatus, number>;
+  byType: Partial<Record<CreationTypeId, number>>;
+}
+
+/**
+ * Calculate stats from creations array
+ */
+export function calculateCreationStats(
+  creations: Array<{ type?: string; status?: string }>
+): CreationStats {
+  const stats: CreationStats = {
+    total: creations.length,
+    byCategory: { all: creations.length, image: 0, video: 0, voice: 0 },
+    byStatus: { pending: 0, queued: 0, processing: 0, completed: 0, failed: 0 },
+    byType: {},
+  };
+
+  for (const creation of creations) {
+    // Count by type
+    if (creation.type) {
+      const typeId = creation.type as CreationTypeId;
+      stats.byType[typeId] = (stats.byType[typeId] || 0) + 1;
+    }
+
+    // Count by status
+    if (creation.status) {
+      const status = creation.status as CreationStatus;
+      if (status in stats.byStatus) {
+        stats.byStatus[status]++;
+      }
+    }
+  }
+
+  // Calculate category counts from type counts
+  const { IMAGE_CREATION_TYPES, VIDEO_CREATION_TYPES, VOICE_CREATION_TYPES } =
+    require("./creation-categories");
+
+  for (const [typeId, count] of Object.entries(stats.byType)) {
+    if (IMAGE_CREATION_TYPES.includes(typeId)) {
+      stats.byCategory.image += count as number;
+    } else if (VIDEO_CREATION_TYPES.includes(typeId)) {
+      stats.byCategory.video += count as number;
+    } else if (VOICE_CREATION_TYPES.includes(typeId)) {
+      stats.byCategory.voice += count as number;
+    }
+  }
+
+  return stats;
+}

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

@@ -0,0 +1,63 @@
+/**
+ * Creation Types
+ * Core type definitions for AI-generated creations
+ */
+
+/**
+ * All supported creation types
+ */
+export type CreationTypeId =
+  | "text-to-image"
+  | "text-to-video"
+  | "image-to-video"
+  | "text-to-voice"
+  | "upscale"
+  | "remove-background"
+  | "photo-restore"
+  | "inpainting"
+  | "style-transfer"
+  | "colorization"
+  | "face-swap"
+  | "object-removal"
+  | "background-replacement"
+  | "ai-brush"
+  | "hd-touch-up"
+  | "ai-hug"
+  | "ai-kiss"
+  | "anime-selfie";
+
+/**
+ * Creation status values
+ */
+export type CreationStatus =
+  | "pending"
+  | "queued"
+  | "processing"
+  | "completed"
+  | "failed";
+
+/**
+ * Creation category for grouping types
+ */
+export type CreationCategory = "image" | "video" | "voice" | "all";
+
+/**
+ * All status values as array for iteration
+ */
+export const ALL_CREATION_STATUSES: CreationStatus[] = [
+  "pending",
+  "queued",
+  "processing",
+  "completed",
+  "failed",
+];
+
+/**
+ * All categories as array for iteration
+ */
+export const ALL_CREATION_CATEGORIES: CreationCategory[] = [
+  "all",
+  "image",
+  "video",
+  "voice",
+];

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

@@ -0,0 +1,44 @@
+/**
+ * Creation Domain Types
+ */
+
+// Core types
+export type {
+  CreationTypeId,
+  CreationStatus,
+  CreationCategory,
+} from "./creation-types";
+
+export {
+  ALL_CREATION_STATUSES,
+  ALL_CREATION_CATEGORIES,
+} from "./creation-types";
+
+// Category system
+export {
+  IMAGE_CREATION_TYPES,
+  VIDEO_CREATION_TYPES,
+  VOICE_CREATION_TYPES,
+  ALL_CREATION_TYPES,
+  getTypesForCategory,
+  getCategoryForType,
+  isTypeInCategory,
+  isVideoCreationType,
+  isImageCreationType,
+  isVoiceCreationType,
+  getMediaTypeForCreation,
+} from "./creation-categories";
+
+// Filter types
+export type {
+  CreationFilter,
+  FilterOption,
+  CreationStats,
+} from "./creation-filter";
+
+export {
+  DEFAULT_CREATION_FILTER,
+  MEDIA_FILTER_OPTIONS,
+  STATUS_FILTER_OPTIONS,
+  calculateCreationStats,
+} from "./creation-filter";

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

@@ -0,0 +1,134 @@
+/**
+ * Creation Helpers
+ * Utility functions for creation data manipulation
+ */
+
+import type { CreationTypeId } from "../types";
+
+/**
+ * Icon name type for design system
+ */
+export type IconName = "image" | "film" | "mic" | "sparkles" | "color-palette" | "brush";
+
+/**
+ * Get icon name for creation type
+ */
+export function getTypeIcon(type: CreationTypeId): IconName {
+  switch (type) {
+    case "text-to-video":
+    case "image-to-video":
+      return "film";
+    case "text-to-voice":
+      return "mic";
+    case "style-transfer":
+    case "colorization":
+      return "color-palette";
+    case "ai-brush":
+    case "inpainting":
+      return "brush";
+    default:
+      return "image";
+  }
+}
+
+/**
+ * Get i18n key for creation type
+ */
+export function getTypeTextKey(type: CreationTypeId): string {
+  return `creations.types.${type}`;
+}
+
+/**
+ * Get formatted type text (fallback)
+ */
+export function getTypeText(type: CreationTypeId): string {
+  return type.split("-").map(word =>
+    word.charAt(0).toUpperCase() + word.slice(1)
+  ).join(" ");
+}
+
+/**
+ * Get creation title from prompt or type
+ */
+export function getCreationTitle(
+  prompt?: string,
+  type?: CreationTypeId,
+  maxLength: number = 50
+): string {
+  if (prompt && prompt.length > 0) {
+    return prompt.length > maxLength
+      ? prompt.substring(0, maxLength) + "..."
+      : prompt;
+  }
+
+  if (type) {
+    return getTypeText(type);
+  }
+
+  return "Untitled Creation";
+}
+
+/**
+ * Filter creations by search query (client-side)
+ */
+export function filterBySearch<T extends { prompt?: string; type?: string; provider?: string }>(
+  items: T[],
+  searchQuery?: string,
+): T[] {
+  if (!searchQuery || searchQuery.trim().length === 0) {
+    return items;
+  }
+
+  const query = searchQuery.toLowerCase().trim();
+
+  return items.filter((item) =>
+    item.prompt?.toLowerCase().includes(query) ||
+    item.type?.toLowerCase().includes(query) ||
+    item.provider?.toLowerCase().includes(query)
+  );
+}
+
+/**
+ * Sort creations by field
+ */
+export function sortCreations<T extends Record<string, unknown>>(
+  items: T[],
+  field: keyof T,
+  order: "asc" | "desc" = "desc"
+): T[] {
+  return [...items].sort((a, b) => {
+    const aVal = a[field] as unknown;
+    const bVal = b[field] as unknown;
+
+    if (aVal === undefined && bVal === undefined) return 0;
+    if (aVal === undefined) return 1;
+    if (bVal === undefined) return -1;
+
+    if (typeof aVal === "string" && typeof bVal === "string") {
+      return order === "desc"
+        ? bVal.localeCompare(aVal)
+        : aVal.localeCompare(bVal);
+    }
+
+    if (typeof aVal === "number" && typeof bVal === "number") {
+      return order === "desc" ? bVal - aVal : aVal - bVal;
+    }
+
+    // Handle Date objects
+    if (aVal instanceof Date && bVal instanceof Date) {
+      return order === "desc"
+        ? bVal.getTime() - aVal.getTime()
+        : aVal.getTime() - bVal.getTime();
+    }
+
+    return 0;
+  });
+}
+
+/**
+ * Truncate text with ellipsis
+ */
+export function truncateText(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return text.substring(0, maxLength - 3) + "...";
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Creation Domain Utils
+ * Utility functions for creation operations
+ */
+
+export * from "./status-helpers";
+export * from "./preview-helpers";
+export * from "./creation-helpers";