@umituz/react-native-mascot 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-mascot",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Interactive mascot system for React Native apps - Customizable animated characters with Lottie and SVG support, mood system, and easy integration",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/application/dto/MascotDTO.ts

@@ -0,0 +1,64 @@
+/**
+ * Data Transfer Objects
+ * Used for data transfer between layers
+ */
+
+import type { MascotConfig, MascotState, MascotAppearance, MascotPersonality } from '../../domain/types/MascotTypes';
+
+/**
+ * Mascot DTO - simplified mascot data for presentation
+ */
+export interface MascotDTO {
+  id: string;
+  name: string;
+  type: string;
+  personality: MascotPersonality;
+  appearance: MascotAppearance;
+  state: MascotState;
+  interactive: boolean;
+  touchEnabled: boolean;
+  soundEnabled: boolean;
+}
+
+/**
+ * Animation State DTO
+ */
+export interface AnimationStateDTO {
+  isPlaying: boolean;
+  currentAnimation: string | null;
+  progress: number;
+  speed: number;
+}
+
+/**
+ * Mascot Initialization Options DTO
+ */
+export interface MascotInitOptionsDTO {
+  config?: MascotConfig;
+  template?: string;
+  autoInitialize?: boolean;
+}
+
+/**
+ * Animation Playback Options DTO
+ */
+export interface AnimationPlaybackOptionsDTO {
+  speed?: number;
+  loop?: boolean;
+  autoplay?: boolean;
+  onStart?: () => void;
+  onFinish?: () => void;
+  onError?: (error: Error) => void;
+}
+
+/**
+ * Mascot Update Options DTO
+ */
+export interface MascotUpdateOptionsDTO {
+  mood?: string;
+  energy?: number;
+  friendliness?: number;
+  playfulness?: number;
+  baseColor?: string;
+  accentColor?: string;
+}

package/src/application/errors/MascotErrors.ts

@@ -0,0 +1,76 @@
+/**
+ * Domain Errors
+ * Custom error classes for mascot domain
+ */
+
+export class MascotError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'MascotError';
+    Object.setPrototypeOf(this, MascotError.prototype);
+  }
+}
+
+export class MascotNotInitializedError extends MascotError {
+  constructor() {
+    super('Mascot has not been initialized. Call initialize() or fromTemplate() first.');
+    this.name = 'MascotNotInitializedError';
+    Object.setPrototypeOf(this, MascotNotInitializedError.prototype);
+  }
+}
+
+export class AnimationNotFoundError extends MascotError {
+  constructor(animationId: string) {
+    super(`Animation with id "${animationId}" not found.`);
+    this.name = 'AnimationNotFoundError';
+    Object.setPrototypeOf(this, AnimationNotFoundError.prototype);
+  }
+}
+
+export class InvalidEnergyLevelError extends MascotError {
+  constructor(value: number) {
+    super(`Energy level must be between 0 and 1, got: ${value}`);
+    this.name = 'InvalidEnergyLevelError';
+    Object.setPrototypeOf(this, InvalidEnergyLevelError.prototype);
+  }
+}
+
+export class InvalidFriendlinessLevelError extends MascotError {
+  constructor(value: number) {
+    super(`Friendliness level must be between 0 and 1, got: ${value}`);
+    this.name = 'InvalidFriendlinessLevelError';
+    Object.setPrototypeOf(this, InvalidFriendlinessLevelError.prototype);
+  }
+}
+
+export class InvalidPlayfulnessLevelError extends MascotError {
+  constructor(value: number) {
+    super(`Playfulness level must be between 0 and 1, got: ${value}`);
+    this.name = 'InvalidPlayfulnessLevelError';
+    Object.setPrototypeOf(this, InvalidPlayfulnessLevelError.prototype);
+  }
+}
+
+export class InvalidMoodTransitionError extends MascotError {
+  constructor(from: string, to: string) {
+    super(`Cannot transition mood from "${from}" to "${to}".`);
+    this.name = 'InvalidMoodTransitionError';
+    Object.setPrototypeOf(this, InvalidMoodTransitionError.prototype);
+  }
+}
+
+export class MascotNotFoundError extends MascotError {
+  constructor(id: string) {
+    super(`Mascot with id "${id}" not found.`);
+    this.name = 'MascotNotFoundError';
+    Object.setPrototypeOf(this, MascotNotFoundError.prototype);
+  }
+}
+
+export class TemplateNotFoundError extends MascotError {
+  constructor(template: string) {
+    super(`Mascot template "${template}" not found.`);
+    this.name = 'TemplateNotFoundError';
+    Object.setPrototypeOf(this, TemplateNotFoundError.prototype);
+  }
+}

package/src/application/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Application Layer
+ * Exports all application layer components
+ */
+
+export * from './errors/MascotErrors';
+export * from './dto/MascotDTO';
+export * from './services/MascotService';

package/src/application/services/MascotService.ts

