@umituz/react-native-ai-generation-content 1.37.4 → 1.37.6

package/package.json

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

package/src/domains/scenarios/configs/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Wizard Configs Public API
+ */
+
+export { WizardInputType } from "./wizard-input.types";
+export type { WizardConfigOptions, WizardConfigFactory } from "./wizard-input.types";
+
+export { detectWizardInputType, SCENARIO_TO_WIZARD_INPUT_MAP } from "./wizard-input-detector";
+
+export { CONFIG_FACTORIES, getConfigFactory } from "./wizard-step-factories";
+
+export {
+  getScenarioWizardConfig,
+  registerWizardConfig,
+  hasExplicitConfig,
+  getScenarioWizardInputType,
+} from "./wizard-config-resolver";

package/src/domains/scenarios/configs/wizard-config-resolver.ts

@@ -0,0 +1,107 @@
+/**
+ * Wizard Config Resolver
+ * Main resolver for getting wizard configurations
+ */
+
+import type { WizardFeatureConfig } from "../../generation/wizard/domain/entities/wizard-config.types";
+import { getConfiguredScenario } from "../infrastructure/scenario-registry";
+import { WizardInputType, type WizardConfigOptions } from "./wizard-input.types";
+import { detectWizardInputType, SCENARIO_TO_WIZARD_INPUT_MAP } from "./wizard-input-detector";
+import { getConfigFactory } from "./wizard-step-factories";
+
+declare const __DEV__: boolean;
+
+const scenarioWizardConfigs: Record<string, WizardFeatureConfig> = {};
+
+function mergeConfigOverrides(
+  config: WizardFeatureConfig,
+  overrides?: Partial<WizardFeatureConfig>,
+): WizardFeatureConfig {
+  if (!overrides) return config;
+  return {
+    ...config,
+    ...overrides,
+    steps: overrides.steps ?? config.steps,
+  };
+}
+
+function applyAdditionalSteps(
+  config: WizardFeatureConfig,
+  additionalSteps?: WizardFeatureConfig["steps"],
+): WizardFeatureConfig {
+  if (!additionalSteps) return config;
+  return { ...config, steps: [...config.steps, ...additionalSteps] };
+}
+
+function buildConfig(
+  scenarioId: string,
+  inputType: WizardInputType,
+  options?: WizardConfigOptions,
+): WizardFeatureConfig {
+  const factory = getConfigFactory(inputType);
+  let config = factory(scenarioId);
+  config = mergeConfigOverrides(config, options?.overrides);
+  return applyAdditionalSteps(config, options?.additionalSteps);
+}
+
+/**
+ * Get wizard config for a scenario
+ * Priority: 1. Explicit inputType  2. Registry config  3. Scenario inputType  4. Pattern detection
+ */
+export function getScenarioWizardConfig(
+  scenarioId: string,
+  options?: WizardConfigOptions,
+): WizardFeatureConfig {
+  if (options?.inputType) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[WizardConfig] Using explicit inputType", { scenarioId, inputType: options.inputType });
+    }
+    return buildConfig(scenarioId, options.inputType, options);
+  }
+
+  if (scenarioWizardConfigs[scenarioId]) {
+    let config = scenarioWizardConfigs[scenarioId];
+    config = mergeConfigOverrides(config, options?.overrides);
+    return applyAdditionalSteps(config, options?.additionalSteps);
+  }
+
+  const scenario = getConfiguredScenario(scenarioId);
+  if (scenario?.inputType) {
+    const wizardInputType = SCENARIO_TO_WIZARD_INPUT_MAP[scenario.inputType];
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[WizardConfig] Using scenario.inputType", {
+        scenarioId,
+        scenarioInputType: scenario.inputType,
+        wizardInputType,
+      });
+    }
+    return buildConfig(scenarioId, wizardInputType, options);
+  }
+
+  const inputType = detectWizardInputType(scenarioId);
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[WizardConfig] Auto-detected inputType", { scenarioId, inputType });
+  }
+  return buildConfig(scenarioId, inputType, options);
+}
+
+/**
+ * Register a custom wizard config
+ */
+export function registerWizardConfig(scenarioId: string, config: WizardFeatureConfig): void {
+  scenarioWizardConfigs[scenarioId] = config;
+}
+
+/**
+ * Check if scenario has explicit wizard config
+ */
+export function hasExplicitConfig(scenarioId: string): boolean {
+  return scenarioId in scenarioWizardConfigs;
+}
+
+/**
+ * Get input type for a scenario
+ */
+export function getScenarioWizardInputType(scenarioId: string): WizardInputType {
+  return detectWizardInputType(scenarioId);
+}

