@umituz/react-native-mascot 1.0.3 → 1.0.7

package/src/application/services/StateMachine.ts

@@ -0,0 +1,154 @@
+/**
+ * State Machine (120 lines)
+ * Core state transition logic with validation
+ */
+
+import type { MascotAnimationState } from '../../domain/types/AnimationStateTypes';
+import { AnimationState } from '../../domain/value-objects/AnimationState';
+import { StateTransitions } from './StateTransitions';
+import { StateHistory } from './StateHistory';
+
+export interface StateMachineConfig {
+  enableAutoTransition?: boolean;
+  enableHistoryTracking?: boolean;
+  maxHistorySize?: number;
+  onStateChange?: (from: MascotAnimationState, to: MascotAnimationState) => void;
+}
+
+export class StateMachine {
+  private _currentState: AnimationState;
+  private _previousState: AnimationState | null = null;
+  private readonly _transitions: StateTransitions;
+  private readonly _history: StateHistory;
+  private readonly _config: Required<StateMachineConfig>;
+
+  constructor(
+    initialState: MascotAnimationState = 'idle',
+    config: StateMachineConfig = {}
+  ) {
+    this._currentState = AnimationState.create(initialState);
+    this._transitions = new StateTransitions();
+    this._history = new StateHistory(config.maxHistorySize || 50);
+    this._config = {
+      enableAutoTransition: config.enableAutoTransition ?? true,
+      enableHistoryTracking: config.enableHistoryTracking ?? true,
+      maxHistorySize: config.maxHistorySize ?? 50,
+      onStateChange: config.onStateChange ?? (() => {}),
+    };
+  }
+
+  get currentState(): AnimationState {
+    return this._currentState;
+  }
+
+  get currentStateValue(): MascotAnimationState {
+    return this._currentState.value;
+  }
+
+  get previousState(): AnimationState | null {
+    return this._previousState;
+  }
+
+  get history(): MascotAnimationState[] {
+    return this._history.getStates();
+  }
+
+  transitionTo(
+    newState: MascotAnimationState,
+    triggeredBy: 'user' | 'system' | 'auto-transition' = 'user'
+  ): void {
+    // Validate transition
+    if (!this._transitions.canTransitionTo(this.currentStateValue, newState)) {
+      const validTransitions = this._transitions
+        .getAvailableTransitions(this.currentStateValue)
+        .map((t) => t.to);
+      throw new Error(
+        `Cannot transition from '${this.currentStateValue}' to '${newState}'. ` +
+        `Valid transitions: ${validTransitions.join(', ')}`
+      );
+    }
+
+    // Store previous state
+    this._previousState = this._currentState;
+
+    // Track history
+    if (this._config.enableHistoryTracking) {
+      this._history.add(this.currentStateValue, triggeredBy);
+    }
+
+    // Update state
+    const oldState = this.currentStateValue;
+    this._currentState = AnimationState.create(newState);
+
+    // Notify
+    this._config.onStateChange(oldState, newState);
+
+    // Schedule auto-transition
+    if (this._config.enableAutoTransition && !this._currentState.shouldLoop()) {
+      const next = this._currentState.getNextState();
+      if (next) {
+        this._scheduleAutoTransition(next);
+      }
+    }
+  }
+
+  // Shortcut methods
+  triggerSuccess(): void {
+    this.transitionTo('success', 'system');
+  }
+
+  triggerError(): void {
+    this.transitionTo('error', 'system');
+  }
+
+  startLoading(): void {
+    this.transitionTo('loading', 'system');
+  }
+
+  stopLoading(success: boolean): void {
+    if (this.currentStateValue === 'loading') {
+      this.transitionTo(success ? 'success' : 'error', 'system');
+    }
+  }
+
+  reset(): void {
+    this.transitionTo('idle', 'system');
+  }
+
+  // State queries
+  isLooping(): boolean {
+    return this._currentState.shouldLoop();
+  }
+
+  isIdle(): boolean {
+    return this.currentStateValue === 'idle';
+  }
+
+  isLoading(): boolean {
+    return this.currentStateValue === 'loading';
+  }
+
+  // Auto-transition scheduling
+  private _autoTransitionTimer: NodeJS.Timeout | null = null;
+
+  private _scheduleAutoTransition(targetState: MascotAnimationState): void {
+    const duration = this._currentState.getDuration();
+    const delay = this._currentState.getTransitionDelay(targetState);
+
+    this._autoTransitionTimer = setTimeout(() => {
+      try {
+        this.transitionTo(targetState, 'auto-transition');
+      } catch (error) {
+        console.warn('Auto-transition failed:', error);
+      }
+    }, duration + delay);
+  }
+
+  destroy(): void {
+    if (this._autoTransitionTimer) {
+      clearTimeout(this._autoTransitionTimer);
+    }
+    this._history.clear();
+    this._config.onStateChange = () => {};
+  }
+}

