@umituz/react-native-mascot 1.0.3 → 1.0.7

package/src/infrastructure/controllers/AnimationTimer.ts

@@ -0,0 +1,62 @@
+/**
+ * Animation Timer (60 lines)
+ * Timer management with proper cleanup
+ */
+
+export class AnimationTimer {
+  private _timer: NodeJS.Timeout | null = null;
+  private _paused: boolean = false;
+  private _startTime: number = 0;
+  private _duration: number = 0;
+  private _remaining: number = 0;
+
+  start(duration: number, onComplete: () => void): void {
+    this._duration = duration;
+    this._startTime = Date.now();
+    this._remaining = duration;
+    this._paused = false;
+
+    this._timer = setTimeout(() => {
+      onComplete();
+      this._timer = null;
+    }, duration);
+  }
+
+  pause(): void {
+    if (!this._timer || this._paused) return;
+
+    const elapsed = Date.now() - this._startTime;
+    this._remaining = this._duration - elapsed;
+    clearTimeout(this._timer);
+    this._timer = null;
+    this._paused = true;
+  }
+
+  resume(): void {
+    if (this._timer || !this._paused || this._remaining <= 0) return;
+
+    this._startTime = Date.now();
+    this._paused = false;
+
+    this._timer = setTimeout(() => {
+      this._timer = null;
+    }, this._remaining);
+  }
+
+  stop(): void {
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = null;
+    }
+    this._paused = false;
+    this._remaining = 0;
+  }
+
+  destroy(): void {
+    this.stop();
+  }
+
+  get isActive(): boolean {
+    return this._timer !== null;
+  }
+}

package/src/infrastructure/controllers/EventManager.ts

@@ -0,0 +1,108 @@
+/**
+ * Event Manager (80 lines)
+ * Event listener management with memory leak prevention
+ */
+
+import type { AnimationEvent } from '../../domain/interfaces/IAnimationController';
+
+// Maximum listeners per event
+const MAX_LISTENERS = 10;
+
+interface ListenerWrapper {
+  callback: (data?: unknown) => void;
+  isActive: boolean;
+}
+
+export class EventManager {
+  private _listeners: Map<AnimationEvent, Set<ListenerWrapper>>;
+
+  constructor() {
+    this._listeners = new Map();
+    this._initializeListeners();
+  }
+
+  on(event: AnimationEvent, callback: (data?: unknown) => void): () => void {
+    const listeners = this._getListeners(event);
+
+    // Check limit
+    if (listeners.size >= MAX_LISTENERS) {
+      console.warn(`Max listeners (${MAX_LISTENERS}) for event "${event}"`);
+    }
+
+    const wrapper: ListenerWrapper = { callback, isActive: true };
+    listeners.add(wrapper);
+
+    return () => {
+      wrapper.isActive = false;
+      listeners.delete(wrapper);
+    };
+  }
+
+  off(event: AnimationEvent, callback: (data?: unknown) => void): void {
+    const listeners = this._getListeners(event);
+    for (const wrapper of listeners) {
+      if (wrapper.callback === callback) {
+        wrapper.isActive = false;
+        listeners.delete(wrapper);
+        break;
+      }
+    }
+  }
+
+  emit(event: AnimationEvent, data?: unknown): void {
+    const listeners = this._listeners.get(event);
+    if (!listeners || listeners.size === 0) return;
+
+    for (const wrapper of listeners) {
+      if (wrapper.isActive) {
+        try {
+          wrapper.callback(data);
+        } catch {
+          // Silent fail to prevent breaking animation
+        }
+      }
+    }
+
+    // Periodic cleanup
+    if (listeners.size > MAX_LISTENERS / 2) {
+      this._cleanupInactive(event);
+    }
+  }
+
+  clear(): void {
+    this._listeners.clear();
+    this._initializeListeners();
+  }
+
+  private _getListeners(event: AnimationEvent): Set<ListenerWrapper> {
+    if (!this._listeners.has(event)) {
+      this._listeners.set(event, new Set());
+    }
+    return this._listeners.get(event)!;
+  }
+
+  private _initializeListeners(): void {
+    const events: AnimationEvent[] = ['start', 'finish', 'pause', 'resume', 'progress', 'error'];
+    events.forEach((event) => {
+      if (!this._listeners.has(event)) {
+        this._listeners.set(event, new Set());
+      }
+    });
+  }
+
+  private _cleanupInactive(event: AnimationEvent): void {
+    const listeners = this._listeners.get(event);
+    if (!listeners) return;
+
+    const toRemove: ListenerWrapper[] = [];
+    for (const wrapper of listeners) {
+      if (!wrapper.isActive) {
+        toRemove.push(wrapper);
+      }
+    }
+
+    for (const wrapper of toRemove) {
+      listeners.delete(wrapper);
+    }
+  }
+}

