@umituz/react-native-ai-generation-content 1.65.1 → 1.65.2

package/src/domains/creations/presentation-exports.ts

@@ -0,0 +1,59 @@
+/**
+ * Creations Presentation Layer Exports
+ */
+
+// Hooks
+export { useCreations } from "./presentation/hooks/useCreations";
+export { useDeleteCreation } from "./presentation/hooks/useDeleteCreation";
+export { useCreationsFilter } from "./presentation/hooks/useCreationsFilter";
+export { useAdvancedFilter } from "./presentation/hooks/useAdvancedFilter";
+export { useCreationPersistence } from "./presentation/hooks/useCreationPersistence";
+export type {
+  UseCreationPersistenceConfig,
+  UseCreationPersistenceReturn,
+  BaseProcessingStartData,
+  BaseProcessingResult,
+} from "./presentation/hooks/useCreationPersistence";
+export { useProcessingJobsPoller } from "./presentation/hooks/useProcessingJobsPoller";
+export type {
+  UseProcessingJobsPollerConfig,
+  UseProcessingJobsPollerReturn,
+} from "./presentation/hooks/useProcessingJobsPoller";
+
+// Core Components
+export { CreationPreview } from "./presentation/components/CreationPreview";
+export { CreationBadges } from "./presentation/components/CreationBadges";
+export {
+  CreationActions,
+  type CreationAction,
+} from "./presentation/components/CreationActions";
+export {
+  CreationCard,
+  type CreationCardData,
+  type CreationCardCallbacks,
+} from "./presentation/components/CreationCard";
+export { CreationThumbnail } from "./presentation/components/CreationThumbnail";
+
+// Filter Components
+export { FilterChips } from "./presentation/components/FilterChips";
+export {
+  CreationsFilterBar,
+  createMediaFilterButtons,
+  createStatusFilterButtons,
+  type FilterButton,
+} from "./presentation/components/CreationsFilterBar";
+
+// Gallery Components
+export { CreationsHomeCard } from "./presentation/components/CreationsHomeCard";
+export { EmptyState } from "./presentation/components/EmptyState";
+export { PendingJobsSection, type PendingJobsSectionProps } from "./presentation/components/PendingJobsSection";
+
+// Utilities
+export {
+  getLocalizedTitle,
+  getFilterCategoriesFromConfig,
+  getTranslatedTypes,
+} from "./presentation/utils/gallery-filters";
+
+// Screens
+export { CreationsGalleryScreen } from "./presentation/screens/CreationsGalleryScreen";

package/src/domains/generation/infrastructure/executors/text-to-image-executor.helpers.ts

@@ -0,0 +1,81 @@
+/**
+ * Text-to-Image Executor Helpers
+ */
+
+import type { TextToImageInput, TextToImageOutput } from "./text-to-image-executor.types";
+
+export function buildModelInput(input: TextToImageInput): Record<string, unknown> {
+  const {
+    prompt,
+    negativePrompt,
+    aspectRatio,
+    size,
+    numImages,
+    guidanceScale,
+    style,
+    outputFormat,
+  } = input;
+
+  let finalPrompt = prompt;
+  if (style && style !== "none") {
+    finalPrompt = `${prompt}, ${style} style`;
+  }
+
+  return {
+    prompt: finalPrompt,
+    ...(negativePrompt && { negative_prompt: negativePrompt }),
+    ...(aspectRatio && { aspect_ratio: aspectRatio }),
+    ...(size && { image_size: size }),
+    ...(numImages && { num_images: numImages }),
+    ...(guidanceScale && { guidance_scale: guidanceScale }),
+    ...(outputFormat && { output_format: outputFormat }),
+  };
+}
+
+export function extractImagesFromObject(obj: Record<string, unknown>): string[] {
+  if (!Array.isArray(obj.images)) {
+    return [];
+  }
+
+  return obj.images
+    .map((img) => {
+      if (typeof img === "string") return img;
+      if (img && typeof img === "object" && "url" in img) {
+        return (img as { url: string }).url;
+      }
+      return null;
+    })
+    .filter((url): url is string => url !== null);
+}
+
+export function extractResult(result: unknown): TextToImageOutput | undefined {
+  if (typeof result !== "object" || result === null) {
+    return undefined;
+  }
+
+  const r = result as Record<string, unknown>;
+
+  if (r.data && typeof r.data === "object") {
+    const urls = extractImagesFromObject(r.data as Record<string, unknown>);
+    if (urls.length > 0) {
+      return { imageUrl: urls[0], imageUrls: urls };
+    }
+  }
+
+  const directUrls = extractImagesFromObject(r);
+  if (directUrls.length > 0) {
+    return { imageUrl: directUrls[0], imageUrls: directUrls };
+  }
+
+  if (typeof r.imageUrl === "string") {
+    return { imageUrl: r.imageUrl, imageUrls: [r.imageUrl] };
+  }
+
+  if (typeof r.imageBase64 === "string") {
+    const mimeType = typeof r.mimeType === "string" ? r.mimeType : "image/png";
+    const dataUrl = `data:${mimeType};base64,${r.imageBase64}`;
+    return { imageUrl: dataUrl, imageUrls: [dataUrl] };
+  }
+
+  return undefined;
+}