package/src/application/services/StateTransitions.ts

@@ -0,0 +1,73 @@
+/**
+ * State Transitions (80 lines)
+ * Transition rules and validation
+ */
+
+import type { MascotAnimationState } from '../../domain/types/AnimationStateTypes';
+
+export interface StateTransition {
+  from: MascotAnimationState;
+  to: MascotAnimationState;
+  condition?: 'always' | 'on-success' | 'on-error' | 'on-complete';
+  delay?: number;
+}
+
+export class StateTransitions {
+  private readonly _transitions: Map<MascotAnimationState, StateTransition[]>;
+
+  constructor() {
+    this._transitions = new Map();
+    this._initializeTransitions();
+  }
+
+  canTransitionTo(from: MascotAnimationState, to: MascotAnimationState): boolean {
+    const transitions = this._transitions.get(from);
+    if (!transitions) return false;
+    return transitions.some((t) => t.to === to);
+  }
+
+  getAvailableTransitions(state: MascotAnimationState): StateTransition[] {
+    return this._transitions.get(state) || [];
+  }
+
+  getTransitionDelay(from: MascotAnimationState, to: MascotAnimationState): number {
+    const transitions = this._transitions.get(from);
+    const transition = transitions?.find((t) => t.to === to);
+    return transition?.delay || 0;
+  }
+
+  private _initializeTransitions(): void {
+    // Idle transitions
+    this._addTransition('idle', 'loading', 'always');
+    this._addTransition('idle', 'empty', 'always');
+    this._addTransition('idle', 'guide', 'always');
+
+    // Loading transitions
+    this._addTransition('loading', 'success', 'on-success');
+    this._addTransition('loading', 'error', 'on-error');
+
+    // Success transitions
+    this._addTransition('success', 'idle', 'on-complete', 100);
+
+    // Error transitions
+    this._addTransition('error', 'idle', 'on-complete', 100);
+
+    // Empty transitions
+    this._addTransition('empty', 'idle', 'always');
+
+    // Guide transitions
+    this._addTransition('guide', 'idle', 'on-complete', 200);
+  }
+
+  private _addTransition(
+    from: MascotAnimationState,
+    to: MascotAnimationState,
+    condition: StateTransition['condition'] = 'always',
+    delay: number = 0
+  ): void {
+    if (!this._transitions.has(from)) {
+      this._transitions.set(from, []);
+    }
+    this._transitions.get(from)!.push({ from, to, condition, delay });
+  }
+}

package/src/application.ts

@@ -0,0 +1,40 @@
+/**
+ * Application Layer Exports (60 lines)
+ * Services, use cases, and DTOs
+ */
+
+// Application - Services
+export { AnimationStateManager } from './application/services/AnimationStateManager';
+export type { AnimationStateManagerConfig } from './application/services/AnimationStateManager';
+
+export { MascotService } from './application/services/MascotService';
+export type { MascotTemplate } from './application/services/MascotService';
+
+export { PersonalityManagement } from './application/services/PersonalityManagement';
+export { AppearanceManagement } from './application/services/AppearanceManagement';
+
+export { StateMachine } from './application/services/StateMachine';
+export { StateTransitions } from './application/services/StateTransitions';
+export { StateHistory } from './application/services/StateHistory';
+
+// 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';

