@umituz/react-native-mascot 1.0.2 → 1.0.4

package/src/domain/value-objects/PlayfulnessLevel.ts

@@ -0,0 +1,66 @@
+/**
+ * PlayfulnessLevel Value Object
+ * Encapsulates playfulness validation and business rules
+ */
+
+export class PlayfulnessLevel {
+  private readonly MIN = 0;
+  private readonly MAX = 1;
+  private readonly PLAYFUL_THRESHOLD = 0.5;
+  private readonly VERY_PLAYFUL_THRESHOLD = 0.8;
+
+  private constructor(public readonly value: number) {
+    if (value < this.MIN || value > this.MAX) {
+      throw new Error(`Playfulness level must be between ${this.MIN} and ${this.MAX}, got: ${value}`);
+    }
+  }
+
+  static create(value: number): PlayfulnessLevel {
+    return new PlayfulnessLevel(value);
+  }
+
+  /**
+   * Check if mascot is playful
+   */
+  isPlayful(): boolean {
+    return this.value >= this.PLAYFUL_THRESHOLD;
+  }
+
+  /**
+   * Check if mascot is very playful
+   */
+  isVeryPlayful(): boolean {
+    return this.value >= this.VERY_PLAYFUL_THRESHOLD;
+  }
+
+  /**
+   * Check if mascot is serious
+   */
+  isSerious(): boolean {
+    return this.value < 0.3;
+  }
+
+  /**
+   * Increase playfulness
+   */
+  increase(amount: number): PlayfulnessLevel {
+    const newValue = Math.min(this.MAX, this.value + amount);
+    return PlayfulnessLevel.create(newValue);
+  }
+
+  /**
+   * Decrease playfulness
+   */
+  decrease(amount: number): PlayfulnessLevel {
+    const newValue = Math.max(this.MIN, this.value - amount);
+    return PlayfulnessLevel.create(newValue);
+  }
+
+  equals(other: PlayfulnessLevel): boolean {
+    return this.value === other.value;
+  }
+
+  toJSON(): number {
+    return this.value;
+  }
+}

package/src/domain/value-objects/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Value Objects
+ * Encapsulate domain logic and validation
+ */
+
+export { Mood } from './Mood';
+export { EnergyLevel } from './EnergyLevel';
+export { FriendlinessLevel } from './FriendlinessLevel';
+export { PlayfulnessLevel } from './PlayfulnessLevel';

package/src/index.ts

@@ -1,7 +1,7 @@
 /**
  * @umituz/react-native-mascot
  *
- * Interactive mascot system for React Native apps
+ * Interactive mascot system for React Native apps with DDD architecture
  */
 
 import type { MascotMood, AnimationSpeed } from './domain/types/MascotTypes';
@@ -9,6 +9,9 @@ import type { MascotMood, AnimationSpeed } from './domain/types/MascotTypes';
 // Domain - Entities
 export { Mascot } from './domain/entities/Mascot';
 