package/src/domains/generation/infrastructure/executors/text-to-image-executor.ts

@@ -9,25 +9,11 @@ import type {
 } from "../../domain/generation.types";
 import type { GenerationResult } from "../../../../domain/entities/generation.types";
 import { providerRegistry } from "../../../../infrastructure/services/provider-registry.service";
+import type { TextToImageInput, TextToImageOutput } from "./text-to-image-executor.types";
+import { buildModelInput, extractResult } from "./text-to-image-executor.helpers";
 
 declare const __DEV__: boolean;
 
-export interface TextToImageInput {
-  prompt: string;
-  negativePrompt?: string;
-  aspectRatio?: string;
-  size?: string;
-  numImages?: number;
-  guidanceScale?: number;
-  style?: string;
-  outputFormat?: "jpeg" | "png" | "webp";
-}
-
-export interface TextToImageOutput {
-  imageUrl: string;
-  imageUrls: string[];
-}
-
 export class TextToImageExecutor
   implements GenerationExecutor<TextToImageInput, TextToImageOutput>
 {
@@ -58,13 +44,13 @@ export class TextToImageExecutor
 
       options?.onProgress?.(10);
 
-      const modelInput = this.buildModelInput(input);
+      const modelInput = buildModelInput(input);
       options?.onProgress?.(20);
 
       const result = await provider.run(model, modelInput);
       options?.onProgress?.(90);
 
-      const extracted = this.extractResult(result);
+      const extracted = extractResult(result);
       options?.onProgress?.(100);
 
       if (!extracted?.imageUrl) {
@@ -88,86 +74,4 @@ export class TextToImageExecutor
       return { success: false, error: message };
     }
   }
