@umituz/react-native-ai-generation-content 1.87.0 → 1.87.2

package/package.json

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

package/src/domains/background/infrastructure/executors/backgroundJobExecutor.ts

@@ -89,6 +89,14 @@ export const executeQueuedJob = async <TInput, TResult>(
     if (completedJob) {
       await executor.onComplete?.(completedJob);
       onJobComplete?.(completedJob);
+    } else {
+      // Job reference lost - log for debugging
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn("[BackgroundJobExecutor] Completed job not found in cache:", {
+          jobId,
+          timestamp: new Date().toISOString(),
+        });
+      }
     }
 
     // Await removal to ensure cleanup happens before checking activeJobs
@@ -103,13 +111,28 @@ export const executeQueuedJob = async <TInput, TResult>(
     if (failedJob) {
       await executor.onError?.(failedJob, error instanceof Error ? error : new Error(errorMsg));
       onJobError?.(failedJob);
+    } else {
+      // Job reference lost - log for debugging
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn("[BackgroundJobExecutor] Failed job not found in cache:", {
+          jobId,
+          error: errorMsg,
+          timestamp: new Date().toISOString(),
+        });
+      }
     }
 
     // Remove failed job from cache to prevent accumulation
     try {
       await removeJobAsync(jobId);
-    } catch {
-      // Best effort cleanup
+    } catch (removeError) {
+      // Log cleanup failure but don't throw - state is already consistent
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[BackgroundJobExecutor] Failed to remove job after error:", {
+          jobId,
+          error: removeError instanceof Error ? removeError.message : String(removeError),
+        });
+      }
     }
   } finally {
     // Use atomic Set operation to prevent race conditions

package/src/domains/background/infrastructure/services/job-poller.service.ts

@@ -31,7 +31,11 @@ function withAbortSignal<T>(
       return;
     }
 
+    let isResolved = false;
     const abortHandler = () => {
+      if (isResolved) return;
+      isResolved = true;
+      if (timeoutId) clearTimeout(timeoutId);
       reject(new Error("Operation aborted"));
     };
 
@@ -41,17 +45,24 @@ function withAbortSignal<T>(
     let timeoutId: ReturnType<typeof setTimeout> | undefined;
     if (timeoutMs) {
       timeoutId = setTimeout(() => {
+        if (isResolved) return;
+        isResolved = true;
+        signal?.removeEventListener("abort", abortHandler);
         reject(new Error(`Operation timeout after ${timeoutMs}ms`));
       }, timeoutMs);
     }
 
     promise
       .then((result) => {
+        if (isResolved) return;
+        isResolved = true;
         signal?.removeEventListener("abort", abortHandler);
         if (timeoutId) clearTimeout(timeoutId);
         resolve(result);
       })
       .catch((error) => {
+        if (isResolved) return;
+        isResolved = true;
         signal?.removeEventListener("abort", abortHandler);
         if (timeoutId) clearTimeout(timeoutId);
         reject(error);

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

@@ -19,7 +19,15 @@ export class CreationsQuery {
 
     /**
      * Get all creations for a user
-     * Optimized query: Server-side filtering for non-deleted items
+     *
+     * NOTE: Client-side filtering for deletedAt is used here for simplicity.
+     * For better performance with large datasets, consider:
+     * 1. Adding a where clause: where(CREATION_FIELDS.DELETED_AT, "==", null)
+     * 2. Creating a composite index on (deletedAt, createdAt)
+     *
+     * Current implementation fetches all documents including soft-deleted ones,
+     * which is acceptable for small-to-medium datasets but may impact performance
+     * at scale.
      */
     async getAll(userId: string): Promise<Creation[]> {
         const userCollection = this.pathResolver.getUserCollection(userId);

package/src/domains/creations/infrastructure/repositories/creation-create.operations.ts

@@ -19,16 +19,16 @@ export async function createCreation(
     uri: creation.uri,
     createdAt: creation.createdAt,
     deletedAt: null,
-    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 }),
-    ...(creation.provider !== undefined && { provider: creation.provider }),
-    ...(creation.requestId !== undefined && { requestId: creation.requestId }),
-    ...(creation.model !== undefined && { model: creation.model }),
-    ...(creation.startedAt !== undefined && { startedAt: creation.startedAt }),
+    metadata: creation.metadata ?? {},
+    isShared: creation.isShared ?? false,
+    isFavorite: creation.isFavorite ?? false,
+    status: creation.status ?? null,
+    output: creation.output ?? null,
+    prompt: creation.prompt ?? null,
+    provider: creation.provider ?? null,
+    requestId: creation.requestId ?? null,
+    model: creation.model ?? null,
+    startedAt: creation.startedAt ?? null,
   };
 
   try {

package/src/domains/image-to-video/index.ts

@@ -48,8 +48,8 @@ export type {
 // INFRASTRUCTURE LAYER
 // =============================================================================
 
-export { executeImageToVideo, hasImageToVideoSupport } from "./infrastructure";
-export type { ExecuteImageToVideoOptions } from "./infrastructure";
+export { executeImageToVideo, hasImageToVideoSupport } from "./infrastructure/services";
+export type { ExecuteImageToVideoOptions } from "./infrastructure/services";
 
 // =============================================================================
 // PRESENTATION LAYER - Hooks

package/src/domains/image-to-video/presentation/components/index.ts

@@ -18,5 +18,5 @@ export type {
 } from "./ImageSelectionGrid";
 
 // Action Components
-export { GenerateButton as ImageToVideoGenerateButton } from "../../../../presentation/components/buttons";
-export type { GenerateButtonProps as ImageToVideoGenerateButtonProps } from "../../../../presentation/components/buttons";
+export { GenerateButton as ImageToVideoGenerateButton } from "../../../../presentation/components/buttons/GenerateButton";
+export type { GenerateButtonProps as ImageToVideoGenerateButtonProps } from "../../../../presentation/components/buttons/GenerateButton";

package/src/domains/text-to-image/infrastructure-exports.ts

@@ -2,5 +2,5 @@
  * Text-to-Image Infrastructure Layer Exports
  */
 
-export { executeTextToImage, hasTextToImageSupport } from "./infrastructure";
-export type { ExecuteTextToImageOptions } from "./infrastructure";
+export { executeTextToImage, hasTextToImageSupport } from "./infrastructure/services";
+export type { ExecuteTextToImageOptions } from "./infrastructure/services";

package/src/domains/text-to-image/presentation/components/index.ts

@@ -7,8 +7,8 @@
 export { PromptInput as TextToImagePromptInput } from "../../../../presentation/components/PromptInput";
 export type { PromptInputProps as TextToImagePromptInputProps } from "../../../../presentation/components/PromptInput";
 
-export { ExamplePrompts as TextToImageExamplePrompts } from "../../../../presentation/components/prompts";
-export type { ExamplePromptsProps as TextToImageExamplePromptsProps } from "../../../../presentation/components/prompts";
+export { ExamplePrompts as TextToImageExamplePrompts } from "../../../../presentation/components/prompts/ExamplePrompts";
+export type { ExamplePromptsProps as TextToImageExamplePromptsProps } from "../../../../presentation/components/prompts/ExamplePrompts";
 
 // Selector Components
 export { StyleSelector as TextToImageStyleSelector } from "../../../../presentation/components/selectors";
@@ -22,8 +22,8 @@ export { GridSelector as TextToImageOutputFormatSelector } from "../../../../pre
 export { GridSelector as TextToImageNumImagesSelector } from "../../../../presentation/components/selectors";
 
 // Action Components
-export { GenerateButton as TextToImageGenerateButton } from "../../../../presentation/components/buttons";
-export type { GenerateButtonProps as TextToImageGenerateButtonProps } from "../../../../presentation/components/buttons";
+export { GenerateButton as TextToImageGenerateButton } from "../../../../presentation/components/buttons/GenerateButton";
+export type { GenerateButtonProps as TextToImageGenerateButtonProps } from "../../../../presentation/components/buttons/GenerateButton";
 
 // Sheet Components
 export { SettingsSheet as TextToImageSettingsSheet } from "../../../../presentation/components/modals/SettingsSheet";

package/src/domains/text-to-video/index.ts

@@ -41,8 +41,8 @@ export type {
 export { INITIAL_FORM_STATE, INITIAL_GENERATION_STATE } from "./domain";
 
 // Infrastructure Services
-export { executeTextToVideo, hasTextToVideoSupport } from "./infrastructure";
-export type { ExecuteTextToVideoOptions } from "./infrastructure";
+export { executeTextToVideo, hasTextToVideoSupport } from "./infrastructure/services";
+export type { ExecuteTextToVideoOptions } from "./infrastructure/services";
 
 // Presentation Hooks
 export {

package/src/infrastructure/services/image-feature-executor.service.ts

@@ -35,7 +35,7 @@ export interface ImageFeatureRequest {
 export async function executeImageFeature(
   featureType: ImageFeatureType,
   request: ImageFeatureRequest,
-  options?: ExecuteImageFeatureOptions,
+  options: ExecuteImageFeatureOptions = {},
 ): Promise<ImageFeatureResult> {
   const validation = validateProvider(`Image:${featureType}`);
   if (!validation.success) {
@@ -43,7 +43,7 @@ export async function executeImageFeature(
   }
 
   const { provider } = validation;
-  const { extractResult, onProgress } = options ?? {};
+  const { extractResult, onProgress } = options;
   const model = provider.getImageFeatureModel(featureType);
 
   try {

package/src/infrastructure/services/video-feature-executor.service.ts

@@ -18,7 +18,7 @@ import type { ExecuteVideoFeatureOptions, VideoFeatureResult, VideoFeatureReques
 export async function executeVideoFeature(
   featureType: VideoFeatureType,
   request: VideoFeatureRequest,
-  options?: ExecuteVideoFeatureOptions,
+  options: ExecuteVideoFeatureOptions = {},
 ): Promise<VideoFeatureResult> {
   const validation = validateProvider(`VideoExecutor:${featureType}`);
   if (!validation.success) {
@@ -26,7 +26,7 @@ export async function executeVideoFeature(
   }
 
   const { provider } = validation;
-  const { extractResult, onStatusChange } = options ?? {};
+  const { extractResult, onStatusChange } = options;
   const model = provider.getVideoFeatureModel(featureType);
 
   try {

package/src/infrastructure/utils/feature-utils.ts

@@ -87,15 +87,20 @@ async function checkCreditGuard(cost: number, featureName: string): Promise<bool
 
   if (!authService.isAuthenticated()) {
     if (__DEV__) {
-       
       console.log(`[${featureName}] Auth required`);
     }
     try {
       authService.requireAuth();
+      // If requireAuth succeeds (e.g., user was already logged in), check auth status again
+      if (!authService.isAuthenticated()) {
+        // requireAuth succeeded but user is still not authenticated
+        // This can happen if requireAuth just navigated without throwing
+        return false;
+      }
     } catch {
+      // requireAuth threw an error (e.g., user cancelled login, navigation failed)
       return false;
     }
-    return false;
   }
 
   const hasCredits = await creditService.checkCredits(cost);

package/src/presentation/components/buttons/index.ts

@@ -1 +1,2 @@
-export { GenerateButton, type GenerateButtonProps } from "./GenerateButton";
+export { GenerateButton } from "./GenerateButton";
+export type { GenerateButtonProps } from "./GenerateButton";

package/src/presentation/components/image-picker/index.ts

@@ -1 +1,2 @@
-export { DualImagePicker, type DualImagePickerProps } from "./DualImagePicker";
+export { DualImagePicker } from "./DualImagePicker";
+export type { DualImagePickerProps } from "./DualImagePicker";

package/src/presentation/hooks/ai-feature-callbacks-execution.hooks.ts

@@ -43,7 +43,9 @@ export function useExecutionCallback<TRequest = unknown, TResult = unknown>(
         }
 
         if (result.success) {
-          return { success: true, imageUrls: result.imageUrls ?? [] };
+          // imageUrls is required when result.success is true
+          // executor must provide it
+          return { success: true, imageUrls: result.imageUrls! };
         }
         return { success: false, error: result.error ?? "Unknown error" };
       } catch (error) {

package/src/presentation/hooks/generation/moderation-handler.ts

@@ -49,12 +49,16 @@ export async function handleModeration<TInput, TResult>(
       moderation.onShowWarning(
         moderationResult.warnings,
         () => {
+          // Cancel callback - reset state
           isGeneratingRef.current = false;
           if (isMountedRef.current) resetState();
         },
-        () => {
-          // Return the promise to allow proper error handling chain
-          return executeGeneration(input).catch(async (err) => {
+        async () => {
+          // Proceed callback - execute generation with full error handling
+          try {
+            const result = await executeGeneration(input);
+            return result;
+          } catch (err) {
             const error = parseError(err);
             if (isMountedRef.current) {
               setState({ status: "error", isGenerating: false, result: null, error });
@@ -63,9 +67,9 @@ export async function handleModeration<TInput, TResult>(
             await onError?.(error);
             handleLifecycleComplete("error", undefined, error);
             throw error; // Re-throw to allow caller to handle
-          }).finally(() => {
+          } finally {
             isGeneratingRef.current = false;
-          });
+          }
         },
       );
       return undefined;

package/src/presentation/hooks/generation/orchestrator.ts

@@ -16,8 +16,12 @@ import type {
   UseGenerationOrchestratorReturn,
 } from "./types";
 
-
-const INITIAL_STATE = { status: "idle" as const, isGenerating: false, result: null, error: null };
+const getInitialState = <T>(): GenerationState<T> => ({
+  status: "idle",
+  isGenerating: false,
+  result: null,
+  error: null,
+});
 
 export const useGenerationOrchestrator = <TInput, TResult>(
   strategy: GenerationStrategy<TInput, TResult>,
@@ -25,7 +29,7 @@ export const useGenerationOrchestrator = <TInput, TResult>(
 ): UseGenerationOrchestratorReturn<TInput, TResult> => {
   const { userId, alertMessages, onSuccess, onError, moderation, lifecycle } = config;
 
-  const [state, setState] = useState<GenerationState<TResult>>(INITIAL_STATE);
+  const [state, setState] = useState<GenerationState<TResult>>(getInitialState<TResult>());
   const isGeneratingRef = useRef(false);
   const isMountedRef = useRef(true);
   const abortControllerRef = useRef<AbortController | null>(null);
@@ -83,17 +87,42 @@ export const useGenerationOrchestrator = <TInput, TResult>(
         console.log("[Orchestrator] executeGeneration() called");
       }
 
+      // Check abort signal before starting
+      if (abortControllerRef.current?.signal.aborted) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Aborted before generation started");
+        }
+        throw new Error("Generation aborted");
+      }
+
       setState((prev) => ({ ...prev, status: "generating" }));
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[Orchestrator] State: generating - calling strategy.execute()");
       }
 
       const result = await strategy.execute(input);
+
+      // Check abort signal after execution
+      if (abortControllerRef.current?.signal.aborted) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Aborted after generation completed");
+        }
+        throw new Error("Generation aborted");
+      }
+
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[Orchestrator] strategy.execute() completed");
       }
 
       if (strategy.save && userId) {
+        // Check abort signal before save
+        if (abortControllerRef.current?.signal.aborted) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] Aborted before save");
+          }
+          throw new Error("Generation aborted");
+        }
+
         if (isMountedRef.current) setState((prev) => ({ ...prev, status: "saving" }));
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[Orchestrator] Saving result to Firestore");
@@ -107,10 +136,22 @@ export const useGenerationOrchestrator = <TInput, TResult>(
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.log("[Orchestrator] ERROR: Save failed:", saveErr);
           }
+          // Update state to error on save failure
+          if (isMountedRef.current) {
+            setState((prev) => ({ ...prev, status: "error", isGenerating: false }));
+          }
           throw createGenerationError("save", alertMessages.saveFailed, saveErr instanceof Error ? saveErr : undefined);
         }
       }
 
+      // Final abort check before success
+      if (abortControllerRef.current?.signal.aborted) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] Aborted before success callback");
+        }
+        throw new Error("Generation aborted");
+      }
+
       if (isMountedRef.current) setState({ status: "success", isGenerating: false, result, error: null });
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[Orchestrator] ✅ Generation SUCCESS");
@@ -126,7 +167,7 @@ export const useGenerationOrchestrator = <TInput, TResult>(
   );
 
   const generate = useCallback(
-    async (input: TInput) => {
+    async (input: TInput): Promise<TResult | void> => {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[Orchestrator] ========================================");
         console.log("[Orchestrator] generate() called with input:", JSON.stringify(input).substring(0, 200));
@@ -145,7 +186,7 @@ export const useGenerationOrchestrator = <TInput, TResult>(
       abortControllerRef.current = new AbortController();
       isGeneratingRef.current = true;
       let moderationPending = false;
-      setState({ ...INITIAL_STATE, status: "checking", isGenerating: true });
+      setState({ ...getInitialState<TResult>(), status: "checking", isGenerating: true });
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[Orchestrator] State set to 'checking', isGenerating: true");
@@ -183,7 +224,7 @@ export const useGenerationOrchestrator = <TInput, TResult>(
           isMountedRef,
           isGeneratingRef,
           setState: (s) => setState(s as GenerationState<TResult>),
-          resetState: () => setState(INITIAL_STATE),
+          resetState: () => setState(getInitialState<TResult>()),
           executeGeneration,
           showError,
           onError,
@@ -227,7 +268,7 @@ export const useGenerationOrchestrator = <TInput, TResult>(
   const reset = useCallback(() => {
     abortControllerRef.current?.abort();
     abortControllerRef.current = null;
-    setState(INITIAL_STATE);
+    setState(getInitialState<TResult>());
     isGeneratingRef.current = false;
   }, []);
 

package/src/presentation/hooks/generation/repositorySingleton.ts

@@ -0,0 +1,17 @@
+/**
+ * Repository Singleton
+ * Prevents multiple repository instances across hooks
+ */
+
+import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";
+
+const REPO_COLLECTION = "creations";
+
+let repositoryInstance: ReturnType<typeof createCreationsRepository> | null = null;
+
+export function getCreationsRepository() {
+  if (!repositoryInstance) {
+    repositoryInstance = createCreationsRepository(REPO_COLLECTION);
+  }
+  return repositoryInstance;
+}

package/src/presentation/hooks/generation/useAudioGenerationExecutor.ts

@@ -9,10 +9,10 @@
  *   - buildMetadata: creation metadata
  */
 
-import { useState, useCallback, useMemo } from "react";
+import { useState, useCallback } from "react";
 import { useGenerationServices } from "../../../infrastructure/providers/generation-services.provider";
 import { resolveProvider } from "../../../infrastructure/services/provider-resolver";
-import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";
+import { getCreationsRepository } from "./repositorySingleton";
 import type { GenerationTarget } from "./useImageGenerationExecutor";
 import { handleCreditRefund, logGenerationError, generateCreationId } from "./generation-execution.utils";
 
@@ -60,10 +60,7 @@ export function useAudioGenerationExecutor<P>(
 ): AudioGenerationExecutorReturn<P> {
   const { userId, deductCredits, refundCredits, onGenerationSuccess } =
     useGenerationServices();
-  const repository = useMemo(
-    () => createCreationsRepository("creations"),
-    [],
-  );
+  const repository = getCreationsRepository();
   const [error, setError] = useState<string | null>(null);
   const [isLoading, setIsLoading] = useState(false);
 
@@ -106,7 +103,7 @@ export function useAudioGenerationExecutor<P>(
           output: { audioUrl },
           model: input.target.model,
           prompt: input.prompt,
-          metadata: config.buildMetadata?.(params) ?? {},
+          metadata: config.buildMetadata?.(params),
         });
 
         if (config.trackRating && onGenerationSuccess) {

package/src/presentation/hooks/generation/useImageGenerationExecutor.ts

@@ -11,10 +11,10 @@
  * Auth and credit services come from GenerationServicesProvider context.
  */
 
-import { useState, useCallback, useMemo } from "react";
+import { useState, useCallback } from "react";
 import { useGenerationServices } from "../../../infrastructure/providers/generation-services.provider";
 import { resolveProvider } from "../../../infrastructure/services/provider-resolver";
-import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";
+import { getCreationsRepository } from "./repositorySingleton";
 import { preprocessImageInputs } from "../../../infrastructure/utils/image-input-preprocessor.util";
 import { resolveType, handleCreditRefund, logGenerationError, generateCreationId } from "./generation-execution.utils";
 
@@ -66,10 +66,7 @@ export function useImageGenerationExecutor<P>(
 ): ImageGenerationExecutorReturn<P> {
   const { userId, deductCredits, refundCredits, onGenerationSuccess } =
     useGenerationServices();
-  const repository = useMemo(
-    () => createCreationsRepository("creations"),
-    [],
-  );
+  const repository = getCreationsRepository();
   const [error, setError] = useState<string | null>(null);
   const [isLoading, setIsLoading] = useState(false);
 

package/src/presentation/hooks/generation/useImagePicker.ts

@@ -26,7 +26,7 @@ export interface UseImagePickerReturn {
   reset(): void;
 }
 
-export const useImagePicker = (options: UseImagePickerOptions = {}): UseImagePickerReturn => {
+export const useImagePicker = (options: UseImagePickerOptions): UseImagePickerReturn => {
   const { aspect = [1, 1], onError } = options;
 
   const [uri, setUri] = useState<string | null>(null);

package/src/shared/hooks/factories/createFormStateHook.ts

@@ -113,7 +113,3 @@ export function createFormStateHook<
     return { state, actions };
   };
 }
-
-// Note: createFormStateHookWithIndividualState removed due to type complexity
-// and lack of usage. Use createFormStateHook instead which provides the same
-// functionality with better type safety.

package/src/shared/utils/credit.ts

@@ -0,0 +1,69 @@
+/**
+ * Credit Calculation Utilities
+ * Provides consistent credit calculation operations
+ */
+
+/**
+ * Validates if a value is a valid credit amount
+ * @param credits - Credit value to validate
+ * @returns True if valid (non-negative number)
+ */
+export function isValidCreditAmount(credits: number): boolean {
+  return typeof credits === "number" && !isNaN(credits) && credits >= 0 && isFinite(credits);
+}
+
+/**
+ * Calculates total credits from multiple items
+ * @param items - Array of credit costs
+ * @returns Total credits
+ */
+export function sumCredits(...items: number[]): number {
+  return items.reduce((sum, credits) => {
+    if (!isValidCreditAmount(credits)) return sum;
+    return sum + credits;
+  }, 0);
+}
+
+/**
+ * Calculates credits per unit from total cost
+ * @param totalCost - Total cost in base currency
+ * @param units - Number of units
+ * @returns Cost per unit
+ */
+export function calculateCostPerUnit(totalCost: number, units: number): number {
+  if (units <= 0) return 0;
+  return totalCost / units;
+}
+
+/**
+ * Calculates total cost from per-unit cost
+ * @param costPerUnit - Cost per single unit
+ * @param units - Number of units
+ * @returns Total cost
+ */
+export function calculateTotalCost(costPerUnit: number, units: number): number {
+  if (units <= 0) return 0;
+  return costPerUnit * units;
+}
+
+/**
+ * Formats credits for display
+ * @param credits - Credit amount
+ * @returns Formatted string
+ */
+export function formatCredits(credits: number): string {
+  if (!isValidCreditAmount(credits)) return "0";
+  return Math.floor(credits).toString();
+}
+
+/**
+ * Parses credits from a string value
+ * @param value - String value to parse
+ * @param defaultValue - Default value if parsing fails (default: 0)
+ * @returns Parsed credits
+ */
+export function parseCredits(value: string, defaultValue: number = 0): number {
+  const parsed = parseFloat(value);
+  if (isNaN(parsed)) return defaultValue;
+  return Math.max(0, parsed);
+}

package/src/shared/utils/date/index.ts

@@ -1,11 +1,7 @@
 /**
  * Date Utilities
- * Centralized date handling utilities
+ * Date normalization and timestamp operations
  */
 
-export {
-  normalizeDateToTimestamp,
-  normalizeToDate,
-  isValidDate,
-  compareDates,
-} from "./normalization";
+export * from "./normalization";
+export * from "./timestamp";

package/src/shared/utils/date/timestamp.ts

@@ -0,0 +1,71 @@
+/**
+ * Timestamp Utilities
+ * Provides consistent timestamp operations across the application
+ */
+
+/**
+ * Gets the current timestamp in milliseconds
+ * @returns Current timestamp in milliseconds
+ */
+export function getCurrentTimestamp(): number {
+  return Date.now();
+}
+
+/**
+ * Calculates elapsed time in milliseconds
+ * @param startTime - Start timestamp in milliseconds
+ * @param endTime - End timestamp in milliseconds (defaults to current time)
+ * @returns Elapsed time in milliseconds
+ */
+export function getElapsedMs(startTime: number, endTime?: number): number {
+  const end = endTime ?? Date.now();
+  return end - startTime;
+}
+
+/**
+ * Formats elapsed time in milliseconds to a human-readable string
+ * @param elapsedMs - Elapsed time in milliseconds
+ * @returns Formatted string (e.g., "1.5s", "500ms", "2m 30s")
+ */
+export function formatElapsedMs(elapsedMs: number): string {
+  if (elapsedMs < 1000) {
+    return `${elapsedMs}ms`;
+  }
+  if (elapsedMs < 60000) {
+    return `${(elapsedMs / 1000).toFixed(1)}s`;
+  }
+  const minutes = Math.floor(elapsedMs / 60000);
+  const seconds = Math.floor((elapsedMs % 60000) / 1000);
+  return `${minutes}m ${seconds}s`;
+}
+
+/**
+ * Creates a unique timestamp-based ID
+ * @param prefix - Optional prefix for the ID
+ * @returns Unique ID with timestamp
+ */
+export function createTimestampId(prefix: string = ""): string {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).slice(2, 9);
+  return prefix ? `${prefix}-${timestamp}-${random}` : `${timestamp}-${random}`;
+}
+
+/**
+ * Converts a timestamp to ISO string
+ * @param timestamp - Timestamp in milliseconds
+ * @returns ISO 8601 formatted string
+ */
+export function timestampToISOString(timestamp: number): string {
+  return new Date(timestamp).toISOString();
+}
+
+/**
+ * Checks if a timestamp is recent (within the specified milliseconds)
+ * @param timestamp - Timestamp to check
+ * @param recentMs - Threshold for "recent" in milliseconds (default: 5000ms)
+ * @returns True if timestamp is within the threshold
+ */
+export function isTimestampRecent(timestamp: number, recentMs: number = 5000): boolean {
+  const elapsed = Date.now() - timestamp;
+  return elapsed >= 0 && elapsed <= recentMs;
+}

package/src/shared/utils/progress.ts

@@ -0,0 +1,123 @@
+/**
+ * Progress Utilities
+ * Provides consistent progress calculations and mappings
+ */
+
+/**
+ * Clamps a value between 0 and 100
+ * @param value - Value to clamp
+ * @returns Clamped value between 0 and 100
+ */
+export function clampProgress(value: number): number {
+  return Math.max(0, Math.min(100, value));
+}
+
+/**
+ * Maps a value from one range to another (0-100)
+ * @param value - Value to map
+ * @param min - Minimum of input range
+ * @param max - Maximum of input range
+ * @returns Mapped value in 0-100 range
+ */
+export function mapToProgress(value: number, min: number, max: number): number {
+  if (max === min) return 0;
+  const normalized = (value - min) / (max - min);
+  return clampProgress(normalized * 100);
+}
+
+/**
+ * Maps a value from one range to another (0-100) with optional clamping
+ * @param value - Value to map
+ * @param min - Minimum of input range
+ * @param max - Maximum of input range
+ * @param clamp - Whether to clamp the result (default: true)
+ * @returns Mapped value in 0-100 range
+ */
+export function mapRangeToProgress(
+  value: number,
+  min: number,
+  max: number,
+  clamp: boolean = true
+): number {
+  if (max === min) return 0;
+  const normalized = (value - min) / (max - min);
+  const result = normalized * 100;
+  return clamp ? clampProgress(result) : result;
+}
+
+/**
+ * Calculates progress percentage from current and total
+ * @param current - Current value
+ * @param total - Total value
+ * @returns Progress percentage (0-100)
+ */
+export function calculateProgress(current: number, total: number): number {
+  if (total <= 0) return 0;
+  if (current >= total) return 100;
+  return clampProgress((current / total) * 100);
+}
+
+/**
+ * Interpolates between two values based on progress (0-100)
+ * @param start - Start value
+ * @param end - End value
+ * @param progress - Progress (0-100)
+ * @returns Interpolated value
+ */
+export function interpolateProgress(start: number, end: number, progress: number): number {
+  const clampedProgress = clampProgress(progress);
+  const factor = clampedProgress / 100;
+  return start + (end - start) * factor;
+}
+
+/**
+ * Converts linear progress to eased progress (smooth animation)
+ * @param progress - Linear progress (0-100)
+ * @param easing - Easing function (default: ease-out cubic)
+ * @returns Eased progress (0-100)
+ */
+export function easeProgress(
+  progress: number,
+  easing: "linear" | "easeIn" | "easeOut" | "easeInOut" = "easeOut"
+): number {
+  const clamped = clampProgress(progress);
+  const normalized = clamped / 100;
+
+  let eased: number;
+  switch (easing) {
+    case "linear":
+      eased = normalized;
+      break;
+    case "easeIn":
+      eased = normalized * normalized;
+      break;
+    case "easeOut":
+      eased = 1 - Math.pow(1 - normalized, 2);
+      break;
+    case "easeInOut":
+      eased = normalized < 0.5
+        ? 2 * normalized * normalized
+        : 1 - Math.pow(-2 * normalized + 2, 2) / 2;
+      break;
+  }
+
+  return eased * 100;
+}
+
+/**
+ * Checks if progress is complete (100)
+ * @param progress - Progress value to check
+ * @returns True if progress is 100
+ */
+export function isProgressComplete(progress: number): boolean {
+  return progress >= 100;
+}
+
+/**
+ * Checks if progress has started (> 0)
+ * @param progress - Progress value to check
+ * @returns True if progress is greater than 0
+ */
+export function hasProgressStarted(progress: number): boolean {
+  return progress > 0;
+}

package/src/domains/text-to-image/infrastructure/index.ts

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

package/src/domains/text-to-video/infrastructure/index.ts

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

package/src/presentation/components/prompts/index.ts

@@ -1 +0,0 @@
-export { ExamplePrompts, type ExamplePromptsProps } from "./ExamplePrompts";