@umituz/react-native-mascot 1.0.3 → 1.0.7

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

@@ -0,0 +1,80 @@
+/**
+ * EnergyLevel Value Object
+ * Encapsulates energy level validation and business rules
+ */
+
+export class EnergyLevel {
+  private readonly MIN = 0;
+  private readonly MAX = 1;
+  private readonly HIGH_THRESHOLD = 0.7;
+  private readonly LOW_THRESHOLD = 0.3;
+
+  private constructor(public readonly value: number) {
+    if (value < this.MIN || value > this.MAX) {
+      throw new Error(`Energy level must be between ${this.MIN} and ${this.MAX}, got: ${value}`);
+    }
+  }
+
+  static create(value: number): EnergyLevel {
+    return new EnergyLevel(value);
+  }
+
+  /**
+   * Check if energy is high
+   */
+  isHigh(): boolean {
+    return this.value > this.HIGH_THRESHOLD;
+  }
+
+  /**
+   * Check if energy is low
+   */
+  isLow(): boolean {
+    return this.value < this.LOW_THRESHOLD;
+  }
+
+  /**
+   * Check if energy is moderate
+   */
+  isModerate(): boolean {
+    return !this.isHigh() && !this.isLow();
+  }
+
+  /**
+   * Increase energy by amount (clamped to MAX)
+   */
+  increase(amount: number): EnergyLevel {
+    const newValue = Math.min(this.MAX, this.value + amount);
+    return EnergyLevel.create(newValue);
+  }
+
+  /**
+   * Decrease energy by amount (clamped to MIN)
+   */
+  decrease(amount: number): EnergyLevel {
+    const newValue = Math.max(this.MIN, this.value - amount);
+    return EnergyLevel.create(newValue);
+  }
+
+  /**
+   * Set energy to specific level
+   */
+  setLevel(value: number): EnergyLevel {
+    return EnergyLevel.create(value);
+  }
+
+  /**
+   * Get energy as percentage (0-100)
+   */
+  toPercentage(): number {
+    return Math.round(this.value * 100);
+  }
+
+  equals(other: EnergyLevel): boolean {
+    return this.value === other.value;
+  }
+
+  toJSON(): number {
+    return this.value;
+  }
+}

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

