@umituz/react-native-ai-generation-content 1.34.0 → 1.34.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.34.0",
+  "version": "1.34.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/generation/wizard/presentation/components/GenericWizardFlow.tsx

@@ -66,7 +66,7 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
   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);
 
   const repository = useMemo(() => createCreationsRepository("creations"), []);

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);