@umituz/react-native-mascot 1.0.1

package/src/assets/index.ts

@@ -0,0 +1,104 @@
+/**
+ * Built-in Mascot Assets
+ * Pre-configured mascots and animations
+ */
+
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import type { MascotConfig, MascotAnimationType } 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');
+
+export const BUILT_IN_MASCOTS: Record<string, MascotConfig> = {
+  'happy-robot': {
+    id: 'happy-robot',
+    name: 'Happy Robot',
+    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: [
+      {
+        id: 'idle',
+        name: 'Idle',
+        type: 'idle' as MascotAnimationType,
+        source: idleAnim,
+        loop: true,
+        autoplay: true,
+      },
+      {
+        id: 'wave',
+        name: 'Wave',
+        type: 'action' as MascotAnimationType,
+        source: waveAnim,
+        loop: false,
+      },
+      {
+        id: 'jump',
+        name: 'Jump',
+        type: 'action' as MascotAnimationType,
+        source: jumpAnim,
+        loop: false,
+      },
+      {
+        id: 'success',
+        name: 'Success',
+        type: 'reaction' as MascotAnimationType,
+        source: successAnim,
+        loop: false,
+      },
+      {
+        id: 'error',
+        name: 'Error',
+        type: 'reaction' as MascotAnimationType,
+        source: errorAnim,
+        loop: false,
+      },
+      {
+        id: 'dance',
+        name: 'Dance',
+        type: 'action' as MascotAnimationType,
+        source: danceAnim,
+        loop: true,
+      },
+    ],
+    interactive: true,
+    touchEnabled: true,
+    soundEnabled: false,
+  },
+};
+
+// Helper function to get built-in mascot
+export function getBuiltInMascot(id: string): MascotConfig | undefined {
+  return BUILT_IN_MASCOTS[id];
+}
+
+// Helper function to get all built-in mascot IDs
+export function getBuiltInMascotIds(): string[] {
+  return Object.keys(BUILT_IN_MASCOTS);
+}
+
+// Helper function to check if mascot is built-in
+export function isBuiltInMascot(id: string): boolean {
+  return id in BUILT_IN_MASCOTS;
+}

package/src/domain/entities/Mascot.ts

@@ -0,0 +1,216 @@
+/**
+ * Mascot Entity
+ * Core mascot representation following DDD principles
+ */
+
+import type {
+  MascotConfig,
+  MascotPersonality,
+  MascotAppearance,
+  MascotAnimation,
+  MascotState,
+  MascotType,
+  MascotMood,
+  MascotAccessory,
+} from '../types/MascotTypes';
+
+export class Mascot {
+  readonly id: string;
+  readonly name: string;
+  readonly type: MascotType;
+  private _personality: MascotPersonality;
+  private _appearance: MascotAppearance;
+  private readonly _animations: Map<string, MascotAnimation>;
+  private readonly _config: MascotConfig;
+  private _state: MascotState;
+  private _interactions: Map<string, () => void | Promise<void>>;
+
+  constructor(config: MascotConfig) {
+    this.id = config.id;
+    this.name = config.name;
+    this.type = config.type;
+    this._personality = config.personality;
+    this._appearance = config.appearance;
+    this._animations = new Map(
+      config.animations.map((anim) => [anim.id, anim])
+    );
+    this._config = config;
+    this._state = {
+      currentMood: config.personality.mood,
+      currentAnimation: null,
+      isAnimating: false,
+      isVisible: true,
+    };
+    this._interactions = new Map();
+  }
+
+  // Getters
+  get personality(): MascotPersonality {
+    return { ...this._personality };
+  }
+
+  get appearance(): MascotAppearance {
+    return { ...this._appearance };
+  }
+
+  get state(): MascotState {
+    return { ...this._state };
+  }
+
+  get config(): MascotConfig {
+    return { ...this._config };
+  }
+
+  get animations(): MascotAnimation[] {
+    return Array.from(this._animations.values());
+  }
+
+  get interactive(): boolean {
+    return this._config.interactive ?? false;
+  }
+
+  get touchEnabled(): boolean {
+    return this._config.touchEnabled ?? true;
+  }
+
+  get soundEnabled(): boolean {
+    return this._config.soundEnabled ?? false;
+  }
+
+  // Personality Management
+  setMood(mood: MascotMood): void {
+    this._personality.mood = 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;
+  }
+
+  setFriendliness(friendliness: number): void {
+    if (friendliness < 0 || friendliness > 1) {
+      throw new Error('Friendliness must be between 0 and 1');
+    }
+    this._personality.friendliness = friendliness;
+  }
+
+  setPlayfulness(playfulness: number): void {
+    if (playfulness < 0 || playfulness > 1) {
+      throw new Error('Playfulness must be between 0 and 1');
+    }
+    this._personality.playfulness = playfulness;
+  }
+
+  // Appearance Management
+  updateAppearance(appearance: Partial<MascotAppearance>): void {
+    this._appearance = {
+      ...this._appearance,
+      ...appearance,
+      accessories: appearance.accessories ?? this._appearance.accessories,
+    };
+  }
+
+  setBaseColor(color: string): void {
+    this._appearance.baseColor = color;
+  }
+
+  setAccentColor(color: string): void {
+    this._appearance.accentColor = color;
+  }
+
+  addAccessory(accessory: {
+    id: string;
+    type: string;
+    color?: string;
+    position?: { x: number; y: number };
+  }): void {
+    const newAccessory: MascotAccessory = {
+      id: accessory.id,
+      type: accessory.type as MascotAccessory['type'],
+      color: accessory.color,
+      position: accessory.position,
+      visible: true,
+    };
+    this._appearance.accessories = [
+      ...this._appearance.accessories.filter((a) => a.id !== accessory.id),
+      newAccessory,
+    ];
+  }
+
+  removeAccessory(accessoryId: string): void {
+    this._appearance.accessories = this._appearance.accessories.filter(
+      (a) => a.id !== accessoryId
+    );
+  }
+
+  // Animation Management
+  getAnimation(animationId: string): MascotAnimation | undefined {
+    return this._animations.get(animationId);
+  }
+
+  getAnimationsByType(type: string): MascotAnimation[] {
+    return this.animations.filter((anim) => anim.type === type);
+  }
+
+  // State Management
+  startAnimation(animationId: string): void {
+    const animation = this._animations.get(animationId);
+    if (!animation) {
+      throw new Error(`Animation ${animationId} not found`);
+    }
+    this._state.currentAnimation = animationId;
+    this._state.isAnimating = true;
+  }
+
+  stopAnimation(): void {
+    this._state.isAnimating = false;
+    this._state.currentAnimation = null;
+  }
+
+  setVisible(visible: boolean): void {
+    this._state.isVisible = visible;
+  }
+
+  setPosition(position: { x: number; y: number }): void {
+    this._state.position = position;
+  }
+
+  // Interaction Management
+  registerInteraction(
+    id: string,
+    handler: () => void | Promise<void>
+  ): void {
+    this._interactions.set(id, handler);
+  }
+
+  unregisterInteraction(id: string): void {
+    this._interactions.delete(id);
+  }
+
+  async triggerInteraction(id: string): Promise<void> {
+    const handler = this._interactions.get(id);
+    if (handler) {
+      await handler();
+    }
+  }
+
+  // Utility Methods
+  clone(): Mascot {
+    return new Mascot(this._config);
+  }
+
+  toJSON(): object {
+    return {
+      id: this.id,
+      name: this.name,
+      type: this.type,
+      personality: this._personality,
+      appearance: this._appearance,
+      state: this._state,
+      config: this._config,
+    };
+  }
+}