package/src/domains/scenarios/configs/wizard-input-detector.ts

@@ -0,0 +1,57 @@
+/**
+ * Wizard Input Detector
+ * Detects wizard input type from scenario ID patterns
+ */
+
+import type { ScenarioInputType } from "../domain/Scenario";
+import { WizardInputType } from "./wizard-input.types";
+
+/**
+ * Map ScenarioInputType to WizardInputType
+ */
+export const SCENARIO_TO_WIZARD_INPUT_MAP: Record<ScenarioInputType, WizardInputType> = {
+  single: WizardInputType.SINGLE_IMAGE,
+  dual: WizardInputType.DUAL_IMAGE,
+  text: WizardInputType.TEXT_INPUT,
+};
+
+/**
+ * Pattern-based input detection
+ * Only matches generic I/O patterns
+ */
+const INPUT_PATTERNS: Record<WizardInputType, readonly RegExp[]> = {
+  [WizardInputType.DUAL_IMAGE]: [/ai-kiss/i, /ai-hug/i, /couple/i, /dual/i],
+  [WizardInputType.SINGLE_IMAGE]: [
+    /^image-to-video$/i,
+    /upscale/i,
+    /restore/i,
+    /enhance/i,
+    /remove-background/i,
+    /background-remove/i,
+    /remove-object/i,
+    /hd-touch/i,
+    /anime-selfie/i,
+  ],
+  [WizardInputType.TEXT_INPUT]: [/^text-to-video$/i, /^text-to-image$/i, /prompt-to/i],
+  [WizardInputType.DUAL_IMAGE_FACE]: [/face-swap/i, /swap-face/i],
+};
+
+const DETECTION_ORDER: readonly WizardInputType[] = [
+  WizardInputType.TEXT_INPUT,
+  WizardInputType.DUAL_IMAGE,
+  WizardInputType.DUAL_IMAGE_FACE,
+  WizardInputType.SINGLE_IMAGE,
+];
+
+/**
+ * Detect input type from scenario ID using pattern matching
+ */
+export function detectWizardInputType(scenarioId: string): WizardInputType {
+  for (const type of DETECTION_ORDER) {
+    const patterns = INPUT_PATTERNS[type];
+    if (patterns.some((pattern) => pattern.test(scenarioId))) {
+      return type;
+    }
+  }
+  return WizardInputType.SINGLE_IMAGE;
+}

package/src/domains/scenarios/configs/wizard-input.types.ts

@@ -0,0 +1,31 @@
+/**
+ * Wizard Input Types
+ * Type definitions for wizard input classification
+ */
+
+import type { WizardFeatureConfig } from "../../generation/wizard/domain/entities/wizard-config.types";
+
+/**
+ * Input Type Classification
+ * Based on what inputs the wizard needs (photos, text)
+ */
+export enum WizardInputType {
+  DUAL_IMAGE = "dual_image",
+  SINGLE_IMAGE = "single_image",
+  TEXT_INPUT = "text_input",
+  DUAL_IMAGE_FACE = "dual_image_face",
+}
+
+/**
+ * Configuration Options for wizard config resolver
+ */
+export interface WizardConfigOptions {
+  readonly inputType?: WizardInputType;
+  readonly additionalSteps?: WizardFeatureConfig["steps"];
+  readonly overrides?: Partial<WizardFeatureConfig>;
+}
+
+/**
+ * Factory function type for creating wizard configs
+ */
+export type WizardConfigFactory = (scenarioId: string) => WizardFeatureConfig;