package/src/assets/index.ts

@@ -3,21 +3,16 @@
  * Pre-configured mascots and animations
  */
 
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
 import type { MascotConfig, MascotAnimationType } from '../domain/types/MascotTypes';
+import type { MascotAnimation } from '../domain/types/MascotTypes';
 
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const idleAnim = require('./lottie/idle.json');
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const waveAnim = require('./lottie/wave.json');
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const jumpAnim = require('./lottie/jump.json');
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const successAnim = require('./lottie/success.json');
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const errorAnim = require('./lottie/error.json');
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const danceAnim = require('./lottie/dance.json');
+// Import JSON animations
+import idleAnim from './lottie/idle.json';
+import waveAnim from './lottie/wave.json';
+import jumpAnim from './lottie/jump.json';
+import successAnim from './lottie/success.json';
+import errorAnim from './lottie/error.json';
+import danceAnim from './lottie/dance.json';
 
 export const BUILT_IN_MASCOTS: Record<string, MascotConfig> = {
   'happy-robot': {
@@ -42,7 +37,7 @@ export const BUILT_IN_MASCOTS: Record<string, MascotConfig> = {
         id: 'idle',
         name: 'Idle',
         type: 'idle' as MascotAnimationType,
-        source: idleAnim,
+        source: idleAnim as MascotAnimation['source'],
         loop: true,
         autoplay: true,
       },
@@ -50,35 +45,35 @@ export const BUILT_IN_MASCOTS: Record<string, MascotConfig> = {
         id: 'wave',
         name: 'Wave',
         type: 'action' as MascotAnimationType,
-        source: waveAnim,
+        source: waveAnim as MascotAnimation['source'],
         loop: false,
       },
       {
         id: 'jump',
         name: 'Jump',
         type: 'action' as MascotAnimationType,
-        source: jumpAnim,
+        source: jumpAnim as MascotAnimation['source'],
         loop: false,
       },
       {
         id: 'success',
         name: 'Success',
         type: 'reaction' as MascotAnimationType,
-        source: successAnim,
+        source: successAnim as MascotAnimation['source'],
         loop: false,
       },
       {
         id: 'error',
         name: 'Error',
         type: 'reaction' as MascotAnimationType,
-        source: errorAnim,
+        source: errorAnim as MascotAnimation['source'],
         loop: false,
       },
       {
         id: 'dance',
         name: 'Dance',
         type: 'action' as MascotAnimationType,
-        source: danceAnim,
+        source: danceAnim as MascotAnimation['source'],
         loop: true,
       },
     ],

package/src/core.ts

@@ -0,0 +1,62 @@
+/**
+ * Core Domain Exports (80 lines)
+ * Domain entities, value objects, and types
+ */
+
+// Domain - Entities
+export { Mascot } from './domain/entities/Mascot';
+
+// Domain - Value Objects
+export { Mood } from './domain/value-objects/Mood';
+export { EnergyLevel } from './domain/value-objects/EnergyLevel';
+export { FriendlinessLevel } from './domain/value-objects/FriendlinessLevel';
+export { PlayfulnessLevel } from './domain/value-objects/PlayfulnessLevel';
+export { AnimationState } from './domain/value-objects/AnimationState';
+
+// Domain - Types - Animation States
+export type {
+  MascotAnimationState,
+  MascotStateConfig,
+  StateTransition,
+  StateHistoryEntry,
+  MascotSize,
+  MascotSizeConfig,
+} from './domain/types/AnimationStateTypes';
+
+export {
+  DEFAULT_STATE_CONFIGS,
+  DEFAULT_SIZE_CONFIG,
+  STATE_TRANSITIONS,
+} from './domain/types/AnimationStateTypes';
+
+// Domain - Types - Mascot
+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';