@@ -0,0 +1,66 @@
+/**
+ * FriendlinessLevel Value Object
+ * Encapsulates friendliness validation and business rules
+ */
+
+export class FriendlinessLevel {
+  private readonly MIN = 0;
+  private readonly MAX = 1;
+  private readonly FRIENDLY_THRESHOLD = 0.6;
+  private readonly VERY_FRIENDLY_THRESHOLD = 0.8;
+
+  private constructor(public readonly value: number) {
+    if (value < this.MIN || value > this.MAX) {
+      throw new Error(`Friendliness level must be between ${this.MIN} and ${this.MAX}, got: ${value}`);
+    }
+  }
+
+  static create(value: number): FriendlinessLevel {
+    return new FriendlinessLevel(value);
+  }
+
+  /**
+   * Check if mascot is friendly
+   */
+  isFriendly(): boolean {
+    return this.value >= this.FRIENDLY_THRESHOLD;
+  }
+
+  /**
+   * Check if mascot is very friendly
+   */
+  isVeryFriendly(): boolean {
+    return this.value >= this.VERY_FRIENDLY_THRESHOLD;
+  }
+
+  /**
+   * Check if mascot is shy
+   */
+  isShy(): boolean {
+    return this.value < 0.4;
+  }
+
+  /**
+   * Increase friendliness
+   */
+  increase(amount: number): FriendlinessLevel {
+    const newValue = Math.min(this.MAX, this.value + amount);
+    return FriendlinessLevel.create(newValue);
+  }
+
+  /**
+   * Decrease friendliness
+   */
+  decrease(amount: number): FriendlinessLevel {
+    const newValue = Math.max(this.MIN, this.value - amount);
+    return FriendlinessLevel.create(newValue);
+  }
+
+  equals(other: FriendlinessLevel): boolean {
+    return this.value === other.value;
+  }
+
+  toJSON(): number {
+    return this.value;
+  }
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Mood Value Object
+ * Encapsulates mood logic and validation
+ */
+
+import type { MascotMood } from '../types/MascotTypes';
+
+export class Mood {
+  private constructor(public readonly value: MascotMood) {}
+
+  static create(value: MascotMood): Mood {
+    return new Mood(value);
+  }
+
+  /**
+   * Check if mood is positive
+   */
+  isPositive(): boolean {
+    return ['happy', 'excited', 'surprised'].includes(this.value);
+  }
+
+  /**
+   * Check if mood is negative
+   */
+  isNegative(): boolean {
+    return ['sad', 'angry'].includes(this.value);
+  }
+
+  /**
+   * Check if mood is neutral
+   */
+  isNeutral(): boolean {
+    return ['neutral', 'thinking'].includes(this.value);
+  }
+
+  /**
+   * Get opposite mood
+   */
+  getOpposite(): Mood {
+    const opposites: Record<MascotMood, MascotMood> = {
+      happy: 'sad',
+      sad: 'happy',
+      excited: 'angry',
+      angry: 'excited',
+      thinking: 'neutral',
+      neutral: 'thinking',
+      surprised: 'neutral',
+    };
+    return Mood.create(opposites[this.value]);
+  }
+
+  equals(other: Mood): boolean {
+    return this.value === other.value;
+  }
+
+  toJSON(): MascotMood {
+    return this.value;
+  }
+}

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/index.ts

@@ -1,78 +1,19 @@
 /**
  * @umituz/react-native-mascot
  *
- * Interactive mascot system for React Native apps
+ * Interactive mascot system for React Native apps with DDD architecture
+ * Version: 1.0.6
  */
 
-import type { MascotMood, AnimationSpeed } from './domain/types/MascotTypes';
-
-// Domain - Entities
-export { Mascot } from './domain/entities/Mascot';
-
-// Domain - Types
-export type {
-  MascotType,
-  MascotStyle,
-  MascotAnimationType,
-  MascotAppearance,
-  MascotAccessory,
-  MascotPersonality,
-  MascotAnimation,
-  MascotConfig,
-  MascotState,
-  MascotInteraction,
-  MascotMood,
-  AnimationSpeed,
-} from './domain/types/MascotTypes';
-
-// Domain - Interfaces
-export type {
-  IAnimationController,
-  AnimationEvent,
-  AnimationOptions,
-} from './domain/interfaces/IAnimationController';
-
-export type {
-  IAssetManager,
-  AssetCache,
-} from './domain/interfaces/IAssetManager';
-
-export type {
-  IMascotRepository,
-} from './domain/interfaces/IMascotRepository';
-
-// Infrastructure - Repositories
-export { MascotRepository } from './infrastructure/repositories/MascotRepository';
-
-// Infrastructure - Controllers
-export { AnimationController } from './infrastructure/controllers/AnimationController';
-
-// Infrastructure - Managers
-export { AssetManager } from './infrastructure/managers/AssetManager';
-export { MascotFactory, type MascotTemplate } from './infrastructure/managers/MascotFactory';
-
-// Presentation - Components
-export { MascotView } from './presentation/components/MascotView';
-export type { MascotViewProps } from './presentation/components/MascotView';
-
-// Presentation - Hooks
-export { useMascot } from './presentation/hooks/useMascot';
-export type {
-  UseMascotOptions,
-  UseMascotReturn,
-} from './presentation/hooks/useMascot';
-
-export { useMascotAnimation } from './presentation/hooks/useMascotAnimation';
-export type {
-  UseMascotAnimationOptions,
-  UseMascotAnimationReturn,
-} from './presentation/hooks/useMascotAnimation';
-
-// Presentation - Contexts
-export { MascotProvider, useMascotContext } from './presentation/contexts/MascotContext';
-export type { MascotProviderProps, MascotContextValue } from './presentation/contexts/MascotContext';
+// Re-export all layers
+export * from './core';
+export * from './application';
+export * from './infrastructure';
+export * from './presentation';
 
 // Constants
+import type { MascotMood, AnimationSpeed } from './domain/types/MascotTypes';
+
 export const MASCOT_TEMPLATES = [
   'friendly-bot',
   'cute-pet',
@@ -97,3 +38,10 @@ export const DEFAULT_ANIMATION_SPEEDS: AnimationSpeed[] = [
   'fast',
   'very-fast',
 ];
+
+// Convenience export - get service instance
+export const getMascotService = () => {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const { DIContainer } = require('./infrastructure/di/Container');
+  return DIContainer.getInstance().getMascotService();
+};

package/src/infrastructure/controllers/AnimationController.ts

@@ -1,163 +1,67 @@
 /**
- * Animation Controller Implementation
- * Controls Lottie and SVG animations with unified API
+ * Animation Controller (Main - 60 lines)
+ * Unified animation control interface
  */
 
-import type {
-  IAnimationController,
-  AnimationOptions,
-  AnimationEvent,
-} from '../../domain/interfaces/IAnimationController';
+import type { IAnimationController, AnimationOptions, AnimationEvent } from '../../domain/interfaces/IAnimationController';
 import type { MascotAnimation } from '../../domain/types/MascotTypes';
+import { AnimationPlayer } from './AnimationPlayer';
+import { EventManager } from './EventManager';
 
 export class AnimationController implements IAnimationController {
-  private _currentAnimation: MascotAnimation | null = null;
-  private _isPlaying: boolean = false;
-  private _isPaused: boolean = false;
-  private _progress: number = 0;
-  private _speed: number = 1;
-  private _eventListeners: Map<AnimationEvent, Set<(data?: unknown) => void>>;
+  private _player: AnimationPlayer;
+  private _events: EventManager;
 
   constructor() {
-    this._eventListeners = new Map();
-    this._initializeEventListeners();
+    this._player = new AnimationPlayer();
+    this._events = new EventManager();
   }
 
-  play(
-    animation: MascotAnimation,
-    options?: AnimationOptions
-  ): Promise<void> {
-    this._currentAnimation = animation;
-    this._isPlaying = true;
-    this._isPaused = false;
-
-    if (options?.speed !== undefined) {
-      this._speed = options.speed;
-    }
-
-    this._emit('start', { animation: animation.id });
-
-    // Simulate animation completion
-    // In real implementation, this would be controlled by LottieView
-    const duration = animation.duration || 2000;
-    const adjustedDuration = duration / this._speed;
-
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        if (this._isPlaying && !this._isPaused) {
-          this._isPlaying = false;
-          this._progress = 1;
-          this._emit('finish', { animation: animation.id });
-          options?.onFinish?.();
-        }
-        resolve();
-      }, adjustedDuration);
-
-      options?.onStart?.();
-    });
+  play(animation: MascotAnimation, options?: AnimationOptions): Promise<void> {
+    return this._player.play(animation, options);
   }
 
   pause(): void {
-    if (!this._isPlaying || this._isPaused) {
-      return;
-    }
-
-    this._isPaused = true;
-    this._emit('pause');
+    this._player.pause();
+    this._events.emit('pause');
   }
 
   resume(): void {
-    if (!this._isPaused) {
-      return;
-    }
-
-    this._isPaused = false;
-    this._emit('resume');
+    this._player.resume();
+    this._events.emit('resume');
   }
 
   stop(): void {
-    this._isPlaying = false;
-    this._isPaused = false;
-    this._progress = 0;
-    this._currentAnimation = null;
+    this._player.stop();
   }
 
   getProgress(): number {
-    return this._progress;
+    return this._player.progress;
   }
 
   setProgress(progress: number): void {
-    if (progress < 0 || progress > 1) {
-      throw new Error('Progress must be between 0 and 1');
-    }
-    this._progress = progress;
-    this._emit('progress', { progress });
+    this._player.setProgress(progress);
+    this._events.emit('progress', { progress });
   }
 
   setSpeed(speed: number): void {
-    if (speed <= 0) {
-      throw new Error('Speed must be greater than 0');
-    }
-    this._speed = speed;
+    this._player.setSpeed(speed);
   }
 
   isPlaying(): boolean {
-    return this._isPlaying && !this._isPaused;
+    return this._player.isPlaying;
   }
 
   on(event: AnimationEvent, callback: (data?: unknown) => void): () => void {
-    if (!this._eventListeners.has(event)) {
-      this._eventListeners.set(event, new Set());
-    }
-
-    this._eventListeners.get(event)!.add(callback);
-
-    // Return unsubscribe function
-    return () => {
-      this.off(event, callback);
-    };
+    return this._events.on(event, callback);
   }
 
   off(event: AnimationEvent, callback: (data?: unknown) => void): void {
-    const listeners = this._eventListeners.get(event);
-    if (listeners) {
-      listeners.delete(callback);
-    }
-  }
-
-  // Private Methods
-  private _initializeEventListeners(): void {
-    const events: AnimationEvent[] = ['start', 'finish', 'pause', 'resume', 'progress', 'error'];
-    events.forEach((event) => {
-      if (!this._eventListeners.has(event)) {
-        this._eventListeners.set(event, new Set());
-      }
-    });
-  }
-
-  private _emit(event: AnimationEvent, data?: unknown): void {
-    const listeners = this._eventListeners.get(event);
-    if (listeners) {
-      listeners.forEach((callback) => {
-        try {
-          callback(data);
-        } catch (error) {
-          console.error(`Error in ${event} event listener:`, error);
-        }
-      });
-    }
-  }
-
-  // Getters
-  get currentAnimation(): MascotAnimation | null {
-    return this._currentAnimation;
-  }
-
-  get speed(): number {
-    return this._speed;
+    this._events.off(event, callback);
   }
 
