react-native-games 1.1.0 → 1.3.0

package/lib/module/helpers/AnimationFrame.js

@@ -1,120 +1 @@
-"use strict";
-
-import { useEffect, useRef } from 'react';
-
-/**
- * Optimized animation frame utility for smooth game object cleanup and updates
- * Uses requestAnimationFrame instead of setInterval for better performance
- */
-export class AnimationFrameManager {
-  animationId = null;
-  isRunning = false;
-  lastTime = 0;
-  constructor(callback, interval = 100) {
-    this.callback = callback;
-    this.interval = interval;
-  }
-
-  /**
-   * Start the animation frame loop
-   */
-  start() {
-    if (this.isRunning) return;
-    this.isRunning = true;
-    this.lastTime = performance.now();
-    this.loop();
-  }
-
-  /**
-   * Stop the animation frame loop
-   */
-  stop() {
-    if (this.animationId) {
-      cancelAnimationFrame(this.animationId);
-      this.animationId = null;
-    }
-    this.isRunning = false;
-  }
-
-  /**
-   * Internal animation frame loop
-   */
-  loop = () => {
-    if (!this.isRunning) return;
-    const currentTime = performance.now();
-    const deltaTime = currentTime - this.lastTime;
-    if (deltaTime >= this.interval) {
-      this.callback();
-      this.lastTime = currentTime;
-    }
-    this.animationId = requestAnimationFrame(this.loop);
-  };
-
-  /**
-   * Update the callback function
-   */
-  updateCallback(callback) {
-    this.callback = callback;
-  }
-
-  /**
-   * Update the interval
-   */
-  updateInterval(interval) {
-    this.interval = interval;
-  }
-}
-
-/**
- * React hook for using optimized animation frame cleanup
- */
-export function useAnimationFrame(callback, interval = 100, dependencies = []) {
-  const managerRef = useRef(null);
-  useEffect(() => {
-    // Create or update the manager
-    if (!managerRef.current) {
-      managerRef.current = new AnimationFrameManager(callback, interval);
-    } else {
-      managerRef.current.updateCallback(callback);
-      managerRef.current.updateInterval(interval);
-    }
-
-    // Start the animation frame loop
-    managerRef.current.start();
-
-    // Cleanup on unmount or dependency change
-    return () => {
-      if (managerRef.current) {
-        managerRef.current.stop();
-      }
-    };
-  }, dependencies);
-
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      if (managerRef.current) {
-        managerRef.current.stop();
-      }
-    };
-  }, []);
-}
-
-/**
- * React hook for creating a reusable animation frame manager
- */
-export function useAnimationFrameManager(interval = 100) {
-  const managerRef = useRef(null);
-  if (!managerRef.current) {
-    managerRef.current = new AnimationFrameManager(() => {}, interval);
-  }
-  useEffect(() => {
-    return () => {
-      if (managerRef.current) {
-        managerRef.current.stop();
-      }
-    };
-  }, []);
-  return managerRef.current;
-}
-//# sourceMappingURL=AnimationFrame.js.map
+"use strict";import{useEffect,useRef}from 'react';export class AnimationFrameManager{animationId = null;isRunning = false;lastTime = 0;constructor(callback,interval = 100){this.callback = callback;this.interval = interval;}start(){if(this.isRunning)return;this.isRunning = true;this.lastTime = performance.now();this.loop();}stop(){if(this.animationId){cancelAnimationFrame(this.animationId);this.animationId = null;}this.isRunning = false;}loop =()=>{if(!this.isRunning)return;const currentTime = performance.now();const deltaTime = currentTime - this.lastTime;if(deltaTime >= this.interval){this.callback();this.lastTime = currentTime;}this.animationId = requestAnimationFrame(this.loop);};updateCallback(callback){this.callback = callback;}updateInterval(interval){this.interval = interval;}}export function useAnimationFrame(callback,interval = 100,dependencies = []){const managerRef = useRef(null);useEffect(()=>{if(!managerRef.current){managerRef.current = new AnimationFrameManager(callback,interval);}else{managerRef.current.updateCallback(callback);managerRef.current.updateInterval(interval);}managerRef.current.start();return()=>{if(managerRef.current){managerRef.current.stop();}};},dependencies);useEffect(()=>{return()=>{if(managerRef.current){managerRef.current.stop();}};},[]);}export function useAnimationFrameManager(interval = 100){const managerRef = useRef(null);if(!managerRef.current){managerRef.current = new AnimationFrameManager(()=>{},interval);}useEffect(()=>{return()=>{if(managerRef.current){managerRef.current.stop();}};},[]);return managerRef.current;}