-
-  private buildModelInput(input: TextToImageInput): Record<string, unknown> {
-    const {
-      prompt,
-      negativePrompt,
-      aspectRatio,
-      size,
-      numImages,
-      guidanceScale,
-      style,
-      outputFormat,
-    } = input;
-
-    let finalPrompt = prompt;
-    if (style && style !== "none") {
-      finalPrompt = `${prompt}, ${style} style`;
-    }
-
-    return {
-      prompt: finalPrompt,
-      ...(negativePrompt && { negative_prompt: negativePrompt }),
-      ...(aspectRatio && { aspect_ratio: aspectRatio }),
-      ...(size && { image_size: size }),
-      ...(numImages && { num_images: numImages }),
-      ...(guidanceScale && { guidance_scale: guidanceScale }),
-      ...(outputFormat && { output_format: outputFormat }),
-    };
-  }
-
-  private extractResult(
-    result: unknown,
-  ): { imageUrl: string; imageUrls: string[] } | undefined {
-    if (typeof result !== "object" || result === null) {
-      return undefined;
-    }
-
-    const r = result as Record<string, unknown>;
-
-    // Check nested 'data' object
-    if (r.data && typeof r.data === "object") {
-      const urls = this.extractImagesFromObject(r.data as Record<string, unknown>);
-      if (urls.length > 0) {
-        return { imageUrl: urls[0], imageUrls: urls };
-      }
-    }
-
-    // Check direct images array
-    const directUrls = this.extractImagesFromObject(r);
-    if (directUrls.length > 0) {
-      return { imageUrl: directUrls[0], imageUrls: directUrls };
-    }
-
-    // Check for imageUrl
-    if (typeof r.imageUrl === "string") {
-      return { imageUrl: r.imageUrl, imageUrls: [r.imageUrl] };
-    }
-
-    // Fallback: base64
-    if (typeof r.imageBase64 === "string") {
-      const mimeType = typeof r.mimeType === "string" ? r.mimeType : "image/png";
-      const dataUrl = `data:${mimeType};base64,${r.imageBase64}`;
-      return { imageUrl: dataUrl, imageUrls: [dataUrl] };
-    }
-
-    return undefined;
-  }
-
-  private extractImagesFromObject(obj: Record<string, unknown>): string[] {
-    if (!Array.isArray(obj.images)) {
-      return [];
-    }
-
-    return obj.images
-      .map((img) => {
-        if (typeof img === "string") return img;
-        if (img && typeof img === "object" && "url" in img) {
-          return (img as { url: string }).url;
-        }
-        return null;
-      })
-      .filter((url): url is string => url !== null);
-  }
 }

package/src/domains/generation/infrastructure/executors/text-to-image-executor.types.ts

@@ -0,0 +1,19 @@
+/**
+ * Text-to-Image Executor Types
+ */
+
+export interface TextToImageInput {
+  prompt: string;
+  negativePrompt?: string;
+  aspectRatio?: string;
+  size?: string;
+  numImages?: number;
+  guidanceScale?: number;
+  style?: string;
+  outputFormat?: "jpeg" | "png" | "webp";
+}
+
+export interface TextToImageOutput {
+  imageUrl: string;
+  imageUrls: string[];
+}

package/src/domains/generation/infrastructure/flow/use-flow-store.types.ts

@@ -0,0 +1,19 @@
+/**
+ * Flow Store Types
+ */
+
+import type {
+  FlowState,
+  FlowActions,
+  StepDefinition,
+} from "../../../../domain/entities/flow-config.types";
+
+export interface FlowStoreState extends FlowState {
+  stepDefinitions: readonly StepDefinition[];
+}
+
+export interface FlowStoreConfig {
+  steps: readonly StepDefinition[];
+  initialStepId?: string;
+  initialStepIndex?: number;
+}

package/src/domains/generation/infrastructure/flow/useFlowStore.ts

@@ -1,6 +1,5 @@
 /**
- * useFlowStore
- * Zustand store for multi-step flow state management
+ * Flow Store - Zustand store for multi-step flow state management
  */
 
 import { createStore } from "@umituz/react-native-design-system";
@@ -8,12 +7,8 @@ import type {
   FlowState,
   FlowActions,
   FlowUploadedImageData,
-  StepDefinition,
 } from "../../../../domain/entities/flow-config.types";