@@ -0,0 +1,194 @@
+/**
+ * MascotService
+ * Application service that orchestrates mascot use cases
+ * This is the main entry point for all mascot operations
+ */
+
+import { Mascot } from '../../domain/entities/Mascot';
+import type { MascotConfig, MascotMood, MascotAppearance, MascotAccessory } from '../../domain/types/MascotTypes';
+import type { IMascotRepository } from '../../domain/interfaces/IMascotRepository';
+import type { IAnimationController, AnimationOptions } from '../../domain/interfaces/IAnimationController';
+import type { IAssetManager } from '../../domain/interfaces/IAssetManager';
+import { MascotFactory } from '../../infrastructure/managers/MascotFactory';
+import { MascotNotInitializedError, AnimationNotFoundError } from '../errors/MascotErrors';
+
+export type MascotTemplate = 'friendly-bot' | 'cute-pet' | 'wise-owl' | 'pixel-hero';
+
+export class MascotService {
+  private _mascot: Mascot | null = null;
+  private _changeListeners: Set<() => void> = new Set();
+
+  constructor(
+    private readonly _repository: IMascotRepository,
+    private readonly _animationController: IAnimationController,
+    private readonly _assetManager: IAssetManager
+  ) {}
+
+  // ✅ Initialization
+  async initialize(config: MascotConfig): Promise<void> {
+    this._mascot = new Mascot(config);
+    await this._repository.save(config);
+    this._notifyChange();
+  }
+
+  async fromTemplate(
+    template: MascotTemplate,
+    customizations?: Partial<MascotConfig>
+  ): Promise<void> {
+    const mascot = MascotFactory.createFromTemplate(template, customizations);
+    this._mascot = mascot;
+    await this._repository.save(mascot.config);
+    this._notifyChange();
+  }
+
+  // ✅ State Getters
+  get mascot(): Mascot | null {
+    return this._mascot;
+  }
+
+  get isPlaying(): boolean {
+    return this._animationController.isPlaying();
+  }
+
+  get currentAnimation(): string | null {
+    return this._mascot?.state.currentAnimation ?? null;
+  }
+
+  get isReady(): boolean {
+    return this._mascot !== null;
+  }
+
+  // ✅ Personality Management
+  setMood(mood: MascotMood): void {
+    this._ensureMascot();
+    this._mascot!.setMood(mood);
+    this._notifyChange();
+  }
+
+  setEnergy(value: number): void {
+    this._ensureMascot();
+    this._mascot!.setEnergy(value);
+    this._notifyChange();
+  }
+
+  setFriendliness(value: number): void {
+    this._ensureMascot();
+    this._mascot!.setFriendliness(value);
+    this._notifyChange();
+  }
+
+  setPlayfulness(value: number): void {
+    this._ensureMascot();
+    this._mascot!.setPlayfulness(value);
+    this._notifyChange();
+  }
+
+  // ✅ Rich Behaviors
+  cheerUp(): void {
+    this._ensureMascot();
+    this._mascot!.cheerUp();
+    this._notifyChange();
+  }
+
+  boostEnergy(amount: number): void {
+    this._ensureMascot();
+    this._mascot!.boostEnergy(amount);
+    this._notifyChange();
+  }
+
+  // ✅ Appearance Management
+  updateAppearance(appearance: Partial<MascotAppearance>): void {
+    this._ensureMascot();
+    this._mascot!.updateAppearance(appearance);
+    this._notifyChange();
+  }
+
+  setBaseColor(color: string): void {
+    this._ensureMascot();
+    this._mascot!.setBaseColor(color);
+    this._notifyChange();
+  }
+
+  setAccentColor(color: string): void {
+    this._ensureMascot();
+    this._mascot!.setAccentColor(color);
+    this._notifyChange();
+  }
+
+  addAccessory(accessory: {
+    id: string;
+    type: string;
+    color?: string;
+    position?: { x: number; y: number };
+  }): void {
+    this._ensureMascot();
+    this._mascot!.addAccessory(accessory);
+    this._notifyChange();
+  }
+
+  removeAccessory(accessoryId: string): void {
+    this._ensureMascot();
+    this._mascot!.removeAccessory(accessoryId);
+    this._notifyChange();
+  }
+
+  // ✅ Animation Management
+  async playAnimation(animationId: string, options?: AnimationOptions): Promise<void> {
+    this._ensureMascot();
+    const animation = this._mascot!.getAnimation(animationId);
+    if (!animation) {
+      throw new AnimationNotFoundError(animationId);
+    }
+    this._mascot!.startAnimation(animationId);
+    await this._animationController.play(animation, options);
+    this._notifyChange();
+  }
+
+  stopAnimation(): void {
+    this._animationController.stop();
+    if (this._mascot) {
+      this._mascot.stopAnimation();
+    }
+    this._notifyChange();
+  }
+
+  pauseAnimation(): void {
+    this._animationController.pause();
+    this._notifyChange();
+  }
+
+  resumeAnimation(): void {
+    this._animationController.resume();
+    this._notifyChange();
+  }
+
+  // ✅ Visibility & Position
+  setVisible(visible: boolean): void {
+    this._ensureMascot();
+    this._mascot!.setVisible(visible);
+    this._notifyChange();
+  }
+
+  setPosition(position: { x: number; y: number }): void {
+    this._ensureMascot();
+    this._mascot!.setPosition(position);
+    this._notifyChange();
+  }
+
+  // ✅ Observable Pattern for React Integration
+  subscribe(listener: () => void): () => void {
+    this._changeListeners.add(listener);
+    return () => this._changeListeners.delete(listener);
+  }
+
+  private _notifyChange(): void {
+    this._changeListeners.forEach((listener) => listener());
+  }
+
+  // ✅ Validation
+  private _ensureMascot(): void {
+    if (!this._mascot) {
+      throw new MascotNotInitializedError();
+    }
+  }
+}

