react-achievements 2.1.0 → 2.2.0

package/dist/providers/AchievementProvider.d.ts

@@ -1,11 +1,12 @@
 import React from 'react';
-import { AchievementProviderProps, AchievementMetrics as AchievementMetricsType } from '../types';
+import 'react-toastify/dist/ReactToastify.css';
+import { AchievementProviderProps, AchievementMetrics } from '../types';
 export interface AchievementContextType {
-    updateMetrics: (newMetrics: AchievementMetricsType | ((prevMetrics: AchievementMetricsType) => AchievementMetricsType)) => void;
+    updateMetrics: (newMetrics: AchievementMetrics | ((prevMetrics: AchievementMetrics) => AchievementMetrics)) => void;
     unlockedAchievements: string[];
     resetStorage: () => void;
 }
 export declare const AchievementContext: React.Context<AchievementContextType | undefined>;
 export declare const useAchievementContext: () => AchievementContextType;
-export declare const AchievementProvider: React.FC<AchievementProviderProps>;
-export declare function mergeDeep(target: any, source: any): any;
+declare const AchievementProvider: React.FC<AchievementProviderProps>;
+export { AchievementProvider };

package/dist/redux/achievementSlice.d.ts

@@ -1,7 +1,7 @@
 import { PayloadAction } from '@reduxjs/toolkit';
-import { AchievementConfiguration, InitialAchievementMetrics, AchievementMetrics } from '../types';
+import { InitialAchievementMetrics, AchievementMetrics, SerializedAchievementConfiguration } from '../types';
 export interface AchievementState {
-    config: AchievementConfiguration;
+    config: SerializedAchievementConfiguration;
     metrics: AchievementMetrics;
     unlockedAchievements: string[];
     previouslyAwardedAchievements: string[];
@@ -9,23 +9,22 @@ export interface AchievementState {
 }
 export declare const achievementSlice: import("@reduxjs/toolkit").Slice<AchievementState, {
     initialize: (state: import("immer/dist/internal").WritableDraft<AchievementState>, action: PayloadAction<{
-        config: AchievementConfiguration;
+        config: SerializedAchievementConfiguration;
         initialState?: InitialAchievementMetrics & {
             previouslyAwardedAchievements?: string[];
         };
         storageKey: string;
     }>) => void;
     setMetrics: (state: import("immer/dist/internal").WritableDraft<AchievementState>, action: PayloadAction<AchievementMetrics>) => void;
-    unlockAchievement: (state: import("immer/dist/internal").WritableDraft<AchievementState>, action: PayloadAction<string>) => void;
     markAchievementAsAwarded: (state: import("immer/dist/internal").WritableDraft<AchievementState>, action: PayloadAction<string>) => void;
     resetAchievements: (state: import("immer/dist/internal").WritableDraft<AchievementState>) => void;
 }, "achievements">;
 export declare const initialize: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    config: AchievementConfiguration;
+    config: SerializedAchievementConfiguration;
     initialState?: InitialAchievementMetrics & {
         previouslyAwardedAchievements?: string[];
     };
     storageKey: string;
-}, "achievements/initialize">, setMetrics: import("@reduxjs/toolkit").ActionCreatorWithPayload<AchievementMetrics, "achievements/setMetrics">, unlockAchievement: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "achievements/unlockAchievement">, resetAchievements: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"achievements/resetAchievements">, markAchievementAsAwarded: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "achievements/markAchievementAsAwarded">;
+}, "achievements/initialize">, setMetrics: import("@reduxjs/toolkit").ActionCreatorWithPayload<AchievementMetrics, "achievements/setMetrics">, resetAchievements: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"achievements/resetAchievements">, markAchievementAsAwarded: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "achievements/markAchievementAsAwarded">;
 declare const _default: import("@reduxjs/toolkit").Reducer<AchievementState>;
 export default _default;

package/dist/types.d.ts

@@ -27,3 +27,11 @@ export interface AchievementUnlockCondition<T extends AchievementMetricValue> {
     isConditionMet: (value: T) => boolean;
     achievementDetails: AchievementDetails;
 }