package/src/domains/scenarios/configs/wizard-step-factories.ts

@@ -0,0 +1,116 @@
+/**
+ * Wizard Step Factories
+ * Factory functions for creating wizard step configurations
+ */
+
+import type { WizardFeatureConfig } from "../../generation/wizard/domain/entities/wizard-config.types";
+import { WizardInputType, type WizardConfigFactory } from "./wizard-input.types";
+
+function createDualImageConfig(scenarioId: string): WizardFeatureConfig {
+  return {
+    id: scenarioId,
+    name: scenarioId,
+    steps: [
+      {
+        id: "photo_1",
+        type: "photo_upload",
+        titleKey: "photoUpload.first.title",
+        subtitleKey: "photoUpload.first.subtitle",
+        showFaceDetection: true,
+        showPhotoTips: true,
+        required: true,
+      },
+      {
+        id: "photo_2",
+        type: "photo_upload",
+        titleKey: "photoUpload.second.title",
+        subtitleKey: "photoUpload.second.subtitle",
+        showFaceDetection: true,
+        showPhotoTips: true,
+        required: true,
+      },
+    ],
+  };
+}
+
+function createSingleImageConfig(scenarioId: string): WizardFeatureConfig {
+  return {
+    id: scenarioId,
+    name: scenarioId,
+    steps: [
+      {
+        id: "photo_1",
+        type: "photo_upload",
+        titleKey: "photoUpload.single.title",
+        subtitleKey: "photoUpload.single.subtitle",
+        showFaceDetection: false,
+        showPhotoTips: true,
+        required: true,
+      },
+    ],
+  };
+}
+
+function createTextInputConfig(scenarioId: string): WizardFeatureConfig {
+  return {
+    id: scenarioId,
+    name: scenarioId,
+    steps: [
+      {
+        id: "text_input",
+        type: "text_input",
+        titleKey: "textInput.title",
+        subtitleKey: "textInput.subtitle",
+        placeholderKey: "textInput.placeholder",
+        minLength: 10,
+        maxLength: 500,
+        multiline: true,
+        required: true,
+      },
+    ],
+  };
+}
+
+function createDualImageFaceConfig(scenarioId: string): WizardFeatureConfig {
+  return {
+    id: scenarioId,
+    name: scenarioId,
+    steps: [
+      {
+        id: "photo_1",
+        type: "photo_upload",
+        titleKey: "photoUpload.source.title",
+        subtitleKey: "photoUpload.source.subtitle",
+        showFaceDetection: true,
+        showPhotoTips: true,
+        required: true,
+      },
+      {
+        id: "photo_2",
+        type: "photo_upload",
+        titleKey: "photoUpload.target.title",
+        subtitleKey: "photoUpload.target.subtitle",
+        showFaceDetection: false,
+        showPhotoTips: true,
+        required: true,
+      },
+    ],
+  };
+}
+
+/**
+ * Registry of config factories by input type
+ */
+export const CONFIG_FACTORIES: Record<WizardInputType, WizardConfigFactory> = {
+  [WizardInputType.DUAL_IMAGE]: createDualImageConfig,
+  [WizardInputType.SINGLE_IMAGE]: createSingleImageConfig,
+  [WizardInputType.TEXT_INPUT]: createTextInputConfig,
+  [WizardInputType.DUAL_IMAGE_FACE]: createDualImageFaceConfig,
+};
+
+/**
+ * Get factory for a specific input type
+ */
+export function getConfigFactory(inputType: WizardInputType): WizardConfigFactory {
+  return CONFIG_FACTORIES[inputType];
+}