package/src/infrastructure/di/Container.ts

@@ -0,0 +1,153 @@
+/**
+ * DI Container (OPTIMIZED)
+ * Lazy imports with caching and better singleton management
+ */
+
+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';
+
+// Cache for lazy-loaded modules
+interface ModuleCache<T> {
+  module: T | null;
+  initialized: boolean;
+}
+
+export class DIContainer {
+  private static _instance: DIContainer;
+  private _animationController: AnimationController | null = null;
+  private _assetManager: AssetManager | null = null;
+  private _repository: IMascotRepository | null = null;
+  private _mascotServiceCache: ModuleCache<MascotService> = {
+    module: null,
+    initialized: false,
+  };
+
+  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 (with caching)
+   */
+  getMascotService(): MascotService {
+    if (!this._mascotServiceCache.initialized) {
+      // Lazy import to avoid circular dependencies
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const { MascotService } = require('../../application/services/MascotService');
+
+      this._mascotServiceCache.module = new MascotService(
+        this.getRepository(),
+        this.getAnimationController(),
+        this.getAssetManager()
+      );
+      this._mascotServiceCache.initialized = true;
+    }
+
+    return this._mascotServiceCache.module!;
+  }
+
+  /**
+   * Reset all instances (useful for testing)
+   */
+  reset(): void {
+    // Cleanup animation controller
+    if (this._animationController) {
+      this._animationController.destroy();
+      this._animationController = null;
+    }
+
+    this._assetManager = null;
+    this._repository = null;
+    this._mascotServiceCache = {
+      module: null,
+      initialized: false,
+    };
+  }
+
+  /**
+   * Check if container has been initialized
+   */
+  isInitialized(): boolean {
+    return this._mascotServiceCache.initialized;
+  }
+
+  /**
+   * Get container statistics (for debugging)
+   */
+  getStats(): {
+    singletons: {
+      animationController: boolean;
+      assetManager: boolean;
+      repository: boolean;
+      mascotService: boolean;
+    };
+  } {
+    return {
+      singletons: {
+        animationController: this._animationController !== null,
+        assetManager: this._assetManager !== null,
+        repository: this._repository !== null,
+        mascotService: this._mascotServiceCache.initialized,
+      },
+    };
+  }
+
+  /**
+   * Cleanup method (call when app unmounts)
+   */
+  destroy(): void {
+    // Destroy animation controller
+    if (this._animationController) {
+      this._animationController.destroy();
+      this._animationController = null;
+    }
+
+    // Clear cache
+    this._mascotServiceCache = {
+      module: null,
+      initialized: false,
+    };
+
+    // Reset other singletons
+    this._assetManager = null;
+    this._repository = null;
+  }
+}

package/src/infrastructure/managers/AssetManager.ts

@@ -1,23 +1,59 @@
 /**
- * Asset Manager Implementation
- * Loads and caches Lottie and SVG assets
+ * Asset Manager Implementation (OPTIMIZED)
+ * Loads and caches Lottie and SVG assets with LRU cache
  */
 