+export interface SerializedAchievementUnlockCondition {
+    achievementDetails: AchievementDetails;
+    conditionType: 'number' | 'string' | 'boolean' | 'date';
+    conditionValue: any;
+}
+export interface SerializedAchievementConfiguration {
+    [metricName: string]: SerializedAchievementUnlockCondition[];
+}

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "react-achievements",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "This package allows users to transpose a React achievements engine over their React apps",
   "keywords": [
     "react",
     "badge",
     "achievement"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dave-b-b/react-achievements.git"
+  },
   "main": "dist/cjs.js",
   "module": "dist/index.esm.js",
   "types": "dist/index.d.ts",
@@ -26,6 +30,7 @@
     "@mui/icons-material": "^6.4.8",
     "@rollup/plugin-commonjs": "^26.0.1",
     "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-replace": "^6.0.2",
     "@storybook/addon-essentials": "^8.6.8",
     "@storybook/addon-interactions": "^8.6.8",
     "@storybook/addon-links": "^8.6.8",
@@ -35,23 +40,27 @@
     "@storybook/react": "^8.6.8",
     "@storybook/react-webpack5": "^8.6.8",
     "@storybook/test": "^8.6.8",
-    "rollup": "^4.19.0",
-    "rollup-plugin-typescript2": "^0.36.0",
-    "storybook": "^8.6.8",
-    "typescript": "^5.5.4",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.14.12",
     "@types/react": "^18.3.3",
-    "@types/react-dom": "^18.3.0"
+    "@types/react-dom": "^18.3.0",
+    "postcss": "^8.5.3",
+    "rollup": "^4.19.0",
+    "rollup-plugin-postcss": "^4.0.2",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "storybook": "^8.6.8",
+    "typescript": "^5.5.4"
   },
   "peerDependencies": {
+    "@reduxjs/toolkit": "^1.0.0",
     "react": "^18.0.0",
+    "react-confetti": "^6.0.0",
     "react-dom": "^18.0.0",
     "react-redux": "^8.0.0 || ^9.0.0",
-    "@reduxjs/toolkit": "^1.0.0",
-    "react-confetti": "^6.0.0",
+    "react-toastify": "^10.0.0",
     "react-use": "^17.0.0"
   },
   "dependencies": {
+    "react-toastify": "^10.0.0"
   }
-}
+}

package/rollup.config.mjs

@@ -1,6 +1,8 @@
 import resolve from '@rollup/plugin-node-resolve';
 import commonjs from '@rollup/plugin-commonjs';
 import typescript from 'rollup-plugin-typescript2';