package/src/domain/interfaces/IAnimationController.ts

@@ -0,0 +1,78 @@
+/**
+ * Animation Controller Interface
+ * Defines contract for animation playback control
+ */
+
+import type { MascotAnimation } from '../types/MascotTypes';
+
+export interface IAnimationController {
+  /**
+   * Play an animation
+   */
+  play(animation: MascotAnimation, options?: AnimationOptions): Promise<void>;
+
+  /**
+   * Pause current animation
+   */
+  pause(): void;
+
+  /**
+   * Resume paused animation
+   */
+  resume(): void;
+
+  /**
+   * Stop current animation
+   */
+  stop(): void;
+
+  /**
+   * Get current animation progress (0-1)
+   */
+  getProgress(): number;
+
+  /**
+   * Set animation progress (0-1)
+   */
+  setProgress(progress: number): void;
+
+  /**
+   * Set animation speed multiplier
+   */
+  setSpeed(speed: number): void;
+
+  /**
+   * Check if currently playing
+   */
+  isPlaying(): boolean;
+
+  /**
+   * Add event listener
+   */
+  on(
+    event: AnimationEvent,
+    callback: (data?: unknown) => void
+  ): () => void;
+
+  /**
+   * Remove event listener
+   */
+  off(event: AnimationEvent, callback: (data?: unknown) => void): void;
+}
+
+export type AnimationEvent =
+  | 'start'
+  | 'finish'
+  | 'pause'
+  | 'resume'
+  | 'progress'
+  | 'error';
+
+export interface AnimationOptions {
+  speed?: number;
+  loop?: boolean;
+  autoplay?: boolean;
+  onStart?: () => void;
+  onFinish?: () => void;
+  onError?: (error: Error) => void;
+}

package/src/domain/interfaces/IAssetManager.ts