-
-interface FlowStoreState extends FlowState {
-  stepDefinitions: readonly StepDefinition[];
-}
+import type { FlowStoreState, FlowStoreConfig } from "./use-flow-store.types";
 
 const createInitialState = (): FlowState => ({
   currentStepId: "",
@@ -33,14 +28,7 @@ const createInitialState = (): FlowState => ({
   generationError: undefined,
 });
 
-interface FlowStoreConfig {
-  steps: readonly StepDefinition[];
-  initialStepId?: string;
-  initialStepIndex?: number;
-}
-
 export const createFlowStore = (config: FlowStoreConfig) => {
-  // Support both initialStepId and initialStepIndex
   let initialIndex = 0;
 
   if (config.initialStepIndex !== undefined) {
@@ -74,76 +62,58 @@ export const createFlowStore = (config: FlowStoreConfig) => {
       nextStep: () => {
         const { stepDefinitions, currentStepIndex, completedSteps, currentStepId } = get();
         const nextIndex = currentStepIndex + 1;
-        if (nextIndex < stepDefinitions.length) {
-          const nextStep = stepDefinitions[nextIndex];
-          const newCompleted = completedSteps.includes(currentStepId)
+        if (nextIndex >= stepDefinitions.length) return;
+        set({
+          currentStepId: stepDefinitions[nextIndex].id,
+          currentStepIndex: nextIndex,
+          completedSteps: completedSteps.includes(currentStepId)
             ? completedSteps
-            : [...completedSteps, currentStepId];
-
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[FlowStore] nextStep", {
-              fromIndex: currentStepIndex,
-              toIndex: nextIndex,
-              fromStep: currentStepId,
-              toStep: nextStep.id,
-              toStepType: nextStep.type,
-            });
-          }
-
-          set({ currentStepId: nextStep.id, currentStepIndex: nextIndex, completedSteps: newCompleted });
-        }
+            : [...completedSteps, currentStepId],
+        });
       },
 
       previousStep: () => {
         const { stepDefinitions, currentStepIndex } = get();
         if (currentStepIndex > 0) {
-          const prevStep = stepDefinitions[currentStepIndex - 1];
-          set({ currentStepId: prevStep.id, currentStepIndex: currentStepIndex - 1 });
+          set({
+            currentStepId: stepDefinitions[currentStepIndex - 1].id,
+            currentStepIndex: currentStepIndex - 1,
+          });
         }
       },
 
       setCategory: (category: unknown) => set({ selectedCategory: category }),
       setScenario: (scenario: unknown) => set({ selectedScenario: scenario }),
 
-      setPartnerImage: (partnerId: string, image: FlowUploadedImageData | undefined) => {
-        const { partners } = get();
-        set({ partners: { ...partners, [partnerId]: image } });
-      },
+      setPartnerImage: (partnerId: string, image: FlowUploadedImageData | undefined) =>
+        set({ partners: { ...get().partners, [partnerId]: image } }),
 
-      setPartnerName: (partnerId: string, name: string) => {
-        const { partnerNames } = get();
-        set({ partnerNames: { ...partnerNames, [partnerId]: name } });
-      },
+      setPartnerName: (partnerId: string, name: string) =>
+        set({ partnerNames: { ...get().partnerNames, [partnerId]: name } }),
 
       setTextInput: (text: string) => set({ textInput: text }),
       setVisualStyle: (styleId: string) => set({ visualStyle: styleId }),
 
-      setSelectedFeatures: (featureType: string, ids: readonly string[]) => {
-        const { selectedFeatures } = get();
-        set({ selectedFeatures: { ...selectedFeatures, [featureType]: ids } });
-      },
+      setSelectedFeatures: (featureType: string, ids: readonly string[]) =>
+        set({ selectedFeatures: { ...get().selectedFeatures, [featureType]: ids } }),
 
-      setCustomData: (key: string, value: unknown) => {
-        const { customData } = get();
-        set({ customData: { ...customData, [key]: value } });
-      },
+      setCustomData: (key: string, value: unknown) =>
+        set({ customData: { ...get().customData, [key]: value } }),
 
-      startGeneration: () => {
-        set({ generationStatus: "preparing", generationProgress: 0, generationError: undefined });
-      },
+      startGeneration: () =>
+        set({ generationStatus: "preparing", generationProgress: 0, generationError: undefined }),
 
-      updateProgress: (progress: number) => {
-        const generationStatus = progress >= 100 ? "completed" : progress > 0 ? "generating" : "preparing";
-        set({ generationProgress: progress, generationStatus });
-      },
+      updateProgress: (progress: number) =>
+        set({
+          generationProgress: progress,
+          generationStatus: progress >= 100 ? "completed" : progress > 0 ? "generating" : "preparing",
+        }),
 
-      setResult: (result: unknown) => {
-        set({ generationResult: result, generationStatus: "completed", generationProgress: 100 });
-      },
+      setResult: (result: unknown) =>
+        set({ generationResult: result, generationStatus: "completed", generationProgress: 100 }),
 
-      setError: (error: string) => {
-        set({ generationError: error, generationStatus: "failed", generationProgress: 0 });
-      },
+      setError: (error: string) =>
+        set({ generationError: error, generationStatus: "failed", generationProgress: 0 }),
 
       reset: () => {
         const { stepDefinitions } = get();
@@ -153,9 +123,7 @@ export const createFlowStore = (config: FlowStoreConfig) => {
 
       completeStep: (stepId: string) => {
         const { completedSteps } = get();
-        if (!completedSteps.includes(stepId)) {
-          set({ completedSteps: [...completedSteps, stepId] });
-        }
+        if (!completedSteps.includes(stepId)) set({ completedSteps: [...completedSteps, stepId] });
       },
     }),
   });

