@umituz/react-native-mascot 1.0.4 → 1.0.7

package/src/infrastructure/managers/MascotFactory.ts

@@ -1,10 +1,18 @@
 /**
- * Mascot Factory
- * Creates pre-configured mascot instances
+ * Mascot Factory (100 lines)
+ * Factory methods for mascot creation
  */
 
 import { Mascot } from '../../domain/entities/Mascot';
 import type { MascotConfig, MascotType } from '../../domain/types/MascotTypes';
+import { getTemplateConfig } from './MascotTemplates';
+import { MascotBuilder } from './MascotBuilder';
+
+export type MascotTemplate =
+  | 'friendly-bot'
+  | 'cute-pet'
+  | 'wise-owl'
+  | 'pixel-hero';
 
 export class MascotFactory {
   /**
@@ -14,7 +22,7 @@ export class MascotFactory {
     template: MascotTemplate,
     customizations?: Partial<MascotConfig>
   ): Mascot {
-    const config = this._getTemplateConfig(template);
+    const config = getTemplateConfig(template);
     const finalConfig = this._mergeConfigs(config, customizations);
     return new Mascot(finalConfig);
   }
@@ -35,136 +43,23 @@ export class MascotFactory {
     type?: MascotType;
     baseColor?: string;
   }): Mascot {
-    const config: MascotConfig = {
-      id: options.id || 'simple-mascot',
-      name: options.name || 'Simple Mascot',
-      type: options.type || 'svg',
-      personality: {
-        mood: 'happy',
-        energy: 0.7,
-        friendliness: 0.8,
-        playfulness: 0.6,
-      },
-      appearance: {
-        baseColor: options.baseColor || '#FF6B6B',
-        accentColor: '#4ECDC4',
-        accessories: [],
-        style: 'minimal',
-        scale: 1,
-      },
-      animations: this._getDefaultAnimations(),
-      interactive: true,
-      touchEnabled: true,
-      soundEnabled: false,
-    };
-
-    return new Mascot(config);
+    const builder = new MascotBuilder(options);
+    if (options.baseColor) {
+      builder.withBaseColor(options.baseColor);
+    }
+    return new Mascot(builder.build());
   }
 
-  // Private Methods
-  private static _getTemplateConfig(template: MascotTemplate): MascotConfig {
-    const templates: Record<MascotTemplate, MascotConfig> = {
-      'friendly-bot': {
-        id: 'friendly-bot',
-        name: 'Friendly Bot',
-        type: 'lottie',
-        personality: {
-          mood: 'happy',
-          energy: 0.8,
-          friendliness: 0.9,
-          playfulness: 0.7,
-        },
-        appearance: {
-          baseColor: '#4A90E2',
-          accentColor: '#50E3C2',
-          accessories: [],
-          style: 'cartoon',
-          scale: 1,
-        },
-        animations: this._getDefaultAnimations(),
-        interactive: true,
-        touchEnabled: true,
-        soundEnabled: false,
-      },
-      'cute-pet': {
-        id: 'cute-pet',
-        name: 'Cute Pet',
-        type: 'svg',
-        personality: {
-          mood: 'excited',
-          energy: 0.9,
-          friendliness: 1.0,
-          playfulness: 0.95,
-        },
-        appearance: {
-          baseColor: '#FFB6C1',
-          accentColor: '#FF69B4',
-          secondaryColor: '#FFF',
-          accessories: [
-            { id: 'bow', type: 'bow', color: '#FF69B4', visible: true },
-          ],
-          style: 'cartoon',
-          scale: 1,
-        },
-        animations: this._getDefaultAnimations(),
-        interactive: true,
-        touchEnabled: true,
-        soundEnabled: false,
-      },
-      'wise-owl': {
-        id: 'wise-owl',
-        name: 'Wise Owl',
-        type: 'lottie',
-        personality: {
-          mood: 'thinking',
-          energy: 0.4,
-          friendliness: 0.7,
-          playfulness: 0.3,
-        },
-        appearance: {
-          baseColor: '#8B4513',
-          accentColor: '#DAA520',
-          accessories: [
-            { id: 'glasses', type: 'glasses', visible: true },
-          ],
-          style: 'realistic',
-          scale: 1,
-        },
-        animations: this._getDefaultAnimations(),
-        interactive: true,
-        touchEnabled: true,
-        soundEnabled: false,
-      },
-      'pixel-hero': {
-        id: 'pixel-hero',
-        name: 'Pixel Hero',
-        type: 'svg',
-        personality: {
-          mood: 'happy',
-          energy: 0.85,
-          friendliness: 0.75,
-          playfulness: 0.8,
-        },
-        appearance: {
-          baseColor: '#3498DB',
-          accentColor: '#E74C3C',
-          secondaryColor: '#F1C40F',
-          accessories: [
-            { id: 'crown', type: 'crown', color: '#F1C40F', visible: true },
-          ],
-          style: 'pixel',
-          scale: 1,
-        },
-        animations: this._getDefaultAnimations(),
-        interactive: true,
-        touchEnabled: true,
-        soundEnabled: false,
-      },
-    };
-
-    return templates[template];
+  /**
+   * Get a builder for fluent mascot creation
+   */
+  static builder(): MascotBuilder {
+    return new MascotBuilder();
   }
 
+  /**
+   * Merge base config with customizations
+   */
   private static _mergeConfigs(
     base: MascotConfig,
     custom?: Partial<MascotConfig>
@@ -189,51 +84,4 @@ export class MascotFactory {
       animations: custom.animations || base.animations,
     };
   }
-
-  private static _getDefaultAnimations() {
-    return [
-      {
-        id: 'idle',
-        name: 'Idle',
-        type: 'idle' as const,
-        source: 'idle.json',
-        loop: true,
-        autoplay: true,
-      },
-      {
-        id: 'wave',
-        name: 'Wave',
-        type: 'action' as const,
-        source: 'wave.json',
-        loop: false,
-      },
-      {
-        id: 'jump',
-        name: 'Jump',
-        type: 'action' as const,
-        source: 'jump.json',
-        loop: false,
-      },
-      {
-        id: 'success',
-        name: 'Success',
-        type: 'reaction' as const,
-        source: 'success.json',
-        loop: false,
-      },
-      {
-        id: 'error',
-        name: 'Error',
-        type: 'reaction' as const,
-        source: 'error.json',
-        loop: false,
-      },
-    ];
-  }
 }