-  get isPaused(): boolean {
-    return this._isPaused;
+  destroy(): void {
+    this._player.destroy();
+    this._events.clear();
   }
 }

package/src/infrastructure/controllers/AnimationPlayer.ts

@@ -0,0 +1,104 @@
+/**
+ * Animation Player (100 lines)
+ * Core playback logic for mascot animations
+ */
+
+import type { MascotAnimation } from '../../domain/types/MascotTypes';
+import type { AnimationOptions } from '../../domain/interfaces/IAnimationController';
+import { AnimationTimer } from './AnimationTimer';
+
+export class AnimationPlayer {
+  private _currentAnimation: MascotAnimation | null = null;
+  private _isPlaying: boolean = false;
+  private _isPaused: boolean = false;
+  private _progress: number = 0;
+  private _speed: number = 1;
+  private readonly _timer: AnimationTimer;
+
+  constructor() {
+    this._timer = new AnimationTimer();
+  }
+
+  get currentAnimation(): MascotAnimation | null {
+    return this._currentAnimation;
+  }
+
+  get isPlaying(): boolean {
+    return this._isPlaying && !this._isPaused;
+  }
+
+  get progress(): number {
+    return this._progress;
+  }
+
+  get speed(): number {
+    return this._speed;
+  }
+
+  play(animation: MascotAnimation, options?: AnimationOptions): Promise<void> {
+    // Stop existing animation
+    this.stop();
+
+    this._currentAnimation = animation;
+    this._isPlaying = true;
+    this._isPaused = false;
+
+    if (options?.speed !== undefined) {
+      this._speed = options.speed;
+    }
+
+    const duration = animation.duration || 2000;
+    const adjustedDuration = duration / this._speed;
+
+    // Start timer
+    this._timer.start(adjustedDuration, () => {
+      this._isPlaying = false;
+      this._progress = 1;
+      options?.onFinish?.();
+    });
+
+    options?.onStart?.();
+    return Promise.resolve();
+  }
+
+  pause(): void {
+    if (!this._isPlaying || this._isPaused) return;
+
+    this._isPaused = true;
+    this._timer.pause();
+  }
+
+  resume(): void {
+    if (!this._isPaused) return;
+
+    this._isPaused = false;
+    this._timer.resume();
+  }
+
+  stop(): void {
+    this._isPlaying = false;
+    this._isPaused = false;
+    this._progress = 0;
+    this._currentAnimation = null;
+    this._timer.stop();
+  }
+
+  setProgress(progress: number): void {
+    if (progress < 0 || progress > 1) {
+      throw new Error('Progress must be between 0 and 1');
+    }
+    this._progress = progress;
+  }
+
+  setSpeed(speed: number): void {
+    if (speed <= 0) {
+      throw new Error('Speed must be greater than 0');
+    }
+    this._speed = speed;
+  }
+
+  destroy(): void {
+    this.stop();
+    this._timer.destroy();
+  }
+}