+// Domain - Value Objects
+export { Mood, EnergyLevel, FriendlinessLevel, PlayfulnessLevel } from './domain/value-objects';
+
 // Domain - Types
 export type {
   MascotType,
@@ -41,6 +44,35 @@ export type {
   IMascotRepository,
 } from './domain/interfaces/IMascotRepository';
 
+// Application - Services
+export { MascotService } from './application/services/MascotService';
+export type { MascotTemplate } from './application/services/MascotService';
+
+// Application - Errors
+export {
+  MascotError,
+  MascotNotInitializedError,
+  AnimationNotFoundError,
+  InvalidEnergyLevelError,
+  InvalidFriendlinessLevelError,
+  InvalidPlayfulnessLevelError,
+  InvalidMoodTransitionError,
+  MascotNotFoundError,
+  TemplateNotFoundError,
+} from './application/errors/MascotErrors';
+
+// Application - DTOs
+export type {
+  MascotDTO,
+  AnimationStateDTO,
+  MascotInitOptionsDTO,
+  AnimationPlaybackOptionsDTO,
+  MascotUpdateOptionsDTO,
+} from './application/dto/MascotDTO';
+
+// Infrastructure - DI
+export { DIContainer } from './infrastructure/di/Container';
+
 // Infrastructure - Repositories
 export { MascotRepository } from './infrastructure/repositories/MascotRepository';
 
@@ -49,7 +81,7 @@ export { AnimationController } from './infrastructure/controllers/AnimationContr
 
 // Infrastructure - Managers
 export { AssetManager } from './infrastructure/managers/AssetManager';
-export { MascotFactory, type MascotTemplate } from './infrastructure/managers/MascotFactory';
+export { MascotFactory, type MascotTemplate as FactoryMascotTemplate } from './infrastructure/managers/MascotFactory';
 
 // Presentation - Components
 export { MascotView } from './presentation/components/MascotView';
@@ -97,3 +129,9 @@ export const DEFAULT_ANIMATION_SPEEDS: AnimationSpeed[] = [
   'fast',
   'very-fast',
 ];
+
+// Convenience export - get service instance
+export const getMascotService = () => {
+  const { DIContainer } = require('./infrastructure/di/Container');
+  return DIContainer.getInstance().getMascotService();
+};

package/src/infrastructure/di/Container.ts

@@ -0,0 +1,90 @@
+/**
+ * Dependency Injection Container
+ * Manages singleton instances and dependencies
+ */
+
+import type { IMascotRepository } from '../../domain/interfaces/IMascotRepository';
+import type { MascotService } from '../../application/services/MascotService';
+import { AnimationController } from '../controllers/AnimationController';
+import { AssetManager } from '../managers/AssetManager';
+import { MascotRepository } from '../repositories/MascotRepository';
+
+export class DIContainer {
+  private static _instance: DIContainer;
+  private _animationController: AnimationController | null = null;
+  private _assetManager: AssetManager | null = null;
+  private _repository: IMascotRepository | null = null;
+  private _mascotService: MascotService | null = null;
+
+  private constructor() {}
+
+  static getInstance(): DIContainer {
+    if (!this._instance) {
+      this._instance = new DIContainer();
+    }
+    return this._instance;
+  }
+
+  /**
+   * Get or create AnimationController singleton
+   */
+  getAnimationController(): AnimationController {
+    if (!this._animationController) {
+      this._animationController = new AnimationController();
+    }
+    return this._animationController;
+  }
+
+  /**
+   * Get or create AssetManager singleton
+   */
+  getAssetManager(): AssetManager {
+    if (!this._assetManager) {
+      this._assetManager = new AssetManager();
+    }
+    return this._assetManager;
+  }
+
+  /**
+   * Get or create MascotRepository singleton
+   */
+  getRepository(): IMascotRepository {
+    if (!this._repository) {
+      this._repository = new MascotRepository();
+    }
+    return this._repository;
+  }
+
+  /**
+   * Get or create MascotService singleton
+   */
+  getMascotService(): MascotService {
+    if (!this._mascotService) {
+      // Lazy import to avoid circular dependencies
+      const { MascotService } = require('../../application/services/MascotService');
+      this._mascotService = new MascotService(
+        this.getRepository(),
+        this.getAnimationController(),
+        this.getAssetManager()
+      );
+    }
+    return this._mascotService;
+  }
+
+  /**
+   * Reset all instances (useful for testing)
+   */
+  reset(): void {
+    this._animationController = null;
+    this._assetManager = null;
+    this._repository = null;
+    this._mascotService = null;
+  }
+
+  /**
+   * Check if container has been initialized
+   */
+  isInitialized(): boolean {
+    return this._mascotService !== null;
+  }
+}

package/src/presentation/contexts/MascotContext.tsx

@@ -1,135 +1,53 @@
 /**
- * Mascot Context
- * Provides mascot state and functionality to components
+ * MascotContext
+ * Thin wrapper that provides MascotService to components
  */
 
-import React, { createContext, useContext, useState, useCallback, useRef } from 'react';
-import { Mascot } from '../../domain/entities/Mascot';
+import React, { createContext, useContext, ReactNode } from 'react';
+import type { Mascot } from '../../domain/entities/Mascot';
 import type { MascotConfig, MascotMood } from '../../domain/types/MascotTypes';
-import { MascotFactory } from '../../infrastructure/managers/MascotFactory';
-import { AnimationController } from '../../infrastructure/controllers/AnimationController';
 import type { AnimationOptions } from '../../domain/interfaces/IAnimationController';
+import type { MascotService, MascotTemplate } from '../../application/services/MascotService';
+import { DIContainer } from '../../infrastructure/di/Container';
 
 export interface MascotContextValue {
   mascot: Mascot | null;
   isPlaying: boolean;
   currentAnimation: string | null;
-  initializeMascot: (config: MascotConfig) => void;
-  initializeFromTemplate: (template: string, customizations?: Partial<MascotConfig>) => void;
-  setMood: (mood: MascotMood) => void;
-  playAnimation: (animationId: string, options?: AnimationOptions) => Promise<void>;
-  stopAnimation: () => void;
-  updateAppearance: (appearance: Partial<MascotConfig['appearance']>) => void;
-  setVisible: (visible: boolean) => void;
+  service: MascotService;
 }
 
 const MascotContext = createContext<MascotContextValue | undefined>(undefined);
 
-export interface MascotProviderProps extends React.PropsWithChildren {
+export interface MascotProviderProps {
+  children: ReactNode;
   initialConfig?: MascotConfig;
-  template?: string;
+  template?: MascotTemplate;
 }
 
 export const MascotProvider: React.FC<MascotProviderProps> = ({
   children,
-  initialConfig: _initialConfig,
-  template: _template,
+  initialConfig,
+  template,
 }) => {
-  const [mascot, setMascot] = useState<Mascot | null>(null);
-  const [isPlaying, setIsPlaying] = useState(false);
-  const [currentAnimation, setCurrentAnimation] = useState<string | null>(null);
-  const animationControllerRef = useRef<AnimationController | null>(null);
-
-  const initializeMascot = useCallback((config: MascotConfig) => {
-    const newMascot = new Mascot(config);
-    setMascot(newMascot);
-    if (!animationControllerRef.current) {
-      animationControllerRef.current = new AnimationController();
-    }
-  }, []);
-
-  const initializeFromTemplate = useCallback((
-    templateName: string,
-    customizations?: Partial<MascotConfig>
-  ) => {
-    const template = templateName as 'friendly-bot' | 'cute-pet' | 'wise-owl' | 'pixel-hero';
-    const newMascot = MascotFactory.createFromTemplate(template, customizations);
-    setMascot(newMascot);
-    if (!animationControllerRef.current) {
-      animationControllerRef.current = new AnimationController();
-    }
-  }, []);
-
-  const setMood = useCallback((mood: MascotMood) => {
-    setMascot((prev) => {
-      if (!prev) return null;
-      prev.setMood(mood);
-      return prev.clone();
-    });
-  }, []);
-
-  const playAnimation = useCallback(async (animationId: string, options?: AnimationOptions) => {
-    if (!mascot || !animationControllerRef.current) return;
-
-    const animation = mascot.getAnimation(animationId);
-    if (!animation) {
-      console.warn(`Animation ${animationId} not found`);
-      return;
-    }
-
-    setIsPlaying(true);
-    setCurrentAnimation(animationId);
-
-    if (animationControllerRef.current) {
-      await animationControllerRef.current.play(animation, options);
-    }
-
-    setIsPlaying(false);
-    setCurrentAnimation(null);
-  }, [mascot]);
-
-  const stopAnimation = useCallback(() => {
-    if (animationControllerRef.current) {
-      animationControllerRef.current.stop();
-    }
-    setIsPlaying(false);
-    setCurrentAnimation(null);
-  }, []);
-
-  const updateAppearance = useCallback((appearance: Partial<MascotConfig['appearance']>) => {
-    setMascot((prev) => {
-      if (!prev) return null;
-      prev.updateAppearance(appearance);
-      return prev.clone();
-    });
-  }, []);
-
-  const setVisible = useCallback((visible: boolean) => {
-    setMascot((prev) => {
-      if (!prev) return null;
-      prev.setVisible(visible);
-      return prev.clone();
-    });
-  }, []);
+  const container = DIContainer.getInstance();
+  const service = container.getMascotService();
+
+  // Auto-initialize if config or template provided
+  if (initialConfig) {
+    service.initialize(initialConfig);
+  } else if (template) {
+    service.fromTemplate(template);
+  }
 
   const value: MascotContextValue = {
-    mascot,
-    isPlaying,
-    currentAnimation,
-    initializeMascot,
-    initializeFromTemplate,
-    setMood,
-    playAnimation,
-    stopAnimation,
-    updateAppearance,
-    setVisible,
+    mascot: service.mascot,
+    isPlaying: service.isPlaying,
+    currentAnimation: service.currentAnimation,
+    service,
   };
 
-  return (
-    <MascotContext.Provider value={value}>
-      {children}
-    </MascotContext.Provider>
-  );
+  return <MascotContext.Provider value={value}>{children}</MascotContext.Provider>;
 };
 
 export const useMascotContext = (): MascotContextValue => {