package/lib/module/helpers/AnimationTracker.js

@@ -1,89 +1 @@
-"use strict";
-
-import { useRef } from 'react';
-
-/**
- * Animation state interface for tracking game object animations
- */
-
-/**
- * Default animation state values
- */
-export const DEFAULT_ANIMATION_STATE = {
-  scale: 1,
-  opacity: 1,
-  rotation: 0,
-  translateX: 0,
-  translateY: 0
-};
-
-/**
- * Animation tracker class for managing game object animations
- * Extends Map to maintain compatibility with existing game services
- */
-export class AnimationTracker extends Map {
-  constructor() {
-    super();
-  }
-
-  /**
-   * Override set to merge with default animation state
-   */
-  set(id, state) {
-    const currentState = super.get(id) || {
-      ...DEFAULT_ANIMATION_STATE
-    };
-    const newState = {
-      ...currentState,
-      ...state
-    };
-    super.set(id, newState);
-    return this;
-  }
-
-  /**
-   * Initialize animation for object if it doesn't exist
-   */
-  initialize(id, initialState) {
-    if (!this.has(id)) {
-      const state = {
-        ...DEFAULT_ANIMATION_STATE,
-        ...initialState
-      };
-      super.set(id, state);
-      return state;
-    }
-    return this.get(id);
-  }
-
-  /**
-   * Update multiple objects at once
-   */
-  updateBatch(updates) {
-    updates.forEach(({
-      id,
-      state
-    }) => {
-      this.set(id, state);
-    });
-  }
-}
-
-/**
- * React hook for creating and managing animation trackers
- */
-export function useAnimationTracker() {
-  return useRef(new AnimationTracker()).current;
-}
-
-/**
- * React hook for creating multiple animation trackers
- */
-export function useAnimationTrackers(trackerNames) {
-  const trackers = useRef(trackerNames.reduce((acc, name) => {
-    acc[name] = new AnimationTracker();
-    return acc;
-  }, {})).current;
-  return trackers;
-}
-//# sourceMappingURL=AnimationTracker.js.map
+"use strict";import{useRef}from 'react';export const DEFAULT_ANIMATION_STATE ={scale:1,opacity:1,rotation:0,translateX:0,translateY:0};export class AnimationTracker extends Map{constructor(){super();}set(id,state){const currentState = super.get(id)||{...DEFAULT_ANIMATION_STATE};const newState ={...currentState,...state};super.set(id,newState);return this;}initialize(id,initialState){if(!this.has(id)){const state ={...DEFAULT_ANIMATION_STATE,...initialState};super.set(id,state);return state;}return this.get(id);}updateBatch(updates){updates.forEach(({id,state})=>{this.set(id,state);});}}export function useAnimationTracker(){return useRef(new AnimationTracker()).current;}export function useAnimationTrackers(trackerNames){const trackers = useRef(trackerNames.reduce((acc,name)=>{acc[name] = new AnimationTracker();return acc;},{})).current;return trackers;}

package/lib/module/helpers/ErrorHandler.js