@@ -0,0 +1,51 @@
+/**
+ * Asset Manager Interface
+ * Defines contract for loading and managing mascot assets
+ */
+
+import type { MascotAnimation } from '../types/MascotTypes';
+
+export interface IAssetManager {
+  /**
+   * Load a Lottie animation
+   */
+  loadLottieAnimation(source: string | object): Promise<MascotAnimation>;
+
+  /**
+   * Load an SVG asset
+   */
+  loadSVGAsset(source: string): Promise<string>;
+
+  /**
+   * Preload multiple animations
+   */
+  preloadAnimations(sources: Array<string | object>): Promise<void>;
+
+  /**
+   * Clear cached assets
+   */
+  clearCache(): void;
+
+  /**
+   * Get asset URL or path
+   */
+  getAssetUrl(assetId: string): string | null;
+
+  /**
+   * Check if asset is loaded
+   */
+  isAssetLoaded(assetId: string): boolean;
+
+  /**
+   * Get all loaded assets
+   */
+  getLoadedAssets(): string[];
+}
+
+export interface AssetCache {
+  [key: string]: {
+    data: unknown;
+    timestamp: number;
+    size: number;
+  };
+}

package/src/domain/interfaces/IMascotRepository.ts

@@ -0,0 +1,39 @@
+/**
+ * Mascot Repository Interface
+ * Defines contract for mascot data persistence and retrieval
+ */
+
+import type { Mascot } from '../entities/Mascot';
+import type { MascotConfig } from '../types/MascotTypes';
+
+export interface IMascotRepository {
+  /**
+   * Save a mascot configuration
+   */
+  save(config: MascotConfig): Promise<void>;
+
+  /**
+   * Load a mascot by ID
+   */
+  load(id: string): Promise<Mascot | null>;
+
+  /**
+   * Load all mascots
+   */
+  loadAll(): Promise<Mascot[]>;
+
+  /**
+   * Delete a mascot
+   */
+  delete(id: string): Promise<void>;
+
+  /**
+   * Update mascot configuration
+   */
+  update(id: string, config: Partial<MascotConfig>): Promise<void>;
+
+  /**
+   * Check if mascot exists
+   */
+  exists(id: string): Promise<boolean>;
+}

package/src/domain/types/MascotTypes.ts

@@ -0,0 +1,75 @@
+/**
+ * Mascot Types
+ * Core type definitions for the mascot system
+ */
+
+export type MascotType = 'lottie' | 'svg' | 'custom';
+
+export type MascotStyle = 'minimal' | 'cartoon' | 'realistic' | 'pixel';
+
+export type MascotMood = 'happy' | 'sad' | 'excited' | 'thinking' | 'angry' | 'neutral' | 'surprised';
+
+export type MascotAnimationType = 'idle' | 'action' | 'reaction' | 'transition';
+
+export type AnimationSpeed = 'very-slow' | 'slow' | 'normal' | 'fast' | 'very-fast';
+
+export interface MascotAppearance {
+  baseColor: string;
+  accentColor: string;
+  secondaryColor?: string;
+  accessories: MascotAccessory[];
+  style: MascotStyle;
+  scale?: number;
+}
+
+export interface MascotAccessory {
+  id: string;
+  type: 'glasses' | 'hat' | 'bow' | 'crown' | 'headphones' | 'mask' | 'custom';
+  color?: string;
+  position?: { x: number; y: number };
+  visible?: boolean;
+}
+
+export interface MascotPersonality {
+  mood: MascotMood;
+  energy: number; // 0-1
+  friendliness: number; // 0-1
+  playfulness: number; // 0-1
+}
+
+export interface MascotAnimation {
+  id: string;
+  name: string;
+  type: MascotAnimationType;
+  source: string | object;
+  loop: boolean;
+  duration?: number;
+  speed?: number;
+  autoplay?: boolean;
+}
+
+export interface MascotConfig {
+  id: string;
+  name: string;
+  type: MascotType;
+  personality: MascotPersonality;
+  appearance: MascotAppearance;
+  animations: MascotAnimation[];
+  interactive?: boolean;
+  touchEnabled?: boolean;
+  soundEnabled?: boolean;
+}
+
+export interface MascotState {
+  currentMood: MascotMood;
+  currentAnimation: string | null;
+  isAnimating: boolean;
+  isVisible: boolean;
+  position?: { x: number; y: number };
+}
+
+export interface MascotInteraction {
+  type: 'tap' | 'longPress' | 'drag' | 'pinch' | 'custom';
+  handler: () => void | Promise<void>;
+  animation?: string;
+}

package/src/index.ts

@@ -0,0 +1,99 @@
+/**
+ * @umituz/react-native-mascot
+ *
+ * Interactive mascot system for React Native apps
+ */
+
+import type { MascotMood, AnimationSpeed } from './domain/types/MascotTypes';
+
+// Domain - Entities
+export { Mascot } from './domain/entities/Mascot';
+
+// 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';
+
+// 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 } 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';
+
+// Constants
+export const MASCOT_TEMPLATES = [
+  'friendly-bot',
+  'cute-pet',
+  'wise-owl',
+  'pixel-hero',
+] as const;
+
+export const DEFAULT_MASCOT_MOODS: MascotMood[] = [
+  'happy',
+  'sad',
+  'excited',
+  'thinking',
+  'angry',
+  'neutral',
+  'surprised',
+];
+
+export const DEFAULT_ANIMATION_SPEEDS: AnimationSpeed[] = [
+  'very-slow',
+  'slow',
+  'normal',
+  'fast',
+  'very-fast',
+];