-
-export type MascotTemplate =
-  | 'friendly-bot'
-  | 'cute-pet'
-  | 'wise-owl'
-  | 'pixel-hero';

package/src/infrastructure/managers/MascotTemplates.ts

@@ -0,0 +1,151 @@
+/**
+ * Mascot Templates (100 lines)
+ * Predefined mascot template configurations
+ */
+
+import type { MascotConfig } from '../../domain/types/MascotTypes';
+import type { MascotTemplate } from './MascotFactory';
+
+export function getTemplateConfig(template: MascotTemplate): MascotConfig {
+  const templates: Record<MascotTemplate, MascotConfig> = {
+    'friendly-bot': {
+      id: 'friendly-bot',
+      name: 'Friendly Bot',
+      type: 'lottie',
+      personality: {
+        mood: 'happy',
+        energy: 0.8,
+        friendliness: 0.9,
+        playfulness: 0.7,
+      },
+      appearance: {
+        baseColor: '#4A90E2',
+        accentColor: '#50E3C2',
+        accessories: [],
+        style: 'cartoon',
+        scale: 1,
+      },
+      animations: getDefaultAnimations(),
+      interactive: true,
+      touchEnabled: true,
+      soundEnabled: false,
+    },
+    'cute-pet': {
+      id: 'cute-pet',
+      name: 'Cute Pet',
+      type: 'svg',
+      personality: {
+        mood: 'excited',
+        energy: 0.9,
+        friendliness: 1.0,
+        playfulness: 0.95,
+      },
+      appearance: {
+        baseColor: '#FFB6C1',
+        accentColor: '#FF69B4',
+        secondaryColor: '#FFF',
+        accessories: [
+          { id: 'bow', type: 'bow', color: '#FF69B4', visible: true },
+        ],
+        style: 'cartoon',
+        scale: 1,
+      },
+      animations: getDefaultAnimations(),
+      interactive: true,
+      touchEnabled: true,
+      soundEnabled: false,
+    },
+    'wise-owl': {
+      id: 'wise-owl',
+      name: 'Wise Owl',
+      type: 'lottie',
+      personality: {
+        mood: 'thinking',
+        energy: 0.4,
+        friendliness: 0.7,
+        playfulness: 0.3,
+      },
+      appearance: {
+        baseColor: '#8B4513',
+        accentColor: '#DAA520',
+        accessories: [
+          { id: 'glasses', type: 'glasses', visible: true },
+        ],
+        style: 'realistic',
+        scale: 1,
+      },
+      animations: getDefaultAnimations(),
+      interactive: true,
+      touchEnabled: true,
+      soundEnabled: false,
+    },
+    'pixel-hero': {
+      id: 'pixel-hero',
+      name: 'Pixel Hero',
+      type: 'svg',
+      personality: {
+        mood: 'happy',
+        energy: 0.85,
+        friendliness: 0.75,
+        playfulness: 0.8,
+      },
+      appearance: {
+        baseColor: '#3498DB',
+        accentColor: '#E74C3C',
+        secondaryColor: '#F1C40F',
+        accessories: [
+          { id: 'crown', type: 'crown', color: '#F1C40F', visible: true },
+        ],
+        style: 'pixel',
+        scale: 1,
+      },
+      animations: getDefaultAnimations(),
+      interactive: true,
+      touchEnabled: true,
+      soundEnabled: false,
+    },
+  };
+
+  return templates[template];
+}
+
+export function getDefaultAnimations() {
+  return [
+    {
+      id: 'idle',
+      name: 'Idle',
+      type: 'idle' as const,
+      source: 'idle.json',
+      loop: true,
+      autoplay: true,
+    },
+    {
+      id: 'wave',
+      name: 'Wave',
+      type: 'action' as const,
+      source: 'wave.json',
+      loop: false,
+    },
+    {
+      id: 'jump',
+      name: 'Jump',
+      type: 'action' as const,
+      source: 'jump.json',
+      loop: false,
+    },
+    {
+      id: 'success',
+      name: 'Success',
+      type: 'reaction' as const,
+      source: 'success.json',
+      loop: false,
+    },
+    {
+      id: 'error',
+      name: 'Error',
+      type: 'reaction' as const,
+      source: 'error.json',
+      loop: false,
+    },
+  ];
+}