@@ -1,269 +1 @@
-"use strict";
-
-import { useCallback, useRef } from 'react';
-
-/**
- * Error types for game-specific error handling
- */
-export let GameErrorType = /*#__PURE__*/function (GameErrorType) {
-  GameErrorType["INITIALIZATION_ERROR"] = "INITIALIZATION_ERROR";
-  GameErrorType["ANIMATION_ERROR"] = "ANIMATION_ERROR";
-  GameErrorType["STORAGE_ERROR"] = "STORAGE_ERROR";
-  GameErrorType["SOUND_ERROR"] = "SOUND_ERROR";
-  GameErrorType["HAPTIC_ERROR"] = "HAPTIC_ERROR";
-  GameErrorType["GESTURE_ERROR"] = "GESTURE_ERROR";
-  GameErrorType["PERFORMANCE_ERROR"] = "PERFORMANCE_ERROR";
-  GameErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";
-  GameErrorType["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-  return GameErrorType;
-}({});
-
-/**
- * Game error interface
- */
-
-/**
- * Error handler configuration
- */
-
-/**
- * Default error handler configuration
- */
-export const DEFAULT_ERROR_CONFIG = {
-  enableLogging: __DEV__,
-  enableConsoleOutput: __DEV__,
-  maxErrorHistory: 50,
-  enableCrashRecovery: true
-};
-
-/**
- * Game error handler class
- */
-export class GameErrorHandler {
-  errorHistory = [];
-  errorCounts = new Map();
-  constructor(config = {}) {
-    this.config = {
-      ...DEFAULT_ERROR_CONFIG,
-      ...config
-    };
-  }
-
-  /**
-   * Handle a game error
-   */
-  handleError(type, message, gameId, context) {
-    const error = {
-      type,
-      message,
-      gameId,
-      timestamp: Date.now(),
-      stack: new Error().stack,
-      context
-    };
-
-    // Add to error history
-    this.errorHistory.push(error);
-    if (this.errorHistory.length > this.config.maxErrorHistory) {
-      this.errorHistory.shift();
-    }
-
-    // Update error counts
-    const currentCount = this.errorCounts.get(type) || 0;
-    this.errorCounts.set(type, currentCount + 1);
-
-    // Log error if enabled
-    if (this.config.enableLogging && this.config.enableConsoleOutput) {
-      this.logError(error);
-    }
-
-    // Call custom error handler if provided
-    if (this.config.onError) {
-      try {
-        this.config.onError(error);
-      } catch (handlerError) {
-        console.error('Error in custom error handler:', handlerError);
-      }
-    }
-  }
-
-  /**
-   * Wrap a function with error handling
-   */
-  wrapFunction(fn, errorType, gameId) {
-    return (...args) => {
-      try {
-        const result = fn(...args);
-
-        // Handle async functions
-        if (result && typeof result.catch === 'function') {
-          return result.catch(error => {
-            this.handleError(errorType, error.message || 'Async function error', gameId, {
-              functionName: fn.name,
-              args
-            });
-            throw error;
-          });
-        }
-        return result;
-      } catch (error) {
-        this.handleError(errorType, error instanceof Error ? error.message : 'Unknown error', gameId, {
-          functionName: fn.name,
-          args
-        });
-        throw error;
-      }
-    };
-  }
-
-  /**
-   * Safe execution with error recovery
-   */
-  safeExecute(fn, fallback, errorType, gameId) {
-    try {
-      return fn();
-    } catch (error) {
-      this.handleError(errorType, error instanceof Error ? error.message : 'Safe execution failed', gameId, {
-        fallback
-      });
-      return fallback;
-    }
-  }
-
-  /**
-   * Safe async execution with error recovery
-   */
-  async safeExecuteAsync(fn, fallback, errorType, gameId) {
-    try {
-      return await fn();
-    } catch (error) {
-      this.handleError(errorType, error instanceof Error ? error.message : 'Safe async execution failed', gameId, {
-        fallback
-      });
-      return fallback;
-    }
-  }
-
-  /**
-   * Get error statistics
-   */
-  getErrorStats() {
-    const errorsByType = {};
-    for (const [type, count] of this.errorCounts.entries()) {
-      errorsByType[type] = count;
-    }
-    return {
-      totalErrors: this.errorHistory.length,
-      errorsByType,
-      recentErrors: this.errorHistory.slice(-10)
-    };
-  }
-
-  /**
-   * Clear error history
-   */
-  clearHistory() {
-    this.errorHistory = [];
-    this.errorCounts.clear();
-  }
-
-  /**
-   * Update configuration
-   */
-  updateConfig(config) {
-    this.config = {
-      ...this.config,
-      ...config
-    };
-  }
-
-  /**
-   * Log error to console
-   */
-  logError(error) {
-    const prefix = error.gameId ? `[${error.gameId}]` : '[Game]';
-    console.error(`${prefix} ${error.type}: ${error.message}`, {
-      timestamp: new Date(error.timestamp).toISOString(),
-      context: error.context,
-      stack: error.stack
-    });
-  }
-}
-
-/**
- * Global error handler instance
- */
-export const globalErrorHandler = new GameErrorHandler();
-
-/**
- * React hook for error handling in game components
- */
-export function useGameErrorHandler(gameId, config = {}) {
-  const handlerRef = useRef(null);
-
-  // Initialize handler
-  if (!handlerRef.current) {
-    handlerRef.current = new GameErrorHandler(config);
-  }
-  const handleError = useCallback((type, message, context) => {
-    handlerRef.current?.handleError(type, message, gameId, context);
-  }, [gameId]);
-  const wrapFunction = useCallback((fn, errorType) => {
-    return handlerRef.current?.wrapFunction(fn, errorType, gameId) || fn;
-  }, [gameId]);
-  const safeExecute = useCallback((fn, fallback, errorType) => {
-    return handlerRef.current?.safeExecute(fn, fallback, errorType, gameId) || fallback;
-  }, [gameId]);
-  const safeExecuteAsync = useCallback((fn, fallback, errorType) => {
-    return handlerRef.current?.safeExecuteAsync(fn, fallback, errorType, gameId) || Promise.resolve(fallback);
-  }, [gameId]);
-  return {
-    handleError,
-    wrapFunction,
-    safeExecute,
-    safeExecuteAsync,
-    errorStats: handlerRef.current?.getErrorStats() || {
-      totalErrors: 0,
-      errorsByType: {},
-      recentErrors: []
-    }
-  };
-}
-
-/**
- * Error boundary utility for wrapping functions with error handling
- */
-export function withErrorHandling(fn, gameId, errorType = GameErrorType.UNKNOWN_ERROR) {
-  return globalErrorHandler.wrapFunction(fn, errorType, gameId);
-}
-
-/**
- * Utility functions for common error scenarios
- */
-export const ErrorUtils = {
-  /**
-   * Handle animation errors safely
-   */
-  safeAnimate: (animationFn, gameId, fallback) => {
-    globalErrorHandler.safeExecute(animationFn, fallback ? fallback() : undefined, GameErrorType.ANIMATION_ERROR, gameId);
-  },
-  /**
-   * Handle sound errors safely
-   */
-  safePlaySound: (soundFn, gameId) => {
-    globalErrorHandler.safeExecute(soundFn, undefined, GameErrorType.SOUND_ERROR, gameId);
-  },
-  /**
-   * Handle haptic errors safely
-   */
-  safeHaptic: (hapticFn, gameId) => {
-    globalErrorHandler.safeExecute(hapticFn, undefined, GameErrorType.HAPTIC_ERROR, gameId);
-  },
-  /**
-   * Handle gesture errors safely
-   */
-  safeGesture: (gestureFn, gameId) => {
-    globalErrorHandler.safeExecute(gestureFn, undefined, GameErrorType.GESTURE_ERROR, gameId);
-  }
-};
-//# sourceMappingURL=ErrorHandler.js.map
+"use strict";import{useCallback,useRef}from 'react';export let GameErrorType = function(GameErrorType){GameErrorType["INITIALIZATION_ERROR"] = "INITIALIZATION_ERROR";GameErrorType["ANIMATION_ERROR"] = "ANIMATION_ERROR";GameErrorType["STORAGE_ERROR"] = "STORAGE_ERROR";GameErrorType["SOUND_ERROR"] = "SOUND_ERROR";GameErrorType["HAPTIC_ERROR"] = "HAPTIC_ERROR";GameErrorType["GESTURE_ERROR"] = "GESTURE_ERROR";GameErrorType["PERFORMANCE_ERROR"] = "PERFORMANCE_ERROR";GameErrorType["NETWORK_ERROR"] = "NETWORK_ERROR";GameErrorType["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";return GameErrorType;}({});export const DEFAULT_ERROR_CONFIG ={enableLogging:__DEV__,enableConsoleOutput:__DEV__,maxErrorHistory:50,enableCrashRecovery:true};export class GameErrorHandler{errorHistory = [];errorCounts = new Map();constructor(config ={}){this.config ={...DEFAULT_ERROR_CONFIG,...config};}handleError(type,message,gameId,context){const error ={type,message,gameId,timestamp:Date.now(),stack:new Error().stack,context};this.errorHistory.push(error);if(this.errorHistory.length > this.config.maxErrorHistory){this.errorHistory.shift();}const currentCount = this.errorCounts.get(type)|| 0;this.errorCounts.set(type,currentCount + 1);if(this.config.enableLogging && this.config.enableConsoleOutput){this.logError(error);}if(this.config.onError){try{this.config.onError(error);}catch(handlerError){console.error('Error in custom error handler:',handlerError);}}}wrapFunction(fn,errorType,gameId){return(...args)=>{try{const result = fn(...args);if(result && typeof result.catch === 'function'){return result.catch(error =>{this.handleError(errorType,error.message || 'Async function error',gameId,{functionName:fn.name,args});throw error;});}return result;}catch(error){this.handleError(errorType,error instanceof Error ? error.message:'Unknown error',gameId,{functionName:fn.name,args});throw error;}};}safeExecute(fn,fallback,errorType,gameId){try{return fn();}catch(error){this.handleError(errorType,error instanceof Error ? error.message:'Safe execution failed',gameId,{fallback});return fallback;}}async safeExecuteAsync(fn,fallback,errorType,gameId){try{return await fn();}catch(error){this.handleError(errorType,error instanceof Error ? error.message:'Safe async execution failed',gameId,{fallback});return fallback;}}getErrorStats(){const errorsByType ={};for(const [type,count] of this.errorCounts.entries()){errorsByType[type] = count;}return{totalErrors:this.errorHistory.length,errorsByType,recentErrors:this.errorHistory.slice(-10)};}clearHistory(){this.errorHistory = [];this.errorCounts.clear();}updateConfig(config){this.config ={...this.config,...config};}logError(error){const prefix = error.gameId ? `[${error.gameId}]`:'[Game]';console.error(`${prefix}${error.type}:${error.message}`,{timestamp:new Date(error.timestamp).toISOString(),context:error.context,stack:error.stack});}}export const globalErrorHandler = new GameErrorHandler();export function useGameErrorHandler(gameId,config ={}){const handlerRef = useRef(null);if(!handlerRef.current){handlerRef.current = new GameErrorHandler(config);}const handleError = useCallback((type,message,context)=>{handlerRef.current?.handleError(type,message,gameId,context);},[gameId]);const wrapFunction = useCallback((fn,errorType)=>{return handlerRef.current?.wrapFunction(fn,errorType,gameId)|| fn;},[gameId]);const safeExecute = useCallback((fn,fallback,errorType)=>{return handlerRef.current?.safeExecute(fn,fallback,errorType,gameId)|| fallback;},[gameId]);const safeExecuteAsync = useCallback((fn,fallback,errorType)=>{return handlerRef.current?.safeExecuteAsync(fn,fallback,errorType,gameId)|| Promise.resolve(fallback);},[gameId]);return{handleError,wrapFunction,safeExecute,safeExecuteAsync,errorStats:handlerRef.current?.getErrorStats()||{totalErrors:0,errorsByType:{},recentErrors:[]}};}export function withErrorHandling(fn,gameId,errorType = GameErrorType.UNKNOWN_ERROR){return globalErrorHandler.wrapFunction(fn,errorType,gameId);}export const ErrorUtils ={safeAnimate:(animationFn,gameId,fallback)=>{globalErrorHandler.safeExecute(animationFn,fallback ? fallback():undefined,GameErrorType.ANIMATION_ERROR,gameId);},safePlaySound:(soundFn,gameId)=>{globalErrorHandler.safeExecute(soundFn,undefined,GameErrorType.SOUND_ERROR,gameId);},safeHaptic:(hapticFn,gameId)=>{globalErrorHandler.safeExecute(hapticFn,undefined,GameErrorType.HAPTIC_ERROR,gameId);},safeGesture:(gestureFn,gameId)=>{globalErrorHandler.safeExecute(gestureFn,undefined,GameErrorType.GESTURE_ERROR,gameId);}};