package/src/domains/scenarios/index.ts

@@ -37,19 +37,14 @@ export { createStoryTemplate } from "./infrastructure/utils/scenario-utils";
 // Wizard Configurations - App-agnostic, classifies by INPUT REQUIREMENTS
 export {
   WizardInputType,
-  SCENARIO_WIZARD_CONFIGS,
   detectWizardInputType,
   getScenarioWizardConfig,
   hasExplicitConfig,
   getScenarioWizardInputType,
   registerWizardConfig,
-  // Deprecated (backward compatibility)
-  FeatureType,
-  detectFeatureType,
-  getScenarioFeatureType,
-} from "./configs/wizard-configs";
+} from "./configs";
 
-export type { WizardConfigOptions } from "./configs/wizard-configs";
+export type { WizardConfigOptions } from "./configs";
 
 // Presentation - Containers
 export { CategoryNavigationContainer } from "./presentation/containers";

package/src/domains/scenarios/configs/wizard-configs.ts

@@ -1,331 +0,0 @@
-/**
- * Wizard Configurations - App-Agnostic
- * Classifies features by INPUT REQUIREMENTS, not app-specific scenarios
- * Apps can override inputType or provide custom step configurations
- */
-
-import type { WizardFeatureConfig } from "../../generation/wizard/domain/entities/wizard-config.types";
-
-declare const __DEV__: boolean;
-
-/**
- * Input Type Classification
- * Based on what inputs the wizard needs (photos, text)
- * NOT based on app-specific scenario names
- */
-export enum WizardInputType {
-  /** Two images required (any two-person/two-image scenario) */
-  DUAL_IMAGE = "dual_image",
-  /** Single image required */
-  SINGLE_IMAGE = "single_image",
-  /** Text input only, no images */
-  TEXT_INPUT = "text_input",
-  /** Two images with face detection (face swap scenarios) */
-  DUAL_IMAGE_FACE = "dual_image_face",
-}
-
-/** @deprecated Use WizardInputType instead */
-export const FeatureType = WizardInputType;
-
-/**
- * Generic Input Detection Patterns
- * Only patterns that describe input/output, NOT app-specific scenarios
- */
-const INPUT_PATTERNS: Record<WizardInputType, RegExp[]> = {
-  [WizardInputType.DUAL_IMAGE]: [
-    /ai-kiss/i,
-    /ai-hug/i,
-    /couple/i,
-    /dual/i,
-  ],
-
-  [WizardInputType.SINGLE_IMAGE]: [
-    /^image-to-video$/i,
-    /upscale/i,
-    /restore/i,
-    /enhance/i,
-    /remove-background/i,
-    /background-remove/i,
-    /remove-object/i,
-    /hd-touch/i,
-    /anime-selfie/i,
-  ],
-
-  [WizardInputType.TEXT_INPUT]: [
-    /^text-to-video$/i,
-    /^text-to-image$/i,
-    /prompt-to/i,
-  ],
-
-  [WizardInputType.DUAL_IMAGE_FACE]: [
-    /face-swap/i,
-    /swap-face/i,
-  ],
-};
-
-/**
- * Detect input type from scenario ID
- * Only matches generic I/O patterns
- * Returns SINGLE_IMAGE as safe default
- */
-export const detectWizardInputType = (scenarioId: string): WizardInputType => {
-  // Check patterns in priority order: TEXT_INPUT, DUAL_IMAGE, DUAL_IMAGE_FACE, SINGLE_IMAGE
-  const checkOrder: WizardInputType[] = [
-    WizardInputType.TEXT_INPUT,
-    WizardInputType.DUAL_IMAGE,
-    WizardInputType.DUAL_IMAGE_FACE,
-    WizardInputType.SINGLE_IMAGE,
-  ];
-
-  for (const type of checkOrder) {
-    const patterns = INPUT_PATTERNS[type];
-    if (patterns.some((pattern) => pattern.test(scenarioId))) {
-      return type;
-    }
-  }
-
-  // Safe default: SINGLE_IMAGE (most common use case)
-  return WizardInputType.SINGLE_IMAGE;
-};
-
-/**
- * Config Factory: DUAL_IMAGE (2 photos required)
- * Generic labels - apps provide translations
- */
-const createDualImageConfig = (scenarioId: string): WizardFeatureConfig => ({
-  id: scenarioId,
-  name: scenarioId,
-  steps: [
-    {
-      id: "photo_1",
-      type: "photo_upload",
-      titleKey: "photoUpload.first.title",
-      subtitleKey: "photoUpload.first.subtitle",
-      showFaceDetection: true,
-      showPhotoTips: true,
-      required: true,
-    },
-    {
-      id: "photo_2",
-      type: "photo_upload",
-      titleKey: "photoUpload.second.title",
-      subtitleKey: "photoUpload.second.subtitle",
-      showFaceDetection: true,
-      showPhotoTips: true,
-      required: true,
-    },
-  ],
-});
-
-/**
- * Config Factory: SINGLE_IMAGE (1 photo required)
- */
-const createSingleImageConfig = (scenarioId: string): WizardFeatureConfig => ({
-  id: scenarioId,
-  name: scenarioId,
-  steps: [
-    {
-      id: "photo_1",
-      type: "photo_upload",
-      titleKey: "photoUpload.single.title",
-      subtitleKey: "photoUpload.single.subtitle",
-      showFaceDetection: false,
-      showPhotoTips: true,
-      required: true,
-    },
-  ],
-});
-
-/**
- * Config Factory: TEXT_INPUT (text only, no photos)
- */
-const createTextInputConfig = (scenarioId: string): WizardFeatureConfig => ({
-  id: scenarioId,
-  name: scenarioId,
-  steps: [
-    {
-      id: "text_input",
-      type: "text_input",
-      titleKey: "textInput.title",
-      subtitleKey: "textInput.subtitle",
-      placeholderKey: "textInput.placeholder",
-      minLength: 10,
-      maxLength: 500,
-      multiline: true,
-      required: true,
-    },
-  ],
-});
-
-/**
- * Config Factory: DUAL_IMAGE_FACE (2 photos with face detection)
- */
-const createDualImageFaceConfig = (scenarioId: string): WizardFeatureConfig => ({
-  id: scenarioId,
-  name: scenarioId,
-  steps: [
-    {
-      id: "photo_1",
-      type: "photo_upload",
-      titleKey: "photoUpload.source.title",
-      subtitleKey: "photoUpload.source.subtitle",
-      showFaceDetection: true,
-      showPhotoTips: true,
-      required: true,
-    },
-    {
-      id: "photo_2",
-      type: "photo_upload",
-      titleKey: "photoUpload.target.title",
-      subtitleKey: "photoUpload.target.subtitle",
-      showFaceDetection: false,
-      showPhotoTips: true,
-      required: true,
-    },
-  ],
-});
-
-/**
- * Config Factories Registry
- */
-const CONFIG_FACTORIES: Record<WizardInputType, (id: string) => WizardFeatureConfig> = {
-  [WizardInputType.DUAL_IMAGE]: createDualImageConfig,
-  [WizardInputType.SINGLE_IMAGE]: createSingleImageConfig,
-  [WizardInputType.TEXT_INPUT]: createTextInputConfig,
-  [WizardInputType.DUAL_IMAGE_FACE]: createDualImageFaceConfig,
-};
-
-/**
- * Explicit Wizard Configs (Optional)
- * Apps can register custom configs for specific scenario IDs
- */
-export const SCENARIO_WIZARD_CONFIGS: Record<string, WizardFeatureConfig> = {};
-
-/**
- * Merge config with overrides
- */
-const mergeConfigOverrides = (
-  config: WizardFeatureConfig,
-  overrides?: Partial<WizardFeatureConfig>,
-): WizardFeatureConfig => {
-  if (!overrides) return config;
-  return {
-    ...config,
-    ...overrides,
-    steps: overrides.steps || config.steps,
-  };
-};
-
-/**
- * Configuration Options
- */
-export interface WizardConfigOptions {
-  /** Explicit input type - highest priority */
-  readonly inputType?: WizardInputType;
-  /** Additional steps to append */
-  readonly additionalSteps?: WizardFeatureConfig["steps"];
-  /** Custom overrides */
-  readonly overrides?: Partial<WizardFeatureConfig>;
-}
-
-/**
- * Get wizard config for a scenario
- *
- * Priority:
- * 1. Explicit inputType in options (highest)
- * 2. Explicit config in SCENARIO_WIZARD_CONFIGS
- * 3. Auto-detect from scenario ID patterns
- *
- * @example
- * // Auto-detect from ID
- * getScenarioWizardConfig("text-to-video")
- *
- * // Explicit input type for app-specific scenarios
- * getScenarioWizardConfig("ai-kiss", { inputType: WizardInputType.DUAL_IMAGE })
- */
-export const getScenarioWizardConfig = (
-  scenarioId: string,
-  options?: WizardConfigOptions,
-): WizardFeatureConfig => {
-  // 1. Explicit inputType (highest priority)
-  if (options?.inputType) {
-    const factory = CONFIG_FACTORIES[options.inputType];
-    let config = factory(scenarioId);
-    config = mergeConfigOverrides(config, options.overrides);
-
-    if (options.additionalSteps) {
-      config = { ...config, steps: [...config.steps, ...options.additionalSteps] };
-    }
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[WizardConfig] Using explicit inputType", {
-        scenarioId,
-        inputType: options.inputType,
-      });
-    }
-
-    return config;
-  }
-
-  // 2. Explicit config in registry
-  if (SCENARIO_WIZARD_CONFIGS[scenarioId]) {
-    let config = SCENARIO_WIZARD_CONFIGS[scenarioId];
-    config = mergeConfigOverrides(config, options?.overrides);
-
-    if (options?.additionalSteps) {
-      config = { ...config, steps: [...config.steps, ...options.additionalSteps] };
-    }
-
-    return config;
-  }
-
-  // 3. Auto-detect from scenario ID
-  const inputType = detectWizardInputType(scenarioId);
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[WizardConfig] Auto-detected inputType", {
-      scenarioId,
-      inputType,
-    });
-  }
-
-  const factory = CONFIG_FACTORIES[inputType];
-  let config = factory(scenarioId);
-  config = mergeConfigOverrides(config, options?.overrides);
-
-  if (options?.additionalSteps) {
-    config = { ...config, steps: [...config.steps, ...options.additionalSteps] };
-  }
-
-  return config;
-};
-
-/**
- * Register a custom wizard config for a scenario
- */
-export const registerWizardConfig = (
-  scenarioId: string,
-  config: WizardFeatureConfig,
-): void => {
-  SCENARIO_WIZARD_CONFIGS[scenarioId] = config;
-};
-
-/**
- * Check if scenario has explicit wizard config
- */
-export const hasExplicitConfig = (scenarioId: string): boolean => {
-  return scenarioId in SCENARIO_WIZARD_CONFIGS;
-};
-
-/**
- * Get input type for a scenario
- */
-export const getScenarioWizardInputType = (scenarioId: string): WizardInputType => {
-  return detectWizardInputType(scenarioId);
-};
-
-/** @deprecated Use getScenarioWizardInputType instead */
-export const getScenarioFeatureType = getScenarioWizardInputType;
-
-/** @deprecated Use detectWizardInputType instead */
-export const detectFeatureType = detectWizardInputType;