@umituz/react-native-ai-generation-content 1.26.2 → 1.26.4

package/src/features/text-to-video/presentation/components/OptionsPanel.tsx

@@ -1,121 +0,0 @@
-/**
- * OptionsPanel Component
- * Single Responsibility: Display toggleable options for video generation
- */
-
-import React from "react";
-import { View, StyleSheet, Switch, TouchableOpacity } from "react-native";
-import {
-  AtomicText,
-  useAppDesignTokens,
-} from "@umituz/react-native-design-system";
-import type { OptionsPanelProps } from "../../domain/types";
-
-export const OptionsPanel: React.FC<OptionsPanelProps> = ({
-  soundEnabled,
-  onSoundToggle,
-  professionalMode,
-  onProfessionalModeToggle,
-  duration,
-  soundLabel,
-  soundBadge,
-  professionalLabel,
-  style,
-}) => {
-  const tokens = useAppDesignTokens();
-
-  return (
-    <View style={[styles.container, style]}>
-      <View style={styles.row}>
-        <View style={styles.labelContainer}>
-          <AtomicText type="labelMedium" style={styles.label}>
-            {soundLabel}
-          </AtomicText>
-          {soundBadge && (
-            <View
-              style={[styles.badge, { backgroundColor: tokens.colors.success }]}
-            >
-              <AtomicText type="labelSmall" style={[styles.badgeText, { color: tokens.colors.textInverse }]}>
-                {soundBadge}
-              </AtomicText>
-            </View>
-          )}
-        </View>
-        <Switch
-          value={soundEnabled}
-          onValueChange={onSoundToggle}
-          trackColor={{
-            false: tokens.colors.surface,
-            true: tokens.colors.success,
-          }}
-        />
-      </View>
-
-      <View style={styles.controlsRow}>
-        <TouchableOpacity
-          style={[
-            styles.controlButton,
-            { backgroundColor: professionalMode ? tokens.colors.surface : tokens.colors.surfaceVariant },
-          ]}
-          onPress={() => onProfessionalModeToggle(!professionalMode)}
-        >
-          <AtomicText
-            type="labelMedium"
-            color={professionalMode ? "textPrimary" : "textSecondary"}
-          >
-            {professionalLabel}
-          </AtomicText>
-        </TouchableOpacity>
-
-        <TouchableOpacity style={[styles.controlButton, styles.durationButton, { backgroundColor: tokens.colors.surfaceVariant }]}>
-          <AtomicText type="labelMedium" color="textSecondary">
-            {duration}s
-          </AtomicText>
-        </TouchableOpacity>
-      </View>
-    </View>
-  );
-};
-
-const styles = StyleSheet.create({
-  container: {
-    marginBottom: 24,
-    gap: 16,
-  },
-  row: {
-    flexDirection: "row",
-    alignItems: "center",
-    justifyContent: "space-between",
-  },
-  labelContainer: {
-    flexDirection: "row",
-    alignItems: "center",
-    gap: 8,
-  },
-  label: {
-    fontWeight: "600",
-  },
-  badge: {
-    paddingHorizontal: 8,
-    paddingVertical: 2,
-    borderRadius: 4,
-  },
-  badgeText: {
-    fontWeight: "bold",
-    fontSize: 10,
-  },
-  controlsRow: {
-    flexDirection: "row",
-    gap: 12,
-  },
-  controlButton: {
-    paddingHorizontal: 16,
-    paddingVertical: 10,
-    borderRadius: 8,
-    alignItems: "center",
-    justifyContent: "center",
-  },
-  durationButton: {
-    minWidth: 60,
-  },
-});

package/src/features/text-to-video/presentation/components/index.ts

@@ -1,10 +0,0 @@
-/**
- * Text-to-Video Presentation Components
- * Single Responsibility: Export all components
- */
-
-export { GenerationTabs } from "./GenerationTabs";
-export { FrameSelector } from "./FrameSelector";
-export { OptionsPanel } from "./OptionsPanel";
-export { HeroSection } from "./HeroSection";
-export { HintCarousel } from "./HintCarousel";

package/src/features/text-to-video/presentation/hooks/index.ts

