@umituz/react-native-ai-generation-content 1.34.1 → 1.35.0

package/package.json

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

package/src/domains/generation/wizard/presentation/components/GenericWizardFlow.tsx

@@ -1,6 +1,7 @@
 /**
  * Generic Wizard Flow Component
  * Config-driven wizard for AI generation features
+ * Supports both scenario object and scenarioId (resolved from provider)
  */
 
 import React, { useMemo, useCallback, useEffect, useRef, useState } from "react";
@@ -19,12 +20,16 @@ import { useResultActions } from "../../../../result-preview/presentation/hooks/
 import { validateScenario } from "../utilities/validateScenario";
 import { WizardStepRenderer } from "./WizardStepRenderer";
 import { StarRatingPicker } from "../../../../result-preview/presentation/components/StarRatingPicker";
+import { useGenerationConfig } from "../../../../../infrastructure/providers";
 
 declare const __DEV__: boolean;
 
 export interface GenericWizardFlowProps {
   readonly featureConfig: WizardFeatureConfig;
+  /** Full scenario object - use this OR scenarioId */
   readonly scenario?: WizardScenarioData;
+  /** Scenario ID - resolved from GenerationConfigProvider's scenarios */
+  readonly scenarioId?: string;
   readonly userId?: string;
   readonly alertMessages?: AlertMessages;
   readonly skipResultStep?: boolean;
@@ -44,7 +49,8 @@ export interface GenericWizardFlowProps {
 
 export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
   featureConfig,
-  scenario,
+  scenario: scenarioProp,
+  scenarioId,
   userId,
   alertMessages,
   skipResultStep = false,
@@ -63,12 +69,51 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
 }) => {
   const tokens = useAppDesignTokens();
   const alert = useAlert();
+  const { getScenarioById, defaultOutputType } = useGenerationConfig();
   const [currentCreation, setCurrentCreation] = useState<Creation | null>(null);
   const [showRatingPicker, setShowRatingPicker] = useState(false);
   const [hasRated, setHasRated] = useState(false);
-  const [isGeneratingDismissed, setIsGeneratingDismissed] = useState(false);
+  const [, setIsGeneratingDismissed] = useState(false);
   const prevStepIdRef = useRef<string | undefined>(undefined);
 
+  // Resolve scenario: use prop directly OR lookup by scenarioId from provider
+  const scenario = useMemo<WizardScenarioData | undefined>(() => {
+    // If scenario prop is provided, use it directly
+    if (scenarioProp) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[GenericWizardFlow] Using scenario from prop:", {
+          id: scenarioProp.id,
+          outputType: scenarioProp.outputType,
+        });
+      }
+      return scenarioProp;
+    }
+
+    // If scenarioId is provided, lookup from provider
+    if (scenarioId) {
+      const found = getScenarioById(scenarioId);
+      if (found) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[GenericWizardFlow] Resolved scenario from provider:", {
+            id: found.id,
+            outputType: found.outputType,
+          });
+        }
+        return found as unknown as WizardScenarioData;
+      }
+      // Scenario not found in provider - create minimal with default outputType
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn("[GenericWizardFlow] Scenario not found in provider:", scenarioId);
+      }
+      return {
+        id: scenarioId,
+        outputType: defaultOutputType,
+      };
+    }
+
+    return undefined;
+  }, [scenarioProp, scenarioId, getScenarioById, defaultOutputType]);
+
   const repository = useMemo(() => createCreationsRepository("creations"), []);
 
   const flowSteps = useMemo<StepDefinition[]>(() => {

package/src/domains/generation/wizard/presentation/components/WizardStepRenderer.tsx

@@ -167,7 +167,8 @@ export const WizardStepRenderer: React.FC<WizardStepRendererProps> = ({
           onBack={onBack}
           onContinue={(text) => {
             // Store text in a structure compatible with existing handlers
-            onPhotoContinue(step.id, { uri: text, text, previewUrl: "" } as any);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            onPhotoContinue(step.id, { uri: text, text, previewUrl: "" } as unknown as any);
           }}
         />
       );
@@ -204,7 +205,8 @@ export const WizardStepRenderer: React.FC<WizardStepRendererProps> = ({
           onBack={onBack}
           onContinue={(value) => {
             // Store selection value
-            onPhotoContinue(step.id, { uri: String(value), selection: value, previewUrl: "" } as any);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            onPhotoContinue(step.id, { uri: String(value), selection: value, previewUrl: "" } as unknown as any);
           }}
         />
       );

package/src/domains/scenarios/domain/Scenario.ts

@@ -573,7 +573,8 @@ export interface Scenario {
   storyTemplate: string;
   requiresPhoto?: boolean;
   hidden?: boolean;
-  outputType: ScenarioOutputType;
+  /** Output type - optional, apps should configure via createScenariosForApp() */
+  outputType?: ScenarioOutputType;
   model?: string; // AI model from app config
   enabled?: boolean;
   // Optional custom generating screen messages

package/src/domains/scenarios/index.ts

@@ -11,6 +11,16 @@ export type { Scenario } from "./domain/Scenario";
 // Scenario Data
 export { SCENARIOS } from "./infrastructure/ScenariosData";
 
+// Scenario Helpers - For app-level configuration
+export {
+  createScenariosForApp,
+  filterScenariosByOutputType,
+  filterScenariosByCategory,
+  getScenarioCategories,
+  findScenarioById,
+} from "./infrastructure/scenario-helpers";
+export type { AppScenarioConfig } from "./infrastructure/scenario-helpers";
+
 // Utils
 export { createStoryTemplate } from "./infrastructure/utils/scenario-utils";
 

package/src/domains/scenarios/infrastructure/ScenariosData.ts

@@ -4,7 +4,7 @@
  * Generic for all AI generation apps (image/video)
  */
 
-import { Scenario, ScenarioCategory, ScenarioOutputType } from "../domain/Scenario";
+import { Scenario, ScenarioCategory } from "../domain/Scenario";
 import { TIME_BASED_SCENARIOS } from "./data/time-based-scenarios";
 import { FAMILY_SCENARIOS } from "./data/family-scenarios";
 import { LIFESTYLE_SCENARIOS } from "./data/lifestyle-scenarios";
@@ -78,11 +78,15 @@ import { UNDERWATER_SCENARIOS } from "./data/underwater-scenarios";
 import { ARABIAN_NIGHTS_SCENARIOS } from "./data/arabian-nights-scenarios";
 import { PREHISTORIC_WORLD_SCENARIOS } from "./data/prehistoric-world-scenarios";
 
-const assignCategory = (scenarios: Omit<Scenario, 'outputType'>[], category: ScenarioCategory) =>
-  scenarios.map((s) => ({ ...s, category, outputType: "image" as ScenarioOutputType }));
+/**
+ * Assigns category to scenarios
+ * Note: outputType is NOT assigned here - apps configure via createScenariosForApp()
+ */
+const assignCategory = (scenarios: Omit<Scenario, 'category'>[], category: ScenarioCategory) =>
+  scenarios.map((s) => ({ ...s, category }));
 
 export const SCENARIOS: Scenario[] = [
-  { ...CUSTOM_SCENARIO, category: ScenarioCategory.FANTASY, outputType: "image" },
+  { ...CUSTOM_SCENARIO, category: ScenarioCategory.FANTASY },
 
   // Time & Future
   ...assignCategory(TIME_BASED_SCENARIOS, ScenarioCategory.TIME_TRAVEL),

package/src/domains/scenarios/infrastructure/scenario-helpers.ts

@@ -0,0 +1,122 @@
+/**
+ * Scenario Helpers
+ * Utilities for configuring scenarios in apps
+ */
+
+import type { Scenario, ScenarioOutputType } from "../domain/Scenario";
+
+/**
+ * Configuration for creating app-specific scenarios
+ */
+export interface AppScenarioConfig {
+  /** Output type for all scenarios (image or video) */
+  readonly outputType: ScenarioOutputType;
+  /** Optional AI model to assign to all scenarios */
+  readonly model?: string;
+  /** Optional filter to exclude certain scenarios by ID */
+  readonly excludeIds?: readonly string[];
+  /** Optional filter to include only certain category IDs */
+  readonly includeCategories?: readonly string[];
+}
+
+/**
+ * Creates app-configured scenarios from package scenarios
+ * Apps use this to set their desired outputType and model
+ *
+ * @example
+ * // Video generation app
+ * const scenarios = createScenariosForApp(SCENARIOS, {
+ *   outputType: "video",
+ *   model: "fal-ai/veo3/image-to-video"
+ * });
+ *
+ * @example
+ * // Image generation app
+ * const scenarios = createScenariosForApp(SCENARIOS, {
+ *   outputType: "image",
+ *   model: "fal-ai/nano-banana/edit",
+ *   excludeIds: ["custom"]
+ * });
+ */
+export const createScenariosForApp = (
+  scenarios: readonly Scenario[],
+  config: AppScenarioConfig,
+): Scenario[] => {
+  const { outputType, model, excludeIds, includeCategories } = config;
+
+  return scenarios
+    .filter((scenario) => {
+      // Filter by excluded IDs
+      if (excludeIds?.includes(scenario.id)) {
+        return false;
+      }
+      // Filter by included categories
+      if (
+        includeCategories &&
+        includeCategories.length > 0 &&
+        scenario.category &&
+        !includeCategories.includes(scenario.category)
+      ) {
+        return false;
+      }
+      return true;
+    })
+    .map((scenario) => ({
+      ...scenario,
+      outputType,
+      ...(model && { model }),
+    }));
+};
+
+/**
+ * Filters scenarios by output type (if they have one set)
+ * Useful for apps that have mixed scenarios with different output types
+ *
+ * @example
+ * const videoScenarios = filterScenariosByOutputType(scenarios, "video");
+ */
+export const filterScenariosByOutputType = (
+  scenarios: readonly Scenario[],
+  outputType: ScenarioOutputType,
+): Scenario[] => scenarios.filter((s) => s.outputType === outputType);
+
+/**
+ * Filters scenarios by category
+ *
+ * @example
+ * const weddingScenarios = filterScenariosByCategory(scenarios, "wedding");
+ */
+export const filterScenariosByCategory = (
+  scenarios: readonly Scenario[],
+  category: string,
+): Scenario[] => scenarios.filter((s) => s.category === category);
+
+/**
+ * Gets unique categories from scenarios
+ *
+ * @example
+ * const categories = getScenarioCategories(scenarios);
+ * // ["wedding", "fantasy", "adventure", ...]
+ */
+export const getScenarioCategories = (
+  scenarios: readonly Scenario[],
+): string[] => {
+  const categories = new Set<string>();
+  scenarios.forEach((s) => {
+    if (s.category) {
+      categories.add(s.category);
+    }
+  });
+  return Array.from(categories);
+};
+
+/**
+ * Finds a scenario by ID
+ *
+ * @example
+ * const scenario = findScenarioById(scenarios, "beach_wedding");
+ */
+export const findScenarioById = (
+  scenarios: readonly Scenario[],
+  id: string,
+): Scenario | undefined => scenarios.find((s) => s.id === id);

package/src/index.ts

@@ -143,6 +143,7 @@ export {
   type GenerationModels,
   type GenerationConfigValue,
   type GenerationConfigProviderProps,
+  type ConfiguredScenario,
 } from "./infrastructure/providers";
 
 export * from "./domains/result-preview";

package/src/infrastructure/providers/generation-config.provider.tsx

@@ -1,10 +1,11 @@
 /**
  * Generation Config Provider
  * Provides app-specific configuration to the package
- * NO hard-coded models, everything comes from app!
+ * NO hard-coded models/scenarios, everything comes from app!
  */
 
-import React, { createContext, useContext, type ReactNode } from "react";
+import React, { createContext, useContext, useMemo, type ReactNode } from "react";
+import type { Scenario, ScenarioOutputType } from "../../domains/scenarios/domain/Scenario";
 
 declare const __DEV__: boolean;
 
@@ -35,11 +36,23 @@ export interface GenerationModels {
   readonly textToVoice?: string;
 }
 
+/** Configured scenario from app */
+export interface ConfiguredScenario extends Scenario {
+  /** Output type - REQUIRED when configured by app */
+  readonly outputType: ScenarioOutputType;
+}
+
 export interface GenerationConfigValue {
   /** AI models configuration from app */
   readonly models: GenerationModels;
+  /** Configured scenarios from app (with outputType set) */
+  readonly scenarios: readonly ConfiguredScenario[];
+  /** Default output type for this app */
+  readonly defaultOutputType: ScenarioOutputType;
   /** Get model for specific feature type */
   readonly getModel: (featureType: keyof GenerationModels) => string;
+  /** Get scenario by ID from configured scenarios */
+  readonly getScenarioById: (id: string) => ConfiguredScenario | undefined;
 }
 
 // ============================================================================
@@ -54,24 +67,29 @@ const GenerationConfigContext = createContext<GenerationConfigValue | null>(null
 
 export interface GenerationConfigProviderProps {
   readonly children: ReactNode;
+  /** AI models configuration */
   readonly models: GenerationModels;
+  /** App-configured scenarios (optional - for scenario-based generation) */
+  readonly scenarios?: readonly ConfiguredScenario[];
+  /** Default output type for this app (default: "video") */
+  readonly defaultOutputType?: ScenarioOutputType;
 }
 
 export const GenerationConfigProvider: React.FC<GenerationConfigProviderProps> = ({
   children,
   models,
+  scenarios = [],
+  defaultOutputType = "video",
 }) => {
   if (typeof __DEV__ !== "undefined" && __DEV__) {
     const configuredModels = Object.entries(models)
       .filter(([, value]) => !!value)
       .map(([key]) => key);
 
-    console.log("[GenerationConfigProvider] Initialized with models:", {
-      configured: configuredModels,
-      imageCoupleMultiRef: models.imageCoupleMultiRef || "not configured",
-      imageTextToImage: models.imageTextToImage || "not configured",
-      imageToVideo: models.imageToVideo || "not configured",
-      textToVideo: models.textToVideo || "not configured",
+    console.log("[GenerationConfigProvider] Initialized:", {
+      models: configuredModels,
+      scenariosCount: scenarios.length,
+      defaultOutputType,
     });
   }
 
@@ -91,9 +109,32 @@ export const GenerationConfigProvider: React.FC<GenerationConfigProviderProps> =
     return model;
   };
 
+  const scenarioMap = useMemo(() => {
+    const map = new Map<string, ConfiguredScenario>();
+    for (const scenario of scenarios) {
+      map.set(scenario.id, scenario);
+    }
+    return map;
+  }, [scenarios]);
+
+  const getScenarioById = (id: string): ConfiguredScenario | undefined => {
+    const found = scenarioMap.get(id);
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[GenerationConfigProvider] getScenarioById:", {
+        id,
+        found: !!found,
+        outputType: found?.outputType,
+      });
+    }
+    return found;
+  };
+
   const value: GenerationConfigValue = {
     models,
+    scenarios,
+    defaultOutputType,
     getModel,
+    getScenarioById,
   };
 
   return (

package/src/infrastructure/providers/index.ts

@@ -9,4 +9,5 @@ export {
   type GenerationModels,
   type GenerationConfigValue,
   type GenerationConfigProviderProps,
+  type ConfiguredScenario,
 } from "./generation-config.provider";