@umituz/react-native-mascot 1.0.4 → 1.0.8

package/src/domain/types/AnimationStateTypes.ts

@@ -0,0 +1,148 @@
+/**
+ * Animation State Types
+ * State-based animation system inspired by AIStylistMascot implementation
+ */
+
+/**
+ * Predefined animation states with specific behaviors
+ */
+export type MascotAnimationState =
+  | 'idle'       // Calm breathing, default state (loop)
+  | 'loading'    // Active processing, rotation/swirl (loop)
+  | 'success'    // Confirmation, scale pulse (non-loop)
+  | 'error'      // Error acknowledgment, shake (non-loop)
+  | 'empty'      // Empty state, inviting gesture (loop)
+  | 'guide';     // Onboarding assistance (loop)
+
+/**
+ * State configuration for each animation state
+ */
+export interface MascotStateConfig {
+  state: MascotAnimationState;
+  loop: boolean;
+  duration?: number; // in milliseconds
+  autoPlay?: boolean;
+  speed?: number;
+  onComplete?: () => void;
+  transitionTo?: MascotAnimationState; // Auto-transition after completion
+}
+
+/**
+ * State transition rules
+ */
+export interface StateTransition {
+  from: MascotAnimationState;
+  to: MascotAnimationState;
+  condition?: 'always' | 'on-success' | 'on-error' | 'on-complete';
+  delay?: number; // Delay before transition (ms)
+}
+
+/**
+ * State history for tracking and debugging
+ */
+export interface StateHistoryEntry {
+  state: MascotAnimationState;
+  timestamp: number;
+  duration?: number;
+  triggeredBy?: 'user' | 'system' | 'auto-transition';
+}
+
+/**
+ * Size variants for mascot display
+ */
+export type MascotSize = 'small' | 'medium' | 'large' | number;
+
+/**
+ * Size configuration in pixels
+ */
+export interface MascotSizeConfig {
+  small: number;
+  medium: number;
+  large: number;
+}
+
+/**
+ * Default state configurations
+ */
+export const DEFAULT_STATE_CONFIGS: Record<MascotAnimationState, MascotStateConfig> = {
+  idle: {
+    state: 'idle',
+    loop: true,
+    duration: 3000,
+    autoPlay: true,
+    speed: 1,
+  },
+  loading: {
+    state: 'loading',
+    loop: true,
+    duration: 2000,
+    autoPlay: true,
+    speed: 1,
+  },
+  success: {
+    state: 'success',
+    loop: false,
+    duration: 1000,
+    autoPlay: true,
+    speed: 1,
+    transitionTo: 'idle',
+  },
+  error: {
+    state: 'error',
+    loop: false,
+    duration: 500,
+    autoPlay: true,
+    speed: 1,
+    transitionTo: 'idle',
+  },
+  empty: {
+    state: 'empty',
+    loop: true,
+    duration: 3000,
+    autoPlay: true,
+    speed: 1,
+  },
+  guide: {
+    state: 'guide',
+    loop: true,
+    duration: 2000,
+    autoPlay: true,
+    speed: 1,
+  },
+};
+
+/**
+ * Default size configurations in pixels
+ */
+export const DEFAULT_SIZE_CONFIG: MascotSizeConfig = {
+  small: 40,
+  medium: 80,
+  large: 120,
+};
+
+/**
+ * State transition mappings
+ */
+export const STATE_TRANSITIONS: Record<MascotAnimationState, StateTransition[]> = {
+  idle: [
+    { from: 'idle', to: 'loading', condition: 'always' },
+    { from: 'idle', to: 'empty', condition: 'always' },
+    { from: 'idle', to: 'guide', condition: 'always' },
+  ],
+  loading: [
+    { from: 'loading', to: 'success', condition: 'on-success' },
+    { from: 'loading', to: 'error', condition: 'on-error' },
+  ],
+  success: [
+    { from: 'success', to: 'idle', condition: 'on-complete', delay: 100 },
+  ],
+  error: [
+    { from: 'error', to: 'idle', condition: 'on-complete', delay: 100 },
+  ],
+  empty: [
+    { from: 'empty', to: 'idle', condition: 'always' },
+  ],
+  guide: [
+    { from: 'guide', to: 'idle', condition: 'on-complete', delay: 200 },
+  ],
+};

package/src/domain/types/MascotTypes.ts