@@ -1,17 +0,0 @@
-/**
- * Text-to-Video Presentation Hooks
- * Single Responsibility: Export all hooks
- */
-
-export { useTextToVideoFeature } from "./useTextToVideoFeature";
-export type {
-  UseTextToVideoFeatureProps,
-  UseTextToVideoFeatureReturn,
-  TextToVideoGenerateParams,
-} from "./useTextToVideoFeature";
-
-export { useTextToVideoForm } from "./useTextToVideoForm";
-export type {
-  UseTextToVideoFormProps,
-  UseTextToVideoFormReturn,
-} from "./useTextToVideoForm";

package/src/features/text-to-video/presentation/hooks/useTextToVideoFeature.ts

@@ -1,225 +0,0 @@
-/**
- * useTextToVideoFeature Hook
- * Uses centralized orchestrator for auth, credits, moderation, and error handling
- */
-
-import { useState, useCallback, useMemo } from "react";
-import {
-  useGenerationOrchestrator,
-  type GenerationStrategy,
-  type AlertMessages,
-} from "../../../../presentation/hooks/generation";
-import { executeTextToVideo } from "../../infrastructure/services";
-import type {
-  TextToVideoFeatureState,
-  TextToVideoConfig,
-  TextToVideoCallbacks,
-  TextToVideoResult,
-  TextToVideoOptions,
-  TextToVideoInputBuilder,
-  TextToVideoResultExtractor,
-} from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-export interface UseTextToVideoFeatureProps {
-  config: TextToVideoConfig;
-  callbacks: TextToVideoCallbacks;
-  userId: string;
-  buildInput: TextToVideoInputBuilder;
-  extractResult?: TextToVideoResultExtractor;
-}
-
-export interface TextToVideoGenerateParams extends TextToVideoOptions {
-  prompt?: string;
-}
-
-export interface UseTextToVideoFeatureReturn {
-  state: TextToVideoFeatureState;
-  setPrompt: (prompt: string) => void;
-  generate: (params?: TextToVideoGenerateParams) => Promise<TextToVideoResult>;
-  reset: () => void;
-  isReady: boolean;
-  canGenerate: boolean;
-}
-
-const INITIAL_STATE: TextToVideoFeatureState = {
-  prompt: "",
-  videoUrl: null,
-  thumbnailUrl: null,
-  isProcessing: false,
-  progress: 0,
-  error: null,
-};
-
-const DEFAULT_ALERT_MESSAGES: AlertMessages = {
-  networkError: "No internet connection. Please check your network.",
-  policyViolation: "Content not allowed. Please try again.",
-  saveFailed: "Failed to save. Please try again.",
-  creditFailed: "Credit operation failed. Please try again.",
-  unknown: "An error occurred. Please try again.",
-};
-
-interface VideoGenerationInput {
-  prompt: string;
-  options?: TextToVideoOptions;
-  creationId: string;
-}
-
-function generateCreationId(): string {
-  return `text-to-video_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-}
-
-export function useTextToVideoFeature(props: UseTextToVideoFeatureProps): UseTextToVideoFeatureReturn {
-  const { config, callbacks, userId, buildInput, extractResult } = props;
-  const [state, setState] = useState<TextToVideoFeatureState>(INITIAL_STATE);
-
-  // Strategy for orchestrator
-  const strategy: GenerationStrategy<VideoGenerationInput, TextToVideoResult> = useMemo(
-    () => ({
-      execute: async (input, onProgress) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[TextToVideo] Executing generation:", input.prompt.slice(0, 100));
-        }
-
-        // Notify generation start
-        callbacks.onGenerationStart?.({
-          creationId: input.creationId,
-          type: "text-to-video",
-          prompt: input.prompt,
-          metadata: input.options as Record<string, unknown> | undefined,
-        }).catch(() => {});
-
-        const result = await executeTextToVideo(
-          { prompt: input.prompt, userId, options: input.options },
-          {
-            model: config.model,
-            buildInput,
-            extractResult,
-            onProgress: (progress) => {
-              setState((prev) => ({ ...prev, progress }));
-              onProgress?.(progress);
-              callbacks.onProgress?.(progress);
-            },
-          },
-        );
-
-        if (!result.success || !result.videoUrl) {
-          throw new Error(result.error || "Generation failed");
-        }
-
-        // Update state with result
-        setState((prev) => ({
-          ...prev,
-          videoUrl: result.videoUrl ?? null,
-          thumbnailUrl: result.thumbnailUrl ?? null,
-        }));
-
-        return result;
-      },
-      getCreditCost: () => config.creditCost,
-      save: async (result, _uid) => {
-        if (result.success && result.videoUrl) {
-          await callbacks.onCreationSave?.({
-            creationId: generateCreationId(),
-            type: "text-to-video",
-            videoUrl: result.videoUrl,
-            thumbnailUrl: result.thumbnailUrl,
-            prompt: state.prompt,
-          });
-        }
-      },
-    }),
-    [config, callbacks, buildInput, extractResult, userId, state.prompt],
-  );
-
-  // Use orchestrator with optional callbacks for credits
-  const orchestrator = useGenerationOrchestrator(strategy, {
-    userId,
-    alertMessages: DEFAULT_ALERT_MESSAGES,
-    auth: callbacks.onAuthCheck
-      ? { isAuthenticated: callbacks.onAuthCheck, onAuthRequired: () => {} }
-      : undefined,
-    credits: callbacks.onCreditCheck
-      ? {
-          checkCredits: async (cost) => (await callbacks.onCreditCheck?.(cost)) ?? true,
-          deductCredits: async (cost) => { await callbacks.onCreditDeduct?.(cost); },
-          onCreditsExhausted: () => callbacks.onShowPaywall?.(config.creditCost),
-        }
-      : undefined,
-    moderation: callbacks.onModeration
-      ? {
-          checkContent: async (input) => {
-            const result = await callbacks.onModeration!((input as VideoGenerationInput).prompt);
-            return result;
-          },
-          onShowWarning: callbacks.onShowModerationWarning,
-        }
-      : undefined,
-    onSuccess: (result) => {
-      const videoResult = result as TextToVideoResult;
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[TextToVideo] Success!", videoResult.videoUrl?.slice(0, 50));
-      }
-      callbacks.onGenerate?.(videoResult);
-    },
-    onError: (err) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[TextToVideo] Error:", err.message);
-      }
-      setState((prev) => ({ ...prev, error: err.message }));
-      callbacks.onError?.(err.message);
-    },
-  });
-
-  const setPrompt = useCallback(
-    (prompt: string) => {
-      setState((prev) => ({ ...prev, prompt, error: null }));
-      callbacks.onPromptChange?.(prompt);
-    },
-    [callbacks],
-  );
-
-  const generate = useCallback(
-    async (params?: TextToVideoGenerateParams): Promise<TextToVideoResult> => {
-      const { prompt: paramPrompt, ...options } = params || {};
-      const effectivePrompt = paramPrompt?.trim() || state.prompt.trim();
-
-      if (!effectivePrompt) {
-        const error = "Prompt is required";
-        setState((prev) => ({ ...prev, error }));
-        callbacks.onError?.(error);
-        return { success: false, error };
-      }
-
-      if (paramPrompt) {
-        setState((prev) => ({ ...prev, prompt: effectivePrompt }));
-      }
-
-      setState((prev) => ({ ...prev, isProcessing: true, progress: 0, error: null }));
-
-      const creationId = generateCreationId();
-      await orchestrator.generate({ prompt: effectivePrompt, options, creationId });
-
-      setState((prev) => ({ ...prev, isProcessing: false }));
-
-      // Return result based on state
-      if (orchestrator.error) {
-        return { success: false, error: orchestrator.error.message };
-      }
-
-      return orchestrator.result || { success: false, error: "No result" };
-    },
-    [state.prompt, callbacks, orchestrator],
-  );
-
-  const reset = useCallback(() => {
-    setState(INITIAL_STATE);
-    orchestrator.reset();
-  }, [orchestrator]);
-
-  const isReady = useMemo(() => state.prompt.trim().length > 0 && !state.isProcessing, [state.prompt, state.isProcessing]);
-  const canGenerate = useMemo(() => isReady && !state.error, [isReady, state.error]);
-
-  return { state, setPrompt, generate, reset, isReady, canGenerate };
-}

package/src/features/text-to-video/presentation/hooks/useTextToVideoForm.ts

@@ -1,134 +0,0 @@
-/**
- * useTextToVideoForm Hook
- * Single Responsibility: Manage text-to-video form state
- */
-
-import { useState, useCallback } from "react";
-import type {
-  TextToVideoFormState,
-  FrameData,
-} from "../../domain/types";
-import { INITIAL_FORM_STATE } from "../../domain/types";
-
-declare const __DEV__: boolean;
-
-export interface UseTextToVideoFormProps {
-  initialValues?: Partial<TextToVideoFormState>;
-  onPromptChange?: (prompt: string) => void;
-  onStyleChange?: (style: string) => void;
-  onTabChange?: (tab: string) => void;
-}
-
-export interface UseTextToVideoFormReturn {
-  state: TextToVideoFormState;
-  frames: FrameData[];
-  setPrompt: (prompt: string) => void;
-  setStyle: (style: string) => void;
-  setAspectRatio: (ratio: string) => void;
-  setDuration: (duration: number) => void;
-  setActiveTab: (tab: string) => void;
-  setSoundEnabled: (enabled: boolean) => void;
-  setProfessionalMode: (enabled: boolean) => void;
-  setFrames: (frames: FrameData[]) => void;
-  handleFrameChange: (index: number) => void;
-  handleFrameDelete: (index: number) => void;
-  selectExamplePrompt: (prompt: string) => void;
-  reset: () => void;
-}
-
-export function useTextToVideoForm(
-  props: UseTextToVideoFormProps = {},
-): UseTextToVideoFormReturn {
-  const { initialValues, onPromptChange, onStyleChange, onTabChange } = props;
-
-  const [state, setState] = useState<TextToVideoFormState>({
-    ...INITIAL_FORM_STATE,
-    ...initialValues,
-  });
-
-  const [frames, setFrames] = useState<FrameData[]>([]);
-
-  const setPrompt = useCallback(
-    (prompt: string) => {
-      setState((prev) => ({ ...prev, prompt }));
-      onPromptChange?.(prompt);
-    },
-    [onPromptChange],
-  );
-
-  const setStyle = useCallback(
-    (style: string) => {
-      setState((prev) => ({ ...prev, style }));
-      onStyleChange?.(style);
-    },
-    [onStyleChange],
-  );
-
-  const setAspectRatio = useCallback((aspectRatio: string) => {
-    setState((prev) => ({ ...prev, aspectRatio }));
-  }, []);
-
-  const setDuration = useCallback((duration: number) => {
-    setState((prev) => ({ ...prev, duration }));
-  }, []);
-
-  const setActiveTab = useCallback(
-    (activeTab: string) => {
-      setState((prev) => ({ ...prev, activeTab }));
-      onTabChange?.(activeTab);
-    },
-    [onTabChange],
-  );
-
-  const setSoundEnabled = useCallback((soundEnabled: boolean) => {
-    setState((prev) => ({ ...prev, soundEnabled }));
-  }, []);
-
-  const setProfessionalMode = useCallback((professionalMode: boolean) => {
-    setState((prev) => ({ ...prev, professionalMode }));
-  }, []);
-
-  const handleFrameChange = useCallback((index: number) => {
-    if (__DEV__) {
-       
-      console.log("[TextToVideoForm] Frame change requested:", index);
-    }
-  }, []);
-
-  const handleFrameDelete = useCallback(
-    (index: number) => {
-      const newFrames = frames.filter((f) => f.order !== index);
-      setFrames(newFrames);
-    },
-    [frames],
-  );
-
-  const selectExamplePrompt = useCallback(
-    (prompt: string) => {
-      setPrompt(prompt);
-    },
-    [setPrompt],
-  );
-
-  const reset = useCallback(() => {
-    setState({ ...INITIAL_FORM_STATE, ...initialValues });
-    setFrames([]);
-  }, [initialValues]);
-
-  return {
-    state,
-    frames,
-    setPrompt,
-    setStyle,
-    setAspectRatio,
-    setDuration,
-    setActiveTab,
-    setSoundEnabled,
-    setProfessionalMode,
-    setFrames,
-    handleFrameChange,
-    handleFrameDelete,
-    selectExamplePrompt,
-    reset,
-  };
-}

package/src/features/text-to-video/presentation/index.ts

@@ -1,7 +0,0 @@
-/**
- * Text-to-Video Presentation Layer
- * Single Responsibility: Export all presentation components and hooks
- */
-
-export * from "./hooks";
-export * from "./components";