package/src/domain/entities/Mascot.ts

@@ -1,6 +1,6 @@
 /**
  * Mascot Entity
- * Core mascot representation following DDD principles
+ * Core mascot representation following DDD principles with Value Objects
  */
 
 import type {
@@ -13,12 +13,16 @@ import type {
   MascotMood,
   MascotAccessory,
 } from '../types/MascotTypes';
+import { Mood, EnergyLevel, FriendlinessLevel, PlayfulnessLevel } from '../value-objects';
 
 export class Mascot {
   readonly id: string;
   readonly name: string;
   readonly type: MascotType;
-  private _personality: MascotPersonality;
+  private _mood: Mood;
+  private _energy: EnergyLevel;
+  private _friendliness: FriendlinessLevel;
+  private _playfulness: PlayfulnessLevel;
   private _appearance: MascotAppearance;
   private readonly _animations: Map<string, MascotAnimation>;
   private readonly _config: MascotConfig;
@@ -29,7 +33,10 @@ export class Mascot {
     this.id = config.id;
     this.name = config.name;
     this.type = config.type;
-    this._personality = config.personality;
+    this._mood = Mood.create(config.personality.mood);
+    this._energy = EnergyLevel.create(config.personality.energy);
+    this._friendliness = FriendlinessLevel.create(config.personality.friendliness);
+    this._playfulness = PlayfulnessLevel.create(config.personality.playfulness);
     this._appearance = config.appearance;
     this._animations = new Map(
       config.animations.map((anim) => [anim.id, anim])
@@ -46,7 +53,12 @@ export class Mascot {
 
   // Getters
   get personality(): MascotPersonality {
-    return { ...this._personality };
+    return {
+      mood: this._mood.value,
+      energy: this._energy.value,
+      friendliness: this._friendliness.value,
+      playfulness: this._playfulness.value,
+    };
   }
 
   get appearance(): MascotAppearance {
@@ -77,31 +89,58 @@ export class Mascot {
     return this._config.soundEnabled ?? false;
   }
 
-  // Personality Management
+  // Value Object Getters (for domain logic)
+  get mood(): Mood {
+    return this._mood;
+  }
+
+  get energy(): EnergyLevel {
+    return this._energy;
+  }
+
+  get friendliness(): FriendlinessLevel {
+    return this._friendliness;
+  }
+
+  get playfulness(): PlayfulnessLevel {
+    return this._playfulness;
+  }
+
+  // Personality Management (using Value Objects)
   setMood(mood: MascotMood): void {
-    this._personality.mood = mood;
+    this._mood = Mood.create(mood);
     this._state.currentMood = mood;
   }
 
-  setEnergy(energy: number): void {
-    if (energy < 0 || energy > 1) {
-      throw new Error('Energy must be between 0 and 1');
-    }
-    this._personality.energy = energy;
+  setEnergy(value: number): void {
+    this._energy = EnergyLevel.create(value);
   }
 
-  setFriendliness(friendliness: number): void {
-    if (friendliness < 0 || friendliness > 1) {
-      throw new Error('Friendliness must be between 0 and 1');
-    }
-    this._personality.friendliness = friendliness;
+  setFriendliness(value: number): void {
+    this._friendliness = FriendlinessLevel.create(value);
   }
 
-  setPlayfulness(playfulness: number): void {
-    if (playfulness < 0 || playfulness > 1) {
-      throw new Error('Playfulness must be between 0 and 1');
+  setPlayfulness(value: number): void {
+    this._playfulness = PlayfulnessLevel.create(value);
+  }
+
+  // Rich behavior with Value Objects
+  cheerUp(): void {
+    if (this._mood.isNegative()) {
+      this._mood = Mood.create('neutral');
     }
-    this._personality.playfulness = playfulness;
+  }
+
+  boostEnergy(amount: number): void {
+    this._energy = this._energy.increase(amount);
+  }
+
+  drainEnergy(amount: number): void {
+    this._energy = this._energy.decrease(amount);
+  }
+
+  makeMoreFriendly(amount: number): void {
+    this._friendliness = this._friendliness.increase(amount);
   }
 
   // Appearance Management

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;
+  }
+}