+import replace from '@rollup/plugin-replace';
+import postcss from 'rollup-plugin-postcss';
 
 export default {
     input: 'src/index.ts',
@@ -15,6 +17,15 @@ export default {
         }
     ],
     plugins: [
+        replace({
+            preventAssignment: true,
+            'this': 'undefined',
+        }),
+        postcss({
+            extract: false,
+            inject: true,
+            modules: false
+        }),
         resolve(),
         commonjs(),
         typescript({ tsconfig: './tsconfig.json' })

package/src/defaultStyles.ts

@@ -1,14 +1,5 @@
 type StyleObject = { [key: string]: string | number };
 
-interface ModalStyles {
-    overlay: StyleObject;
-    content: StyleObject;
-    title: StyleObject;
-    icon: StyleObject;
-    description: StyleObject;
-    button: StyleObject;
-}
-
 interface BadgesModalStyles {
     overlay: StyleObject;
     content: StyleObject;
@@ -21,54 +12,11 @@ interface BadgesModalStyles {
 }
 
 export interface Styles {
-    achievementModal: ModalStyles;
     badgesModal: BadgesModalStyles;
     badgesButton: StyleObject;
 }
 
 export const defaultStyles: Styles = {
-    achievementModal: {
-        overlay: {
-            position: 'fixed',
-            top: 0,
-            left: 0,
-            right: 0,
-            bottom: 0,
-            backgroundColor: 'rgba(0, 0, 0, 0.5)',
-            display: 'flex',
-            alignItems: 'center',
-            justifyContent: 'center',
-        },
-        content: {
-            backgroundColor: '#ffffff',
-            borderRadius: '8px',
-            padding: '20px',
-            maxWidth: '400px',
-            width: '100%',
-        },
-        title: {
-            fontSize: '24px',
-            fontWeight: 'bold',
-            marginBottom: '10px',
-        },
-        icon: {
-            width: '50px',
-            height: '50px',
-            marginBottom: '10px',
-        },
-        description: {
-            fontSize: '16px',
-            marginBottom: '20px',
-        },
-        button: {
-            backgroundColor: '#007bff',
-            color: '#ffffff',
-            padding: '10px 20px',
-            borderRadius: '4px',
-            border: 'none',
-            cursor: 'pointer',
-        },
-    },
     badgesModal: {
         overlay: {
             position: 'fixed',

package/src/hooks/useAchievement.ts

@@ -1,20 +1,17 @@
-import { useSelector, useDispatch } from 'react-redux';
-import { RootState, AppDispatch } from '../redux/store';
+import { useSelector } from 'react-redux';
+import { RootState } from '../redux/store';
 import { useAchievementContext } from '../providers/AchievementProvider';
 
 export const useAchievement = () => {
-    const dispatch: AppDispatch = useDispatch();
-    const { updateMetrics, unlockedAchievements, resetStorage } = useAchievementContext() || {};
+    const { updateMetrics, unlockedAchievements, resetStorage } = useAchievementContext();
     const metrics = useSelector((state: RootState) => state.achievements.metrics);
-    const notifications = useSelector((state: RootState) => state.notifications.notifications);
     const config = useSelector((state: RootState) => state.achievements.config);
 
     return {
-        metrics: metrics,
-        unlockedAchievements: unlockedAchievements || [],
-        notifications: notifications,
-        config: config,
-        updateMetrics: updateMetrics || (() => {}),
-        resetStorage: resetStorage || (() => {}),
+        metrics,
+        unlockedAchievements,
+        config,
+        updateMetrics,
+        resetStorage,
     };
 };

package/src/index.ts

@@ -1,19 +1,25 @@
 import { AchievementProvider, useAchievementContext as useAchievement } from './providers/AchievementProvider';
-import { AchievementMetrics, AchievementConfiguration, AchievementDetails, AchievementUnlockCondition } from './types';
-import ConfettiWrapper from './components/ConfettiWrapper';
+import type { 
+    AchievementMetrics, 
+    AchievementConfiguration, 
+    AchievementDetails, 
+    AchievementUnlockCondition, 
+    AchievementMetricValue, 
+    InitialAchievementMetrics 
+} from './types';
 import achievementReducer from './redux/achievementSlice';
-import notificationReducer from './redux/notificationSlice'
-import { useAchievementState } from './hooks/useAchievementState';
 
 export {
     AchievementProvider,
     useAchievement,
+    achievementReducer,
+};
+
+export type {
     AchievementMetrics,
     AchievementConfiguration,
     AchievementDetails,
     AchievementUnlockCondition,
-    ConfettiWrapper,
-    achievementReducer,
-    notificationReducer,
-    useAchievementState,
+    AchievementMetricValue,
+    InitialAchievementMetrics,
 };

package/src/providers/AchievementProvider.tsx

@@ -1,24 +1,24 @@
-import React, { useEffect, useCallback } from 'react';
+import React, { useEffect, useCallback, useState, useMemo, useRef } from 'react';
 import { useSelector, useDispatch } from 'react-redux';
 import { RootState, AppDispatch } from '../redux/store';
-import { initialize, setMetrics, unlockAchievement, resetAchievements, markAchievementAsAwarded } from '../redux/achievementSlice';
-import { addNotification, clearNotifications } from '../redux/notificationSlice';
+import { initialize, setMetrics, resetAchievements, unlockAchievement, clearNotifications } from '../redux/achievementSlice';
+import { toast, ToastContainer } from 'react-toastify';
+import 'react-toastify/dist/ReactToastify.css';
 import {
     AchievementDetails,
     AchievementMetricValue,
-    AchievementUnlockCondition,
+    AchievementConfiguration,
     AchievementProviderProps,
-    AchievementMetrics as AchievementMetricsType,
+    AchievementMetrics,
+    AchievementState
 } from '../types';
-import { defaultStyles, Styles } from '../defaultStyles';
-import AchievementModal from '../components/AchievementModal';
-import BadgesModal from '../components/BadgesModal';
 import BadgesButton from '../components/BadgesButton';
+import BadgesModal from '../components/BadgesModal';
 import ConfettiWrapper from '../components/ConfettiWrapper';
-import { defaultAchievementIcons } from '../assets/defaultIcons';
+import { defaultStyles } from '../defaultStyles';
 
 export interface AchievementContextType {
-    updateMetrics: (newMetrics: AchievementMetricsType | ((prevMetrics: AchievementMetricsType) => AchievementMetricsType)) => void;
+    updateMetrics: (newMetrics: AchievementMetrics | ((prevMetrics: AchievementMetrics) => AchievementMetrics)) => void;
     unlockedAchievements: string[];
     resetStorage: () => void;
 }
@@ -33,165 +33,170 @@ export const useAchievementContext = () => {
     return context;
 };
 
-export const AchievementProvider: React.FC<AchievementProviderProps> = ({
-                                                                            children,
-                                                                            config,
-                                                                            initialState = {},
-                                                                            storageKey = 'react-achievements',
-                                                                            badgesButtonPosition = 'top-right',
-                                                                            styles = {},
-                                                                            icons = {},
-                                                                        }: AchievementProviderProps) => {
+// Helper function to serialize dates for Redux actions
+const serializeMetrics = (metrics: AchievementMetrics): AchievementMetrics => {
+    return Object.entries(metrics).reduce((acc, [key, values]) => ({
+        ...acc,
+        [key]: values.map(value => value instanceof Date ? value.toISOString() : value)
+    }), {} as AchievementMetrics);
+};
+
+// Helper function to parse potential date strings
+const deserializeValue = (value: string | number | boolean): AchievementMetricValue => {
+    if (typeof value === 'string') {
+        // Try to parse ISO date string
+        const date = new Date(value);
+        if (!isNaN(date.getTime()) && value === date.toISOString()) {
+            return date;
+        }
+    }
+    return value;
+};
+
+const AchievementProvider: React.FC<AchievementProviderProps> = ({
+    children,
+    config,
+    initialState = {},
+    storageKey = 'react-achievements',
+    badgesButtonPosition = 'top-right',
+    styles = {},
+    icons = {},
+}) => {
     const dispatch: AppDispatch = useDispatch();
+    const configRef = useRef(config);
     const metrics = useSelector((state: RootState) => state.achievements.metrics);
     const unlockedAchievementIds = useSelector((state: RootState) => state.achievements.unlockedAchievements);
-    const previouslyAwardedAchievementIds = useSelector((state: RootState) => state.achievements.previouslyAwardedAchievements);
-    const notifications = useSelector((state: RootState) => state.notifications.notifications);
-    const mergedStyles = React.useMemo(() => mergeDeep(defaultStyles, styles), [styles]);
-
-    const [currentAchievement, setCurrentAchievement] = React.useState<AchievementDetails | null>(null);
-    const [showBadges, setShowBadges] = React.useState(false);
-    const [showConfetti, setShowConfetti] = React.useState(false);
-
-    const mergedIcons = React.useMemo(() => ({ ...defaultAchievementIcons, ...icons }), [icons]);
-
-    const updateMetrics = useCallback(
-        (newMetrics: AchievementMetricsType | ((prevMetrics: AchievementMetricsType) => AchievementMetricsType)) => {
-            dispatch(setMetrics(typeof newMetrics === 'function' ? newMetrics(metrics) : newMetrics));
-        },
-        [dispatch, metrics]
-    );
-
-    const resetStorage = useCallback(() => {
-        localStorage.removeItem(storageKey);
-        dispatch(resetAchievements());
-    }, [dispatch, storageKey]);
+    const pendingNotifications = useSelector((state: RootState) => state.achievements.pendingNotifications);
+    const [showBadges, setShowBadges] = useState(false);
+    const [showConfetti, setShowConfetti] = useState(false);
 
+    // Update config ref when it changes
     useEffect(() => {
-        dispatch(initialize({ config, initialState, storageKey }));
-    }, [dispatch, config, initialState, storageKey]);
+        configRef.current = config;
+    }, [config]);
 
     const checkAchievements = useCallback(() => {
-        const newAchievementsToAward: AchievementDetails[] = [];
-
-        if (!unlockedAchievementIds) {
-            console.error('unlockedAchievements is undefined!');
-            return;
-        }
-
-        Object.entries(config)
-            .forEach(([metricName, conditions]) => {
-                const metricValues = metrics[metricName];
-
-                if (!metricValues) {
-                    return;
+        Object.entries(configRef.current).forEach(([metricName, conditions]) => {
+            const metricValues = metrics[metricName];
+            if (!metricValues) return;
+
+            const latestValue = deserializeValue(metricValues[metricValues.length - 1]);
+            const state: AchievementState = {
+                metrics: Object.entries(metrics).reduce((acc, [key, values]) => ({
+                    ...acc,
+                    [key]: values.map(deserializeValue)
+                }), {}),
+                unlockedAchievements: unlockedAchievementIds
+            };
+
+            conditions.forEach((condition) => {
+                if (
+                    condition.isConditionMet(latestValue, state) &&
+                    !unlockedAchievementIds.includes(condition.achievementDetails.achievementId)
+                ) {
+                    dispatch(unlockAchievement(condition.achievementDetails));
+                    setShowConfetti(true);
                 }
-
-                conditions
-                    .filter(condition => !previouslyAwardedAchievementIds.includes(condition.achievementDetails.achievementId))
-                    .forEach((condition) => {
-                        if (
-                            metricValues.some((value: AchievementMetricValue) => condition.isConditionMet(value)) &&
-                            !unlockedAchievementIds.includes(condition.achievementDetails.achievementId)
-                        ) {
-                            dispatch(unlockAchievement(condition.achievementDetails.achievementId));
-                            newAchievementsToAward.push(condition.achievementDetails);
-                        } else if (
-                            metricValues.some((value: AchievementMetricValue) => condition.isConditionMet(value)) &&
-                            unlockedAchievementIds.includes(condition.achievementDetails.achievementId) &&
-                            !previouslyAwardedAchievementIds.includes(condition.achievementDetails.achievementId)
-                        ) {
-                            newAchievementsToAward.push(condition.achievementDetails);
-                        }
-                    });
             });
+        });
+    }, [metrics, unlockedAchievementIds, dispatch]);
 
-        if (newAchievementsToAward.length > 0) {
-            newAchievementsToAward.forEach((achievement) => {
-                dispatch(addNotification(achievement));
-                dispatch(markAchievementAsAwarded(achievement.achievementId));
+    // Handle notifications
+    useEffect(() => {
+        if (pendingNotifications.length > 0) {
+            pendingNotifications.forEach((notification) => {
+                toast.success(
+                    <div>
+                        <h4 style={{ margin: '0 0 8px 0' }}>Achievement Unlocked! 🎉</h4>
+                        <strong>{notification.achievementTitle}</strong>
+                        <p style={{ margin: '4px 0 0 0' }}>{notification.achievementDescription}</p>
+                        {notification.achievementIconKey && icons[notification.achievementIconKey] && (
+                            <div style={{ fontSize: '24px', marginTop: '8px' }}>
+                                {icons[notification.achievementIconKey]}
+                            </div>
+                        )}
+                    </div>,
+                    {
+                        position: "top-right",
+                        autoClose: 5000,
+                        hideProgressBar: false,
+                        closeOnClick: true,
+                        pauseOnHover: true,
+                        draggable: true,
+                    }
+                );
             });
-            setShowConfetti(true);
+            dispatch(clearNotifications());
         }
-    }, [config, metrics, unlockedAchievementIds, previouslyAwardedAchievementIds, dispatch]);
+    }, [pendingNotifications, dispatch, icons]);
 
+    // Reset confetti after delay
+    useEffect(() => {
+        if (showConfetti) {
+            const timer = setTimeout(() => setShowConfetti(false), 5000);
+            return () => clearTimeout(timer);
+        }
+    }, [showConfetti]);
+
+    // Check for achievements when metrics change
     useEffect(() => {
         checkAchievements();
     }, [metrics, checkAchievements]);
 
+    // Initialize on mount, but don't store config in Redux
     useEffect(() => {
-        if (notifications.length > 0 && !currentAchievement) {
-            setCurrentAchievement(notifications[0]);
-        }
-    }, [notifications, currentAchievement]);
-
-    const showBadgesModal = () => setShowBadges(true);
-
-    const getAchievements = useCallback(
-        (achievedIds: string[]) => {
-            return Object.values(config).flatMap((conditions) =>
-                conditions
-                    .filter((c) => achievedIds.includes(c.achievementDetails.achievementId))
-                    .map((c) => c.achievementDetails)
-            );
-        },
-        [config]
-    );
-
-    const unlockedAchievementsDetails = getAchievements(unlockedAchievementIds);
-    const previouslyAwardedAchievementsDetails = getAchievements(previouslyAwardedAchievementIds);
+        dispatch(initialize({
+            initialState,
+            storageKey,
+        }));
+    }, [dispatch, initialState, storageKey]);
+
+    // Convert achievement IDs to details using config from ref
+    const achievementDetails = useMemo(() => {
+        return unlockedAchievementIds
+            .map(id => {
+                const achievement = Object.values(configRef.current)
+                    .flat()
+                    .find(condition => condition.achievementDetails.achievementId === id);
+                return achievement?.achievementDetails;
+            })
+            .filter((a): a is AchievementDetails => !!a);
+    }, [unlockedAchievementIds]);
 
     return (
-        <AchievementContext.Provider value={{ updateMetrics, unlockedAchievements: unlockedAchievementIds, resetStorage }}>
+        <AchievementContext.Provider value={{
+            updateMetrics: (newMetrics) => {
+                if (typeof newMetrics === 'function') {
+                    const updatedMetrics = newMetrics(metrics);
+                    dispatch(setMetrics(serializeMetrics(updatedMetrics)));
+                } else {
+                    dispatch(setMetrics(serializeMetrics(newMetrics)));
+                }
+            },
+            unlockedAchievements: unlockedAchievementIds,
+            resetStorage: () => {
+                localStorage.removeItem(storageKey);
+                dispatch(resetAchievements());
+            },
+        }}>
             {children}
-            <AchievementModal
-                isOpen={!!currentAchievement}
-                achievement={currentAchievement}
-                onClose={() => {
-                    setCurrentAchievement(null);
-                    if (currentAchievement) {
-                        dispatch(clearNotifications());
-                    }
-                }}
-                styles={mergedStyles.achievementModal}
-                icons={mergedIcons}
+            <ToastContainer />
+            <ConfettiWrapper show={showConfetti} />
+            <BadgesButton
+                onClick={() => setShowBadges(true)}
+                position={badgesButtonPosition}
+                styles={styles.badgesButton || defaultStyles.badgesButton}
+                unlockedAchievements={achievementDetails}
             />
             <BadgesModal
                 isOpen={showBadges}
-                achievements={previouslyAwardedAchievementsDetails}
+                achievements={achievementDetails}
                 onClose={() => setShowBadges(false)}
-                styles={mergedStyles.badgesModal}
-                icons={mergedIcons}
+                styles={styles.badgesModal || defaultStyles.badgesModal}
+                icons={icons}
             />
-            <BadgesButton
-                onClick={showBadgesModal}
-                position={badgesButtonPosition}
-                styles={mergedStyles.badgesButton}
-                unlockedAchievements={previouslyAwardedAchievementsDetails}
-            />
-            <ConfettiWrapper show={showConfetti || notifications.length > 0} />
         </AchievementContext.Provider>
     );
 };
 
-function isObject(item: any) {
-    return item && typeof item === 'object' && !Array.isArray(item);
-}
-
-export function mergeDeep(target: any, source: any) {
-    const output = { ...target };
-    if (isObject(target) && isObject(source)) {
-        Object.keys(source).forEach((key) => {
-            if (isObject(source[key])) {
-                if (!(key in target)) {
-                    output[key] = source[key];
-                } else {
-                    output[key] = mergeDeep(target[key], source[key]);
-                }
-            } else {
-                output[key] = source[key];
-            }
-        });
-    }
-    return output;
-}
+export { AchievementProvider };