-import type {
-  IAssetManager,
-  AssetCache,
-} from '../../domain/interfaces/IAssetManager';
+import type { IAssetManager } from '../../domain/interfaces/IAssetManager';
 import type { MascotAnimation } from '../../domain/types/MascotTypes';
+import { LRUCache } from '../utils/LRUCache';
+
+// Cache size constants
+const DEFAULT_MAX_CACHE_SIZE_BYTES = 50 * 1024 * 1024; // 50MB
+const CACHE_EVICTION_RATIO = 0.3; // Evict 30% of cache when full
+const BYTES_PER_CHAR = 2; // UTF-16 encoding
+
+// Size cache to avoid repeated JSON.stringify calls
+const SIZE_CACHE_MAX_SIZE = 100;
+const sizeCache = new Map<unknown, number>();
+
+/**
+ * Get estimated size with caching
+ */
+function getEstimatedSize(data: unknown): number {
+  // Check cache first
+  if (sizeCache.has(data)) {
+    return sizeCache.get(data)!;
+  }
+
+  // Calculate and cache
+  const size = JSON.stringify(data).length * BYTES_PER_CHAR;
+
+  // Add to cache if space available
+  if (sizeCache.size < SIZE_CACHE_MAX_SIZE) {
+    sizeCache.set(data, size);
+  }
+
+  return size;
+}
+
+/**
+ * Cache entry with metadata
+ */
+interface CacheEntry {
+  data: unknown;
+  size: number;
+  timestamp: number;
+}
 
 export class AssetManager implements IAssetManager {
-  private readonly _cache: AssetCache;
-  private readonly _loadedAssets: Set<string>;
-  private readonly _maxCacheSize: number = 50 * 1024 * 1024; // 50MB
+  private readonly lruCache: LRUCache<string, CacheEntry>;
   private _currentCacheSize: number = 0;
+  private readonly _maxCacheSize: number;
 
-  constructor() {
-    this._cache = {};
-    this._loadedAssets = new Set();
+  constructor(maxCacheSize: number = DEFAULT_MAX_CACHE_SIZE_BYTES) {
+    this._maxCacheSize = maxCacheSize;
+    // Cache up to 1000 items (will be limited by size anyway)
+    this.lruCache = new LRUCache<string, CacheEntry>(1000);
   }
 
   loadLottieAnimation(
@@ -25,8 +61,10 @@ export class AssetManager implements IAssetManager {
   ): Promise<MascotAnimation> {
     const assetId = this._getAssetId(source);
 
-    if (this._isAssetLoaded(assetId)) {
-      return Promise.resolve(this._cache[assetId].data as MascotAnimation);
+    // Check LRU cache first (O(1) operation)
+    const cached = this.lruCache.get(assetId);
+    if (cached) {
+      return Promise.resolve(cached.data as MascotAnimation);
     }
 
     // Simulate loading - in real implementation, this would actually load the file
@@ -39,13 +77,16 @@ export class AssetManager implements IAssetManager {
       autoplay: false,
     };
 
+    // Cache the animation
     this._cacheAsset(assetId, animation);
     return Promise.resolve(animation);
   }
 
   loadSVGAsset(source: string): Promise<string> {
-    if (this._isAssetLoaded(source)) {
-      return Promise.resolve(this._cache[source].data as string);
+    // Check LRU cache first
+    const cached = this.lruCache.get(source);
+    if (cached) {
+      return Promise.resolve(cached.data as string);
     }
 
     // Simulate loading - in real implementation, this would load the SVG file
@@ -55,6 +96,7 @@ export class AssetManager implements IAssetManager {
   }
 
   async preloadAnimations(sources: Array<string | object>): Promise<void> {
+    // Load in parallel for better performance
     const promises = sources.map((source) =>
       this.loadLottieAnimation(source)
     );
@@ -62,26 +104,43 @@ export class AssetManager implements IAssetManager {
   }
 
   clearCache(): void {
-    Object.keys(this._cache).forEach((key) => {
-      delete this._cache[key];
-    });
-    this._loadedAssets.clear();
+    this.lruCache.clear();
     this._currentCacheSize = 0;
+    sizeCache.clear(); // Clear size cache too
   }
 
   getAssetUrl(assetId: string): string | null {
-    if (this._isAssetLoaded(assetId)) {
+    if (this.lruCache.has(assetId)) {
       return assetId;
     }
     return null;
   }
 
   isAssetLoaded(assetId: string): boolean {
-    return this._loadedAssets.has(assetId);
+    return this.lruCache.has(assetId);
   }
 
   getLoadedAssets(): string[] {
-    return Array.from(this._loadedAssets);
+    return this.lruCache.keys();
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getCacheStats(): {
+    size: number;
+    count: number;
+    maxSize: number;
+    usage: number;
+    lruStats: { size: number; capacity: number; usage: number };
+  } {
+    return {
+      size: this._currentCacheSize,
+      count: this.lruCache.size(),
+      maxSize: this._maxCacheSize,
+      usage: this._currentCacheSize / this._maxCacheSize,
+      lruStats: this.lruCache.getStats(),
+    };
   }
 
   // Private Methods
@@ -92,68 +151,80 @@ export class AssetManager implements IAssetManager {
     return JSON.stringify(source);
   }
 
+  /**
+   * Cache asset with LRU eviction
+   */
   private _cacheAsset(assetId: string, data: unknown): void {
-    const size = this._estimateSize(data);
+    const size = getEstimatedSize(data);
+
+    // Check if single asset exceeds cache size
+    if (size > this._maxCacheSize) {
+      console.warn(`Asset ${assetId} (${size} bytes) exceeds cache size (${this._maxCacheSize} bytes)`);
+      return;
+    }
+
+    // Check if updating existing asset
+    const existing = this.lruCache.get(assetId);
+    if (existing) {
+      this._currentCacheSize -= existing.size;
+    }
 
-    // Check if cache is full
-    if (this._currentCacheSize + size > this._maxCacheSize) {
-      this._evictOldestAssets();
+    // Evict assets if needed (LRU handles this automatically)
+    const spaceNeeded = size - (existing?.size || 0);
+    if (this._currentCacheSize + spaceNeeded > this._maxCacheSize) {
+      this._evictLRUAssets(spaceNeeded);
     }
 
-    this._cache[assetId] = {
+    // Add to cache
+    this.lruCache.set(assetId, {
       data,
-      timestamp: Date.now(),
       size,
-    };
-
-    this._loadedAssets.add(assetId);
-    this._currentCacheSize += size;
-  }
+      timestamp: Date.now(),
+    });
 
-  private _isAssetLoaded(assetId: string): boolean {
-    return this._loadedAssets.has(assetId) && !!this._cache[assetId];
+    this._currentCacheSize += spaceNeeded;
   }
 
-  private _evictOldestAssets(): void {
-    const sortedAssets = Object.entries(this._cache)
-      .sort(([, a], [, b]) => a.timestamp - b.timestamp);
+  /**
+   * Evict LRU assets to make space (much faster than sorting)
+   */
+  private _evictLRUAssets(requiredSpace: number): void {
+    const targetSpace = this._maxCacheSize * CACHE_EVICTION_RATIO;
+    const spaceToFree = Math.max(requiredSpace, targetSpace);
 
     let freedSpace = 0;
-    const targetSpace = this._maxCacheSize * 0.3; // Evict 30% of cache
+    const keysToRemove: string[] = [];
 
-    for (const [assetId, asset] of sortedAssets) {
-      if (freedSpace >= targetSpace) {
+    // Iterate from least recently used (tail) to most recently used (head)
+    const keys = this.lruCache.keys();
+    for (const key of keys) {
+      if (freedSpace >= spaceToFree) {
         break;
       }
 
-      delete this._cache[assetId];
-      this._loadedAssets.delete(assetId);
-      freedSpace += asset.size;
-      this._currentCacheSize -= asset.size;
+      const entry = this.lruCache.get(key);
+      if (entry) {
+        freedSpace += entry.size;
+        keysToRemove.push(key);
+      }
     }
-  }
 
-  private _estimateSize(data: unknown): number {
-    // Rough estimation in bytes
-    return JSON.stringify(data).length * 2; // 2 bytes per char (UTF-16)
+    // Remove evicted entries
+    for (const key of keysToRemove) {
+      const entry = this.lruCache.get(key);
+      if (entry) {
+        this._currentCacheSize -= entry.size;
+      }
+      this.lruCache.delete(key);
+    }
   }
 
+  /**
+   * Load SVG from file (placeholder)
+   */
   private _loadSVGFromFile(_source: string): string {
     // In real implementation, this would use FileSystem or require()
     // For now, return a placeholder
     return `<svg viewBox="0 0 100 100"><circle cx="50" cy="50" r="40" fill="currentColor"/></svg>`;
   }
-
-  // Getters
-  get cacheSize(): number {
-    return this._currentCacheSize;
-  }
-
-  get cacheStats(): { size: number; count: number; maxSize: number } {
-    return {
-      size: this._currentCacheSize,
-      count: this._loadedAssets.size,
-      maxSize: this._maxCacheSize,
-    };
-  }
 }

package/src/infrastructure/managers/MascotBuilder.ts

@@ -0,0 +1,89 @@
+/**
+ * Mascot Builder (80 lines)
+ * Builder pattern for custom mascot creation
+ */
+
+import type { MascotConfig, MascotType } from '../../domain/types/MascotTypes';
+import { getDefaultAnimations } from './MascotTemplates';
+
+export class MascotBuilder {
+  private config: MascotConfig;
+
+  constructor(options: {
+    id?: string;
+    name?: string;
+    type?: MascotType;
+  } = {}) {
+    this.config = {
+      id: options.id || 'custom-mascot',
+      name: options.name || 'Custom Mascot',
+      type: options.type || 'svg',
+      personality: {
+        mood: 'happy',
+        energy: 0.7,
+        friendliness: 0.8,
+        playfulness: 0.6,
+      },
+      appearance: {
+        baseColor: '#FF6B6B',
+        accentColor: '#4ECDC4',
+        accessories: [],
+        style: 'minimal',
+        scale: 1,
+      },
+      animations: getDefaultAnimations(),
+      interactive: true,
+      touchEnabled: true,
+      soundEnabled: false,
+    };
+  }
+
+  withId(id: string): MascotBuilder {
+    this.config.id = id;
+    return this;
+  }
+
+  withName(name: string): MascotBuilder {
+    this.config.name = name;
+    return this;
+  }
+
+  withType(type: MascotType): MascotBuilder {
+    this.config.type = type;
+    return this;
+  }
+
+  withPersonality(personality: Partial<MascotConfig['personality']>): MascotBuilder {
+    this.config.personality = { ...this.config.personality, ...personality };
+    return this;
+  }
+
+  withAppearance(appearance: Partial<MascotConfig['appearance']>): MascotBuilder {
+    this.config.appearance = { ...this.config.appearance, ...appearance };
+    return this;
+  }
+
+  withBaseColor(color: string): MascotBuilder {
+    this.config.appearance.baseColor = color;
+    return this;
+  }
+
+  withAccentColor(color: string): MascotBuilder {
+    this.config.appearance.accentColor = color;
+    return this;
+  }
+
+  interactive(enabled: boolean = true): MascotBuilder {
+    this.config.interactive = enabled;
+    return this;
+  }
+
+  touchEnabled(enabled: boolean = true): MascotBuilder {
+    this.config.touchEnabled = enabled;
+    return this;
+  }
+
+  build(): MascotConfig {
+    return this.config;
+  }
+}