package/src/infrastructure/utils/LRUCache.ts

@@ -0,0 +1,218 @@
+/**
+ * LRU (Least Recently Used) Cache Entry
+ * Efficient cache implementation with O(1) operations
+ */
+
+interface LRUNode<K, V> {
+  key: K;
+  value: V;
+  prev: LRUNode<K, V> | null;
+  next: LRUNode<K, V> | null;
+}
+
+/**
+ * LRU Cache implementation
+ * Provides O(1) get/set operations with automatic eviction
+ */
+export class LRUCache<K, V> {
+  private capacity: number;
+  private cache: Map<K, LRUNode<K, V>>;
+  private head: LRUNode<K, V> | null;
+  private tail: LRUNode<K, V> | null;
+  private _size: number;
+
+  constructor(capacity: number) {
+    this.capacity = capacity;
+    this.cache = new Map();
+    this.head = null;
+    this.tail = null;
+    this._size = 0;
+  }
+
+  /**
+   * Get value by key and move to front (most recently used)
+   */
+  get(key: K): V | undefined {
+    const node = this.cache.get(key);
+    if (!node) {
+      return undefined;
+    }
+
+    // Move to front (most recently used)
+    this.moveToFront(node);
+    return node.value;
+  }
+
+  /**
+   * Set value and evict least recently used if at capacity
+   */
+  set(key: K, value: V): void {
+    const existingNode = this.cache.get(key);
+
+    if (existingNode) {
+      // Update existing node
+      existingNode.value = value;
+      this.moveToFront(existingNode);
+      return;
+    }
+
+    // Create new node
+    const newNode: LRUNode<K, V> = {
+      key,
+      value,
+      prev: null,
+      next: null,
+    };
+
+    // Add to cache
+    this.cache.set(key, newNode);
+    this.addToFront(newNode);
+    this._size++;
+
+    // Evict if at capacity
+    if (this._size > this.capacity) {
+      this.removeLeastRecentlyUsed();
+    }
+  }
+
+  /**
+   * Check if key exists
+   */
+  has(key: K): boolean {
+    return this.cache.has(key);
+  }
+
+  /**
+   * Delete specific key
+   */
+  delete(key: K): boolean {
+    const node = this.cache.get(key);
+    if (!node) {
+      return false;
+    }
+
+    this.removeNode(node);
+    this.cache.delete(key);
+    this._size--;
+    return true;
+  }
+
+  /**
+   * Clear all entries
+   */
+  clear(): void {
+    this.cache.clear();
+    this.head = null;
+    this.tail = null;
+    this._size = 0;
+  }
+
+  /**
+   * Get current size
+   */
+  size(): number {
+    return this._size;
+  }
+
+  /**
+   * Get all keys in order (most recent to least recent)
+   */
+  keys(): K[] {
+    const keys: K[] = [];
+    let current = this.head;
+    while (current) {
+      keys.push(current.key);
+      current = current.next;
+    }
+    return keys;
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getStats(): { size: number; capacity: number; usage: number } {
+    return {
+      size: this._size,
+      capacity: this.capacity,
+      usage: this._size / this.capacity,
+    };
+  }
+
+  /**
+   * Add node to front of list (most recently used)
+   */
+  private addToFront(node: LRUNode<K, V>): void {
+    node.prev = null;
+    node.next = this.head;
+
+    if (this.head) {
+      this.head.prev = node;
+    }
+
+    this.head = node;
+
+    if (!this.tail) {
+      this.tail = node;
+    }
+  }
+
+  /**
+   * Move existing node to front
+   */
+  private moveToFront(node: LRUNode<K, V>): void {
+    if (node === this.head) {
+      return;
+    }
+
+    // Remove node from current position
+    this.removeNode(node);
+
+    // Add to front
+    node.prev = null;
+    node.next = this.head;
+
+    if (this.head) {
+      this.head.prev = node;
+    }
+
+    this.head = node;
+
+    // If node was tail, update tail
+    if (this.tail === null) {
+      this.tail = node;
+    } else if (this.tail.prev === node) {
+      this.tail = node;
+    }
+  }
+
+  /**
+   * Remove node from list (without deleting from cache)
+   */
+  private removeNode(node: LRUNode<K, V>): void {
+    if (node.prev) {
+      node.prev.next = node.next;
+    } else {
+      this.head = node.next;
+    }
+
+    if (node.next) {
+      node.next.prev = node.prev;
+    } else {
+      this.tail = node.prev;
+    }
+  }
+
+  /**
+   * Remove least recently used (tail) node
+   */
+  private removeLeastRecentlyUsed(): void {
+    if (!this.tail) {
+      return;
+    }
+
+    const lruKey = this.tail.key;
+    this.removeNode(this.tail);
+    this.cache.delete(lruKey);
+    this._size--;
+  }
+}

package/src/infrastructure.ts

@@ -0,0 +1,24 @@
+/**
+ * Infrastructure Layer Exports (60 lines)
+ * Controllers, repositories, managers, and utilities
+ */
+
+// Infrastructure - DI
+export { DIContainer } from './infrastructure/di/Container';
+
+// Infrastructure - Repositories
+export { MascotRepository } from './infrastructure/repositories/MascotRepository';
+
+// Infrastructure - Controllers
+export { AnimationController } from './infrastructure/controllers/AnimationController';
+export { AnimationPlayer } from './infrastructure/controllers/AnimationPlayer';
+export { EventManager } from './infrastructure/controllers/EventManager';
+export { AnimationTimer } from './infrastructure/controllers/AnimationTimer';
+
+// Infrastructure - Managers
+export { AssetManager } from './infrastructure/managers/AssetManager';
+export { MascotFactory, type MascotTemplate as FactoryMascotTemplate } from './infrastructure/managers/MascotFactory';
+export { MascotBuilder } from './infrastructure/managers/MascotBuilder';
+
+// Infrastructure - Utils
+export { LRUCache } from './infrastructure/utils/LRUCache';

package/src/presentation/components/LottieMascot.tsx

@@ -0,0 +1,85 @@
+/**
+ * Lottie Mascot Component (80 lines)
+ * Lottie-specific rendering with auto-play and caching
+ */
+
+import React, { memo, useMemo, useRef, useEffect } from 'react';
+import { View, ViewStyle } from 'react-native';
+import LottieView from 'lottie-react-native';
+import type { AnimationObject } from 'lottie-react-native';
+import type { Mascot } from '../../domain/entities/Mascot';
+import type { MascotAnimation } from '../../domain/types/MascotTypes';
+
+type LottieAnimationSource = string | AnimationObject | { uri: string };
+
+export interface LottieMascotProps {
+  mascot: Mascot;
+  animation?: MascotAnimation | null;
+  resizeMode?: 'cover' | 'contain' | 'center';
+  onAnimationFinish?: () => void;
+}
+
+const LottieMascotComponent: React.FC<LottieMascotProps> = memo(({
+  mascot,
+  animation,
+  resizeMode = 'contain',
+  onAnimationFinish,
+}) => {
+  const lottieRef = useRef<LottieView>(null);
+
+  // Memoize source to prevent reloads
+  const source = useMemo(() => {
+    return animation?.source || mascot.animations.find((a: MascotAnimation) => a.type === 'idle')?.source;
+  }, [animation?.source, mascot.animations]);
+
+  // Play animation when source changes
+  useEffect(() => {
+    if (source && lottieRef.current) {
+      lottieRef.current.play();
+    }
+  }, [source]);
+
+  if (!source) {
+    return (
+      <FallbackMascot
+        mascot={mascot}
+        size={0}
+        style={{ width: '100%', height: '100%', backgroundColor: mascot.appearance.baseColor }}
+      />
+    );
+  }
+
+  return (
+    <LottieView
+      ref={lottieRef}
+      source={source as LottieAnimationSource}
+      style={{ width: '100%', height: '100%' }}
+      resizeMode={resizeMode}
+      autoPlay={animation?.autoplay}
+      loop={animation?.loop}
+      onAnimationFinish={onAnimationFinish}
+    />
+  );
+});
+
+LottieMascotComponent.displayName = 'LottieMascot';
+
+export const LottieMascot = LottieMascotComponent;
+
+// Fallback component for when no source is available
+interface FallbackMascotProps {
+  mascot: Mascot;
+  size?: number;
+  style?: ViewStyle;
+}
+
+const FallbackMascotComponent: React.FC<FallbackMascotProps> = ({ mascot, style }) => (
+  <View style={[{ backgroundColor: mascot.appearance.baseColor, borderRadius: 100, justifyContent: 'center', alignItems: 'center' }, style]}>
+    <View style={{ width: 10, height: 10, backgroundColor: '#000', borderRadius: 5, top: '40%', position: 'absolute' }} />
+    <View style={{ width: 10, height: 10, backgroundColor: '#000', borderRadius: 5, top: '40%', position: 'absolute' }} />
+  </View>
+);
+
+FallbackMascotComponent.displayName = 'FallbackMascot';
+
+export const FallbackMascot = memo(FallbackMascotComponent);