@@ -73,3 +73,12 @@ export interface MascotInteraction {
   handler: () => void | Promise<void>;
   animation?: string;
 }
+
+export interface AnimationOptions {
+  speed?: number;
+  loop?: boolean;
+  autoplay?: boolean;
+  onStart?: () => void;
+  onFinish?: () => void;
+  onError?: (error: Error) => void;
+}

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

@@ -0,0 +1,126 @@
+/**
+ * Animation State Value Object
+ * Encapsulates animation state logic and validation
+ */
+
+import type {
+  MascotAnimationState,
+  MascotStateConfig,
+  StateTransition,
+} from '../types/AnimationStateTypes';
+import { DEFAULT_STATE_CONFIGS, STATE_TRANSITIONS } from '../types/AnimationStateTypes';
+
+export class AnimationState {
+  private constructor(
+    public readonly value: MascotAnimationState,
+    private readonly _config: MascotStateConfig
+  ) {}
+
+  static create(state: MascotAnimationState, config?: Partial<MascotStateConfig>): AnimationState {
+    const defaultConfig = DEFAULT_STATE_CONFIGS[state];
+    const finalConfig = { ...defaultConfig, ...config, state };
+    return new AnimationState(state, finalConfig);
+  }
+
+  /**
+   * Check if state should loop
+   */
+  shouldLoop(): boolean {
+    return this._config.loop;
+  }
+
+  /**
+   * Get animation duration
+   */
+  getDuration(): number {
+    return this._config.duration || 3000;
+  }
+
+  /**
+   * Check if animation should auto-play
+   */
+  shouldAutoPlay(): boolean {
+    return this._config.autoPlay ?? true;
+  }
+
+  /**
+   * Get animation speed
+   */
+  getSpeed(): number {
+    return this._config.speed || 1;
+  }
+
+  /**
+   * Get next state after completion (for auto-transition)
+   */
+  getNextState(): MascotAnimationState | null {
+    return this._config.transitionTo || null;
+  }
+
+  /**
+   * Get available transitions from current state
+   */
+  getAvailableTransitions(): StateTransition[] {
+    return STATE_TRANSITIONS[this.value] || [];
+  }
+
+  /**
+   * Check if transition to target state is allowed
+   */
+  canTransitionTo(targetState: MascotAnimationState): boolean {
+    const transitions = this.getAvailableTransitions();
+    return transitions.some(t => t.to === targetState);
+  }
+
+  /**
+   * Get transition delay to target state
+   */
+  getTransitionDelay(targetState: MascotAnimationState): number {
+    const transitions = this.getAvailableTransitions();
+    const transition = transitions.find(t => t.to === targetState);
+    return transition?.delay || 0;
+  }
+
+  /**
+   * Get completion callback
+   */
+  getOnComplete(): (() => void) | undefined {
+    return this._config.onComplete;
+  }
+
+  /**
+   * Check if state is a success state
+   */
+  isSuccessState(): boolean {
+    return this.value === 'success';
+  }
+
+  /**
+   * Check if state is an error state
+   */
+  isErrorState(): boolean {
+    return this.value === 'error';
+  }
+
+  /**
+   * Check if state is a loading state
+   */
+  isLoadingState(): boolean {
+    return this.value === 'loading';
+  }
+
+  /**
+   * Check if state is an idle state
+   */
+  isIdleState(): boolean {
+    return this.value === 'idle';
+  }
+
+  equals(other: AnimationState): boolean {
+    return this.value === other.value;
+  }
+
+  toJSON(): MascotStateConfig {
+    return { ...this._config };
+  }
+}

package/src/index.ts

@@ -2,109 +2,18 @@
  * @umituz/react-native-mascot
  *
  * 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 - Value Objects
-export { Mood, EnergyLevel, FriendlinessLevel, PlayfulnessLevel } from './domain/value-objects';
-
-// 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';
-
-// 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';
-
-// Infrastructure - Controllers
-export { AnimationController } from './infrastructure/controllers/AnimationController';
-
-// Infrastructure - Managers
-export { AssetManager } from './infrastructure/managers/AssetManager';
-export { MascotFactory, type MascotTemplate as FactoryMascotTemplate } 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',
@@ -132,6 +41,7 @@ export const DEFAULT_ANIMATION_SPEEDS: AnimationSpeed[] = [
 
 // 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();
+  }
+}