react-achievements 3.7.0 → 3.9.0

package/dist/index.d.ts

@@ -1,20 +1,19 @@
 import React$1 from 'react';
+import * as achievements_engine from 'achievements-engine';
+import { ImportOptions, ImportResult, AchievementWithStatus as AchievementWithStatus$1, AchievementEngine, AchievementConfigurationType as AchievementConfigurationType$1, AchievementStorage as AchievementStorage$1, AsyncAchievementStorage as AsyncAchievementStorage$1, StorageType, RestApiStorageConfig, EventMapping, AchievementError } from 'achievements-engine';
+export { AchievementBuilder, AchievementEngine, AchievementEngineApi, AchievementError, AchievementUnlockedEvent, AsyncStorageAdapter, AwardDetails, ConfigurationError, EngineConfig, EngineEvent, ErrorEvent, EventMapping, ExportedData, ImportOptions, ImportResult, ImportValidationError, IndexedDBStorage, LocalStorage, MemoryStorage, MetricUpdatedEvent, MetricUpdater, OfflineQueueStorage, RestApiStorage, RestApiStorageConfig, StateChangedEvent, StorageError, StorageQuotaError, StorageType, SyncError, UnsubscribeFn, createConfigHash, exportAchievementData, importAchievementData, isAchievementError, isRecoverableError, isSimpleConfig, normalizeAchievements } from 'achievements-engine';
 
 /**
  * Notification component interface
  * Displays achievement unlock notifications
  */
 interface NotificationProps {
-    achievement: {
-        id: string;
-        title: string;
-        description: string;
-        icon: string;
-    };
+    achievement: AchievementWithStatus;
     onClose?: () => void;
     duration?: number;
     position?: NotificationPosition;
     theme?: string;
+    icons?: Record<string, string>;
 }
 type NotificationComponent = React$1.FC<NotificationProps>;
 /**
@@ -188,6 +187,21 @@ interface AsyncAchievementStorage {
 }
 type AnyAchievementStorage = AchievementStorage | AsyncAchievementStorage;
 declare function isAsyncStorage(storage: AnyAchievementStorage): storage is AsyncAchievementStorage;
+/**
+ * @deprecated This type is outdated and will be removed in v4.0.0.
+ * Use AchievementContextType from 'react-achievements' instead.
+ *
+ * This legacy interface does not include the 'engine' property.
+ *
+ * @example
+ * ```typescript
+ * // Old (deprecated)
+ * import { AchievementContextValue } from 'react-achievements';
+ *
+ * // New (recommended)
+ * import { AchievementContextType } from 'react-achievements';
+ * ```
+ */
 interface AchievementContextValue {
     updateMetrics: (metrics: AchievementMetrics | ((prev: AchievementMetrics) => AchievementMetrics)) => void;
     unlockedAchievements: string[];
@@ -222,232 +236,49 @@ interface AchievementProviderProps$1 {
     storage?: AchievementStorage;
     onAchievementUnlocked?: (achievement: AchievementDetails) => void;
 }
-declare enum StorageType {
-    Local = "local",// Synchronous localStorage
-    Memory = "memory",// Synchronous in-memory storage
-    IndexedDB = "indexeddb",// Asynchronous IndexedDB storage
-    RestAPI = "restapi"
-}
-
-declare class LocalStorage implements AchievementStorage {
-    private storageKey;
-    constructor(storageKey: string);
-    private serializeValue;
-    private deserializeValue;
-    private serializeMetrics;
-    private deserializeMetrics;
-    private getStorageData;
-    private setStorageData;
-    getMetrics(): AchievementMetrics;
-    setMetrics(metrics: AchievementMetrics): void;
-    getUnlockedAchievements(): string[];
-    setUnlockedAchievements(achievements: string[]): void;
-    clear(): void;
-}
-
-declare class MemoryStorage implements AchievementStorage {
-    private metrics;
-    private unlockedAchievements;
-    constructor();
-    getMetrics(): AchievementMetrics;
-    setMetrics(metrics: AchievementMetrics): void;
-    getUnlockedAchievements(): string[];
-    setUnlockedAchievements(achievements: string[]): void;
-    clear(): void;
-}
-
-/**
- * Base error class for all achievement-related errors
- */
-declare class AchievementError extends Error {
-    code: string;
-    recoverable: boolean;
-    remedy?: string | undefined;
-    constructor(message: string, code: string, recoverable: boolean, remedy?: string | undefined);
-}
-/**
- * Error thrown when browser storage quota is exceeded
- */
-declare class StorageQuotaError extends AchievementError {
-    bytesNeeded: number;
-    constructor(bytesNeeded: number);
-}
-/**
- * Error thrown when imported data fails validation
- */
-declare class ImportValidationError extends AchievementError {
-    validationErrors: string[];
-    constructor(validationErrors: string[]);
-}
-/**
- * Error thrown when storage operations fail
- */
-declare class StorageError extends AchievementError {
-    originalError?: Error | undefined;
-    constructor(message: string, originalError?: Error | undefined);
-}
-/**
- * Error thrown when configuration is invalid
- */
-declare class ConfigurationError extends AchievementError {
-    constructor(message: string);
-}
-/**
- * Error thrown when network sync operations fail
- */
-declare class SyncError extends AchievementError {
-    readonly statusCode?: number;
-    readonly timeout?: number;
-    constructor(message: string, details?: {
-        statusCode?: number;
-        timeout?: number;
-    });
-}
-/**
- * Type guard to check if an error is an AchievementError
- */
-declare function isAchievementError(error: unknown): error is AchievementError;
-/**
- * Type guard to check if an error is recoverable
- */
-declare function isRecoverableError(error: unknown): boolean;
 
-declare class AsyncStorageAdapter implements AchievementStorage {
-    private asyncStorage;
-    private cache;
-    private pendingWrites;
-    private onError?;
-    constructor(asyncStorage: AsyncAchievementStorage, options?: {
-        onError?: (error: AchievementError) => void;
-    });
-    /**
-     * Initialize cache by loading from async storage
-     * This happens in the background during construction
-     */
-    private initializeCache;
-    /**
-     * Wait for cache to be loaded (used internally)
-     * Returns immediately if already loaded, otherwise waits
-     */
-    private ensureCacheLoaded;
-    /**
-     * SYNC READ: Returns cached metrics immediately
-     * Cache is loaded eagerly during construction
-     */
-    getMetrics(): AchievementMetrics;
-    /**
-     * SYNC WRITE: Updates cache immediately, writes to storage in background
-     * Uses optimistic updates - assumes write will succeed
-     */
-    setMetrics(metrics: AchievementMetrics): void;
-    /**
-     * SYNC READ: Returns cached unlocked achievements immediately
-     */
-    getUnlockedAchievements(): string[];
-    /**
-     * SYNC WRITE: Updates cache immediately, writes to storage in background
-     */
-    setUnlockedAchievements(achievements: string[]): void;
-    /**
-     * SYNC CLEAR: Clears cache immediately, clears storage in background
-     */
-    clear(): void;
-    /**
-     * Wait for all pending writes to complete (useful for testing/cleanup)
-     * NOT part of AchievementStorage interface - utility method
-     */
-    flush(): Promise<void>;
-}
-
-declare class IndexedDBStorage implements AsyncAchievementStorage {
-    private dbName;
-    private storeName;
-    private db;
-    private initPromise;
-    constructor(dbName?: string);
-    /**
-     * Initialize IndexedDB database and object store
-     */
-    private initDB;
-    /**
-     * Generic get operation from IndexedDB
-     */
-    private get;
-    /**
-     * Generic set operation to IndexedDB
-     */
-    private set;
-    /**
-     * Delete operation from IndexedDB
-     */
-    private delete;
-    getMetrics(): Promise<AchievementMetrics>;
-    setMetrics(metrics: AchievementMetrics): Promise<void>;
-    getUnlockedAchievements(): Promise<string[]>;
-    setUnlockedAchievements(achievements: string[]): Promise<void>;
-    clear(): Promise<void>;
-}
-
-interface RestApiStorageConfig {
-    baseUrl: string;
-    userId: string;
-    headers?: Record<string, string>;
-    timeout?: number;
-}
-declare class RestApiStorage implements AsyncAchievementStorage {
-    private config;
-    constructor(config: RestApiStorageConfig);
-    /**
-     * Generic fetch wrapper with timeout and error handling
-     */
-    private fetchWithTimeout;
-    getMetrics(): Promise<AchievementMetrics>;
-    setMetrics(metrics: AchievementMetrics): Promise<void>;
-    getUnlockedAchievements(): Promise<string[]>;
-    setUnlockedAchievements(achievements: string[]): Promise<void>;
-    clear(): Promise<void>;
-}
-
-interface QueuedOperation {
-    id: string;
-    type: 'setMetrics' | 'setUnlockedAchievements' | 'clear';
-    data?: any;
-    timestamp: number;
+interface AchievementContextType {
+    update: (metrics: Record<string, any>) => void;
+    achievements: {
+        unlocked: string[];
+        all: Record<string, any>;
+    };
+    reset: () => void;
+    getState: () => {
+        metrics: Record<string, any>;
+        unlocked: string[];
+    };
+    exportData: () => string;
+    importData: (jsonString: string, options?: ImportOptions) => ImportResult;
+    getAllAchievements: () => AchievementWithStatus$1[];
+    engine: AchievementEngine;
+    _isLegacyPattern: boolean;
 }
-declare class OfflineQueueStorage implements AsyncAchievementStorage {
-    private innerStorage;
-    private queue;
-    private isOnline;
-    private isSyncing;
-    private queueStorageKey;
-    constructor(innerStorage: AsyncAchievementStorage);
-    private loadQueue;
-    private saveQueue;
-    private handleOnline;
-    private handleOffline;
-    private processQueue;
-    private queueOperation;
-    getMetrics(): Promise<AchievementMetrics>;
-    setMetrics(metrics: AchievementMetrics): Promise<void>;
-    getUnlockedAchievements(): Promise<string[]>;
-    setUnlockedAchievements(achievements: string[]): Promise<void>;
-    clear(): Promise<void>;
-    /**
-     * Manually trigger queue processing (useful for testing)
-     */
-    sync(): Promise<void>;
+declare const AchievementContext: React$1.Context<AchievementContextType | undefined>;
+interface AchievementProviderProps {
+    achievements?: AchievementConfigurationType$1;
+    storage?: AchievementStorage$1 | AsyncAchievementStorage$1 | StorageType;
+    restApiConfig?: RestApiStorageConfig;
+    eventMapping?: EventMapping;
+    engine?: AchievementEngine;
+    children: React$1.ReactNode;
+    icons?: Record<string, string>;
+    onError?: (error: AchievementError) => void;
     /**
-     * Get current queue status (useful for debugging)
+     * UI configuration for notifications, modal, and confetti
+     * NEW in v3.6.0
      */
-    getQueueStatus(): {
-        pending: number;
-        operations: QueuedOperation[];
-    };
+    ui?: UIConfig;
     /**
-     * Cleanup listeners (call on unmount)
+     * Force use of built-in UI components (opt-in for v3.x)
+     * Set to true to skip legacy library detection and use built-in UI
+     * In v4.0.0, this will become the default behavior
+     * NEW in v3.6.0
+     * @default false
      */
-    destroy(): void;
+    useBuiltInUI?: boolean;
 }
+declare const AchievementProvider: React$1.FC<AchievementProviderProps>;
 
 interface BadgesButtonProps {
     onClick: () => void;
@@ -542,95 +373,6 @@ interface ConfettiWrapperProps {
 }
 declare const ConfettiWrapper: React$1.FC<ConfettiWrapperProps>;
 
-/**
- * Options for importing achievement data
- */
-interface ImportOptions {
-    /** Strategy for merging imported data with existing data */
-    mergeStrategy?: 'replace' | 'merge' | 'preserve';
-    /** Whether to validate the imported data */
-    validate?: boolean;
-    /** Optional config hash to validate against */
-    expectedConfigHash?: string;
-}
-/**
- * Result of an import operation
- */
-interface ImportResult {
-    success: boolean;
-    imported: {
-        metrics: number;
-        achievements: number;
-    };
-    errors?: string[];
-    warnings?: string[];
-}
-/**
- * Imports achievement data from a JSON string
- *
- * @param jsonString - JSON string containing exported achievement data
- * @param currentMetrics - Current metrics state
- * @param currentUnlocked - Current unlocked achievements
- * @param options - Import options
- * @returns Import result with success status and any errors
- *
- * @example
- * ```typescript
- * const result = importAchievementData(
- *   jsonString,
- *   currentMetrics,
- *   currentUnlocked,
- *   { mergeStrategy: 'merge', validate: true }
- * );
- *
- * if (result.success) {
- *   console.log(`Imported ${result.imported.achievements} achievements`);
- * } else {
- *   console.error('Import failed:', result.errors);
- * }
- * ```
- */
-declare function importAchievementData(jsonString: string, currentMetrics: AchievementMetrics, currentUnlocked: string[], options?: ImportOptions): ImportResult;
-
-interface AchievementContextType {
-    update: (metrics: Record<string, any>) => void;
-    achievements: {
-        unlocked: string[];
-        all: Record<string, any>;
-    };
-    reset: () => void;
-    getState: () => {
-        metrics: AchievementMetrics;
-        unlocked: string[];
-    };
-    exportData: () => string;
-    importData: (jsonString: string, options?: ImportOptions) => ImportResult;
-    getAllAchievements: () => AchievementWithStatus[];
-}
-declare const AchievementContext: React$1.Context<AchievementContextType | undefined>;
-interface AchievementProviderProps {
-    achievements: AchievementConfigurationType;
-    storage?: AchievementStorage | AsyncAchievementStorage | StorageType;
-    children: React$1.ReactNode;
-    icons?: Record<string, string>;
-    onError?: (error: AchievementError) => void;
-    restApiConfig?: RestApiStorageConfig;
-    /**
-     * UI configuration for notifications, modal, and confetti
-     * NEW in v3.6.0
-     */
-    ui?: UIConfig;
-    /**
-     * Force use of built-in UI components (opt-in for v3.x)
-     * Set to true to skip legacy library detection and use built-in UI
-     * In v4.0.0, this will become the default behavior
-     * NEW in v3.6.0
-     * @default false
-     */
-    useBuiltInUI?: boolean;
-}
-declare const AchievementProvider: React$1.FC<AchievementProviderProps>;
-
 declare const useAchievements: () => AchievementContextType;
 
 /**
@@ -675,7 +417,7 @@ declare const useSimpleAchievements: () => {
      * Get current state (advanced usage)
      */
     getState: () => {
-        metrics: AchievementMetrics;
+        metrics: Record<string, any>;
         unlocked: string[];
     };
     /**
@@ -689,14 +431,50 @@ declare const useSimpleAchievements: () => {
      * @param options - Import options (merge strategy, validation)
      * @returns Import result with success status and any errors
      */
-    importData: (jsonString: string, options?: ImportOptions) => ImportResult;
+    importData: (jsonString: string, options?: achievements_engine.ImportOptions) => achievements_engine.ImportResult;
     /**
      * Get all achievements with their unlock status
      * @returns Array of achievements with isUnlocked boolean property
      */
-    getAllAchievements: () => AchievementWithStatus[];
+    getAllAchievements: () => achievements_engine.AchievementWithStatus[];
 };
 
+/**
+ * Hook to access the injected AchievementEngine instance (NEW event-based pattern)
+ *
+ * IMPORTANT: This hook only works when Provider has an externally created engine injected via the `engine` prop.
+ * Do NOT use this hook with the old `achievements` prop pattern - use `useAchievements()` instead.
+ *
+ * @example
+ * ```tsx
+ * // Create engine outside React
+ * import { AchievementEngine } from 'achievements-engine';
+ *
+ * const myEngine = new AchievementEngine({
+ *   achievements: config,
+ *   eventMapping: { 'userScored': 'score', 'levelUp': 'level' },
+ *   storage: 'local'
+ * });
+ *
+ * // Inject into Provider
+ * <AchievementProvider engine={myEngine}>
+ *   <App />
+ * </AchievementProvider>
+ *
+ * function App() {
+ *   const engine = useAchievementEngine();
+ *   engine.emit('userScored', 100);
+ *   engine.emit('levelUp', 5);
+ * }
+ * ```
+ *
+ * @returns AchievementEngine instance
+ * @throws Error if used with old achievements prop pattern
+ * @throws Error if used outside AchievementProvider
+ * @since 3.8.0
+ */
+declare const useAchievementEngine: () => AchievementEngine;
+
 declare const defaultStyles: Required<StylesProps>;
 
 declare const defaultAchievementIcons: {
@@ -708,177 +486,6 @@ declare const defaultAchievementIcons: {
     star: string;
 };
 
-declare function isSimpleConfig(config: AchievementConfigurationType): config is SimpleAchievementConfig;
-declare function normalizeAchievements(config: AchievementConfigurationType): AchievementConfiguration;
-
-/**
- * Helper interface for cleaner achievement award definitions
- */
-interface AwardDetails {
-    title?: string;
-    description?: string;
-    icon?: string;
-}
-/**
- * Base class for chainable achievement configuration (Tier 2)
- */
-declare abstract class Achievement {
-    protected metric: string;
-    protected award: AwardDetails;
-    constructor(metric: string, defaultAward: AwardDetails);
-    /**
-     * Customize the award details for this achievement
-     * @param award - Custom award details
-     * @returns This achievement for chaining
-     */
-    withAward(award: AwardDetails): Achievement;
-    /**
-     * Convert this achievement to a SimpleAchievementConfig
-     */
-    abstract toConfig(): SimpleAchievementConfig;
-}
-/**
- * Threshold-based achievement (score, level, etc.)
- */
-declare class ThresholdAchievement extends Achievement {
-    private threshold;
-    constructor(metric: string, threshold: number, defaultAward: AwardDetails);
-    toConfig(): SimpleAchievementConfig;
-}
-/**
- * Boolean achievement (tutorial completion, first login, etc.)
- */
-declare class BooleanAchievement extends Achievement {
-    toConfig(): SimpleAchievementConfig;
-}
-/**
- * Value-based achievement (character class, difficulty, etc.)
- */
-declare class ValueAchievement extends Achievement {
-    private value;
-    constructor(metric: string, value: string, defaultAward: AwardDetails);
-    toConfig(): SimpleAchievementConfig;
-}
-/**
- * Complex achievement builder for power users (Tier 3)
- */
-declare class ComplexAchievementBuilder {
-    private id;
-    private metric;
-    private condition;
-    private award;
-    /**
-     * Set the unique identifier for this achievement
-     */
-    withId(id: string): ComplexAchievementBuilder;
-    /**
-     * Set the metric this achievement tracks
-     */
-    withMetric(metric: string): ComplexAchievementBuilder;
-    /**
-     * Set the condition function that determines if achievement is unlocked
-     */
-    withCondition(fn: (value: AchievementMetricValue, state: AchievementState) => boolean): ComplexAchievementBuilder;
-    /**
-     * Set the award details for this achievement
-     */
-    withAward(award: AwardDetails): ComplexAchievementBuilder;
-    /**
-     * Build the final achievement configuration
-     */
-    build(): SimpleAchievementConfig;
-}
-/**
- * Main AchievementBuilder with three-tier API
- * Tier 1: Simple static methods with smart defaults
- * Tier 2: Chainable customization
- * Tier 3: Full builder for complex logic
- */
-declare class AchievementBuilder {
-    /**
-     * Create a single score achievement with smart defaults
-     * @param threshold - Score threshold to achieve
-     * @returns Chainable ThresholdAchievement
-     */
-    static createScoreAchievement(threshold: number): ThresholdAchievement;
-    /**
-     * Create multiple score achievements
-     * @param thresholds - Array of thresholds or [threshold, award] tuples
-     * @returns Complete SimpleAchievementConfig
-     */
-    static createScoreAchievements(thresholds: (number | [number, AwardDetails])[]): SimpleAchievementConfig;
-    /**
-     * Create a single level achievement with smart defaults
-     * @param level - Level threshold to achieve
-     * @returns Chainable ThresholdAchievement
-     */
-    static createLevelAchievement(level: number): ThresholdAchievement;
-    /**
-     * Create multiple level achievements
-     * @param levels - Array of levels or [level, award] tuples
-     * @returns Complete SimpleAchievementConfig
-     */
-    static createLevelAchievements(levels: (number | [number, AwardDetails])[]): SimpleAchievementConfig;
-    /**
-     * Create a boolean achievement with smart defaults
-     * @param metric - The metric name (e.g., 'completedTutorial')
-     * @returns Chainable BooleanAchievement
-     */
-    static createBooleanAchievement(metric: string): BooleanAchievement;
-    /**
-     * Create a value-based achievement with smart defaults
-     * @param metric - The metric name (e.g., 'characterClass')
-     * @param value - The value to match (e.g., 'wizard')
-     * @returns Chainable ValueAchievement
-     */
-    static createValueAchievement(metric: string, value: string): ValueAchievement;
-    /**
-     * Create a complex achievement builder for power users
-     * @returns ComplexAchievementBuilder for full control
-     */
-    static create(): ComplexAchievementBuilder;
-    /**
-     * Combine multiple achievement configurations
-     * @param achievements - Array of SimpleAchievementConfig objects or Achievement instances
-     * @returns Combined SimpleAchievementConfig
-     */
-    static combine(achievements: (SimpleAchievementConfig | Achievement)[]): SimpleAchievementConfig;
-}
-
-/**
- * Structure of exported achievement data
- */
-interface ExportedData {
-    version: string;
-    timestamp: number;
-    metrics: AchievementMetrics;
-    unlockedAchievements: string[];
-    configHash?: string;
-}
-/**
- * Exports achievement data to a JSON string
- *
- * @param metrics - Current achievement metrics
- * @param unlocked - Array of unlocked achievement IDs
- * @param configHash - Optional hash of achievement configuration for validation
- * @returns JSON string containing all achievement data
- *
- * @example
- * ```typescript
- * const json = exportAchievementData(_metrics, ['score_100', 'level_5']);
- * // Save json to file or send to server
- * ```
- */
-declare function exportAchievementData(metrics: AchievementMetrics, unlocked: string[], configHash?: string): string;
-/**
- * Creates a simple hash of the achievement configuration
- * Used to validate that imported data matches the current configuration
- *
- * @param config - Achievement configuration object
- * @returns Simple hash string
- */
-declare function createConfigHash(config: any): string;
-
 /**
  * Built-in notification component
  * Modern, theme-aware achievement notification with smooth animations
@@ -914,4 +521,4 @@ declare function useWindowSize(): {
     height: number;
 };
 
-export { AchievementBuilder, AchievementCondition, AchievementConfiguration, AchievementConfigurationType, AchievementContext, AchievementContextValue, AchievementDetails, AchievementError, AchievementMetricArrayValue, AchievementMetricValue, AchievementMetrics, AchievementProvider, AchievementProviderProps$1 as AchievementProviderProps, AchievementState, AchievementStorage, AchievementWithStatus, AnyAchievementStorage, AsyncAchievementStorage, AsyncStorageAdapter, AwardDetails, BadgesButton, BadgesButtonWithModal, BadgesModal, BuiltInConfetti, BuiltInModal, BuiltInNotification, ConfettiComponent, ConfettiProps, ConfettiWrapper, ConfigurationError, CustomAchievementDetails, ExportedData, ImportOptions, ImportResult, ImportValidationError, IndexedDBStorage, InitialAchievementMetrics, LocalStorage, MemoryStorage, ModalComponent, ModalProps, NotificationComponent, NotificationPosition, NotificationProps, OfflineQueueStorage, RestApiStorage, RestApiStorageConfig, SimpleAchievementConfig, SimpleAchievementDetails, StorageError, StorageQuotaError, StorageType, StylesProps, SyncError, ThemeConfig, UIConfig, createConfigHash, defaultAchievementIcons, defaultStyles, exportAchievementData, importAchievementData, isAchievementError, isAsyncStorage, isRecoverableError, isSimpleConfig, normalizeAchievements, useAchievements, useSimpleAchievements, useWindowSize };
+export { AchievementCondition, AchievementConfiguration, AchievementConfigurationType, AchievementContext, AchievementContextType, AchievementContextValue, AchievementDetails, AchievementMetricArrayValue, AchievementMetricValue, AchievementMetrics, AchievementProvider, AchievementProviderProps$1 as AchievementProviderProps, AchievementState, AchievementStorage, AchievementWithStatus, AnyAchievementStorage, AsyncAchievementStorage, BadgesButton, BadgesButtonWithModal, BadgesModal, BuiltInConfetti, BuiltInModal, BuiltInNotification, ConfettiComponent, ConfettiProps, ConfettiWrapper, CustomAchievementDetails, InitialAchievementMetrics, ModalComponent, ModalProps, NotificationComponent, NotificationPosition, NotificationProps, SimpleAchievementConfig, SimpleAchievementDetails, StylesProps, ThemeConfig, UIConfig, defaultAchievementIcons, defaultStyles, isAsyncStorage, useAchievementEngine, useAchievements, useSimpleAchievements, useWindowSize };