package/src/domains/generation/wizard/domain/entities/wizard-config-builder.ts

@@ -0,0 +1,75 @@
+/**
+ * Wizard Config Builder
+ * Domain Service: Builds wizard configuration from scenario
+ */
+
+import type { WizardStepConfig } from "./wizard-step.types";
+import type { WizardFeatureConfig, ScenarioBasedConfig } from "./wizard-feature-config.types";
+
+/**
+ * Build wizard config from scenario shorthand
+ */
+export function buildWizardConfigFromScenario(
+  scenarioId: string,
+  config: ScenarioBasedConfig
+): WizardFeatureConfig {
+  const steps: WizardStepConfig[] = [];
+
+  if (config.photoCount && config.photoCount > 0) {
+    const maxPhotos = Math.min(config.photoCount, 2);
+    for (let i = 0; i < maxPhotos; i++) {
+      steps.push({
+        id: `photo_${i + 1}`,
+        type: "photo_upload",
+        label: config.photoLabels?.[i] || `Photo ${i + 1}`,
+        showFaceDetection: true,
+        showPhotoTips: true,
+        required: true,
+      });
+    }
+  }
+
+  if (config.requireText) {
+    steps.push({
+      id: "text_input",
+      type: "text_input",
+      required: true,
+      minLength: 10,
+      maxLength: 500,
+    });
+  }
+
+  if (config.requireStyleSelection) {
+    steps.push({
+      id: "style_selection",
+      type: "selection",
+      selectionType: "style",
+      options: [],
+      required: true,
+    });
+  }
+
+  if (config.requireDurationSelection) {
+    steps.push({
+      id: "duration_selection",
+      type: "selection",
+      selectionType: "duration",
+      options: [
+        { id: "5s", label: "5 seconds", value: 5 },
+        { id: "10s", label: "10 seconds", value: 10 },
+        { id: "15s", label: "15 seconds", value: 15 },
+      ],
+      required: true,
+    });
+  }
+
+  if (config.customSteps) {
+    steps.push(...config.customSteps);
+  }
+
+  return {
+    id: scenarioId,
+    name: scenarioId,
+    steps,
+  };
+}

package/src/domains/generation/wizard/domain/entities/wizard-feature-config.types.ts

@@ -0,0 +1,29 @@
+/**
+ * Wizard Feature Configuration Types
+ */
+
+import type { WizardStepConfig } from "./wizard-step.types";
+
+/**
+ * Feature Flow Configuration
+ */
+export interface WizardFeatureConfig {
+  readonly id: string;
+  readonly name: string;
+  readonly steps: readonly WizardStepConfig[];
+  readonly translations?: {
+    readonly [key: string]: string | Record<string, string>;
+  };
+}
+
+/**
+ * Scenario-based Configuration Builder
+ */
+export interface ScenarioBasedConfig {
+  readonly photoCount?: number;
+  readonly photoLabels?: readonly string[];
+  readonly requireText?: boolean;
+  readonly requireStyleSelection?: boolean;
+  readonly requireDurationSelection?: boolean;
+  readonly customSteps?: readonly WizardStepConfig[];
+}

package/src/domains/generation/wizard/domain/entities/wizard-feature.types.ts

@@ -1,118 +1,13 @@
 /**
- * Wizard Feature Configuration Types
+ * Wizard Feature Configuration Types - Barrel Export
  * Feature-level configs and builder utilities
+ *
+ * Architecture:
+ * - Domain: Feature config types, scenario config types
+ * - Domain Service: Config builder function
+ * - Domain Knowledge: Preset configurations
  */
 
-import type { WizardStepConfig } from "./wizard-step.types";
-
-/**
- * Feature Flow Configuration
- */
-export interface WizardFeatureConfig {
-  readonly id: string;
-  readonly name: string;
-  readonly steps: readonly WizardStepConfig[];
-  readonly translations?: {
-    readonly [key: string]: string | Record<string, string>;
-  };
-}
-
-/**
- * Scenario-based Configuration Builder
- */
-export interface ScenarioBasedConfig {
-  readonly photoCount?: number;
-  readonly photoLabels?: readonly string[];
-  readonly requireText?: boolean;
-  readonly requireStyleSelection?: boolean;
-  readonly requireDurationSelection?: boolean;
-  readonly customSteps?: readonly WizardStepConfig[];
-}
-
-/**
- * Build wizard config from scenario shorthand
- */
-export const buildWizardConfigFromScenario = (
-  scenarioId: string,
-  config: ScenarioBasedConfig,
-): WizardFeatureConfig => {
-  const steps: WizardStepConfig[] = [];
-
-  if (config.photoCount && config.photoCount > 0) {
-    const maxPhotos = Math.min(config.photoCount, 2);
-    for (let i = 0; i < maxPhotos; i++) {
-      steps.push({
-        id: `photo_${i + 1}`,
-        type: "photo_upload",
-        label: config.photoLabels?.[i] || `Photo ${i + 1}`,
-        showFaceDetection: true,
-        showPhotoTips: true,
-        required: true,
-      });
-    }
-  }
-
-  if (config.requireText) {
-    steps.push({
-      id: "text_input",
-      type: "text_input",
-      required: true,
-      minLength: 10,
-      maxLength: 500,
-    });
-  }
-
-  if (config.requireStyleSelection) {
-    steps.push({
-      id: "style_selection",
-      type: "selection",
-      selectionType: "style",
-      options: [],
-      required: true,
-    });
-  }
-
-  if (config.requireDurationSelection) {
-    steps.push({
-      id: "duration_selection",
-      type: "selection",
-      selectionType: "duration",
-      options: [
-        { id: "5s", label: "5 seconds", value: 5 },
-        { id: "10s", label: "10 seconds", value: 10 },
-        { id: "15s", label: "15 seconds", value: 15 },
-      ],
-      required: true,
-    });
-  }
-
-  if (config.customSteps) {
-    steps.push(...config.customSteps);
-  }
-
-  return {
-    id: scenarioId,
-    name: scenarioId,
-    steps,
-  };
-};
-
-/**
- * Pre-configured scenarios for common use cases
- */
-export const WIZARD_PRESETS = {
-  TWO_PHOTOS: {
-    photoCount: 2,
-  },
-  SINGLE_PHOTO: {
-    photoCount: 1,
-    requireStyleSelection: true,
-    requireDurationSelection: true,
-  },
-  TEXT_ONLY: {
-    photoCount: 0,
-    requireText: true,
-    requireStyleSelection: true,
-    requireDurationSelection: true,
-  },
-} as const;
+export type { WizardFeatureConfig, ScenarioBasedConfig } from "./wizard-feature-config.types";
+export { buildWizardConfigFromScenario } from "./wizard-config-builder";
+export { WIZARD_PRESETS } from "./wizard-presets.constants";