@coorpacademy/app-review 0.46.14-react18.80 → 0.46.14-react18.83

package/es/actions/api/fetch-correction.js

@@ -0,0 +1,18 @@
+import buildTask from '@coorpacademy/redux-task';
+import get from 'lodash/fp/get';
+export const CORRECTION_FETCH_REQUEST = '@@correction/FETCH_REQUEST';
+export const CORRECTION_FETCH_SUCCESS = '@@correction/FETCH_SUCCESS';
+export const CORRECTION_FETCH_FAILURE = '@@correction/FETCH_FAILURE';
+export const fetchCorrection = (dispatch, getState, { services }) => {
+    const state = getState();
+    const slideRef = get(['ui', 'currentSlideRef'], state);
+    const token = get(['data', 'token'], state);
+    const progressionId = get(['data', 'progression', '_id'], state);
+    const answer = get(['ui', 'answers', slideRef], state);
+    const action = buildTask({
+        types: [CORRECTION_FETCH_REQUEST, CORRECTION_FETCH_SUCCESS, CORRECTION_FETCH_FAILURE],
+        meta: { slideRef },
+        task: () => services.fetchCorrection(slideRef, token, progressionId, answer)
+    });
+    return dispatch(action);
+};

package/es/actions/api/fetch-rank.js

@@ -0,0 +1,34 @@
+import buildTask from '@coorpacademy/redux-task';
+import get from 'lodash/fp/get';
+export const RANK_FETCH_START_REQUEST = '@@rank/FETCH_START_REQUEST';
+export const RANK_FETCH_START_SUCCESS = '@@rank/FETCH_START_SUCCESS';
+export const RANK_FETCH_START_FAILURE = '@@rank/FETCH_START_FAILURE';
+export const RANK_FETCH_END_REQUEST = '@@rank/FETCH_END_REQUEST';
+export const RANK_FETCH_END_SUCCESS = '@@rank/FETCH_END_SUCCESS';
+export const RANK_FETCH_END_FAILURE = '@@rank/FETCH_END_FAILURE';
+const bailout = (path) => (state) => {
+    const value = get(path, state);
+    return !Number.isNaN(value);
+};
+export const fetchRank = (dispatch, getState, services, types, path) => {
+    const action = buildTask({
+        types,
+        task: () => {
+            const state = getState();
+            const token = get(['data', 'token'], state);
+            return services.fetchRank(token);
+        },
+        bailout: path ? bailout(path) : undefined
+    });
+    return dispatch(action);
+};
+export const fetchStartRank = (dispatch, getState, { services }) => {
+    return fetchRank(dispatch, getState, services, [RANK_FETCH_START_REQUEST, RANK_FETCH_START_SUCCESS, RANK_FETCH_START_FAILURE], 'data.rank.start');
+};
+export const fetchEndRank = (dispatch, getState, { services }) => {
+    return fetchRank(dispatch, getState, services, [
+        RANK_FETCH_END_REQUEST,
+        RANK_FETCH_END_SUCCESS,
+        RANK_FETCH_END_FAILURE
+    ]);
+};

package/es/actions/api/fetch-skill.js

@@ -0,0 +1,16 @@
+import get from 'lodash/fp/get';
+import buildTask from '@coorpacademy/redux-task';
+export const SKILL_FETCH_REQUEST = '@@skill/FETCH_REQUEST';
+export const SKILL_FETCH_SUCCESS = '@@skill/FETCH_SUCCESS';
+export const SKILL_FETCH_FAILURE = '@@skill/FETCH_FAILURE';
+export const fetchSkill = (skillRef) => (dispatch, getState, { services }) => {
+    const action = buildTask({
+        types: [SKILL_FETCH_REQUEST, SKILL_FETCH_SUCCESS, SKILL_FETCH_FAILURE],
+        task: () => {
+            const state = getState();
+            const token = get(['data', 'token'], state);
+            return services.fetchSkill(skillRef, token);
+        }
+    });
+    return dispatch(action);
+};

package/es/actions/api/fetch-slide.js

@@ -0,0 +1,31 @@
+import buildTask from '@coorpacademy/redux-task';
+import get from 'lodash/fp/get';
+import has from 'lodash/fp/has';
+import isEmpty from 'lodash/fp/isEmpty';
+import { setCurrentSlide } from '../ui/slides';
+export const SLIDE_FETCH_REQUEST = '@@slides/FETCH_REQUEST';
+export const SLIDE_FETCH_SUCCESS = '@@slides/FETCH_SUCCESS';
+export const SLIDE_FETCH_FAILURE = '@@slides/FETCH_FAILURE';
+export const fetchSlide = (slideRef) => async (dispatch, getState, { services }) => {
+    const action = buildTask({
+        types: [SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS, SLIDE_FETCH_FAILURE],
+        bailout: (state) => {
+            return has(`data.slides.${slideRef}`, state);
+        },
+        task: () => {
+            const state = getState();
+            const token = get(['data', 'token'], state);
+            return services.fetchSlide(slideRef, token);
+        },
+        meta: { slideRef }
+    });
+    const response = await dispatch(action);
+    if (response.type === SLIDE_FETCH_SUCCESS) {
+        const slideFromAPI = response.payload;
+        const state = getState();
+        const slides = get('data.progression.state.slides', state);
+        if (isEmpty(slides)) {
+            dispatch(setCurrentSlide(slideFromAPI));
+        }
+    }
+};

package/es/actions/api/fetch-slides-to-review-by-skill-ref.js

@@ -0,0 +1,32 @@
+import buildTask from '@coorpacademy/redux-task';
+import difference from 'lodash/fp/difference';
+import map from 'lodash/fp/map';
+import get from 'lodash/fp/get';
+import { showButtonRevising } from '../ui/show-button-revising';
+export const SLIDES_TO_REVIEW_FETCH_REQUEST = '@@slidesToReview/FETCH_REQUEST';
+export const SLIDES_TO_REVIEW_FETCH_SUCCESS = '@@slidesToReview/FETCH_SUCCESS';
+export const SLIDES_TO_REVIEW_FETCH_FAILURE = '@@slidesToReview/FETCH_FAILURE';
+export const fetchSlidesToReviewBySkillRef = async (dispatch, getState, { services }) => {
+    const state = getState();
+    const action = buildTask({
+        types: [
+            SLIDES_TO_REVIEW_FETCH_REQUEST,
+            SLIDES_TO_REVIEW_FETCH_SUCCESS,
+            SLIDES_TO_REVIEW_FETCH_FAILURE
+        ],
+        task: () => {
+            const token = state.data.token;
+            const progression = state.data.progression;
+            const skillRef = progression.content.ref;
+            return services.fetchSlidesToReviewBySkillRef(token, skillRef, 10);
+        }
+    });
+    const response = await dispatch(action);
+    if (response.type === SLIDES_TO_REVIEW_FETCH_SUCCESS) {
+        const answeredSlidesRef = get(['data', 'progression', 'state', 'slides'], state);
+        const slidesToReview = map(({ slideId }) => slideId, response.payload);
+        if (difference(slidesToReview, answeredSlidesRef).length >= 5) {
+            dispatch(showButtonRevising);
+        }
+    }
+};

package/es/actions/api/fetch-video-props.js

@@ -0,0 +1,34 @@
+import get from 'lodash/fp/get';
+export const SET_VIDEO_PROPS = '@@slide/SET_VIDEO_PROPS';
+export const SHOW_VIDEO = '@@slide/SHOW_VIDEO';
+export const setVideoProps = (payload) => ({
+    type: SET_VIDEO_PROPS,
+    payload
+});
+export const showVideo = (slideId) => ({
+    type: SHOW_VIDEO,
+    payload: { slideId }
+});
+export const fetchPropsVideo = (slideId) => async (dispatch, getState, { appendVideoOptions }) => {
+    const state = getState();
+    const slideFromAPI = get(['data', 'slides', slideId], state);
+    if (!slideFromAPI) {
+        return;
+    }
+    const slideMedia = get(['question', 'medias', '0'], slideFromAPI);
+    if (slideMedia && slideMedia.type === 'video') {
+        const videoProps = get(['data', 'videos', slideId], state);
+        if (videoProps) {
+            dispatch(showVideo(slideId));
+            return;
+        }
+        const props = await appendVideoOptions(slideMedia);
+        props.src[0].loading = false; // set to false to not show it until the next slide is unstack
+        props.src[0].type = 'video';
+        dispatch(setVideoProps({
+            slideId,
+            props
+        }));
+    }
+    return;
+};

package/es/actions/api/post-answer.js

@@ -0,0 +1,36 @@
+import buildTask from '@coorpacademy/redux-task';
+import get from 'lodash/fp/get';
+import { fetchCorrection } from './fetch-correction';
+import { fetchSlide } from './fetch-slide';
+import { fetchStartRank } from './fetch-rank';
+export const POST_ANSWER_REQUEST = '@@answer/POST_REQUEST';
+export const POST_ANSWER_SUCCESS = '@@answer/POST_SUCCESS';
+export const POST_ANSWER_FAILURE = '@@answer/POST_FAILURE';
+export const postAnswer = async (dispatch, getState, { services, onEndProgression }) => {
+    const state = getState();
+    const currentSlideRef = get(['ui', 'currentSlideRef'], state);
+    const token = get(['data', 'token'], state);
+    const answer = get(['ui', 'answers', currentSlideRef], state);
+    const progression = get(['data', 'progression'], state);
+    if (!progression)
+        throw new Error('Cannot answer a question of an inexistent progression');
+    const action = buildTask({
+        types: [POST_ANSWER_REQUEST, POST_ANSWER_SUCCESS, POST_ANSWER_FAILURE],
+        meta: { slideRef: currentSlideRef },
+        task: () => services.postAnswer(progression, token, answer)
+    });
+    const response = await dispatch(action);
+    if (response.type === POST_ANSWER_SUCCESS) {
+        const updatedProgression = response.payload;
+        const slideRef = updatedProgression.state.nextContent.ref;
+        if (slideRef !== 'successExitNode') {
+            await dispatch(fetchSlide(slideRef));
+            await dispatch(fetchCorrection);
+            await dispatch(fetchStartRank);
+        }
+        else {
+            onEndProgression(updatedProgression);
+            await dispatch(fetchCorrection);
+        }
+    }
+};

package/es/actions/api/post-progression.js

@@ -0,0 +1,25 @@
+import buildTask from '@coorpacademy/redux-task';
+import get from 'lodash/fp/get';
+import { fetchSlide } from './fetch-slide';
+import { fetchSkill } from './fetch-skill';
+export const POST_PROGRESSION_REQUEST = '@@progression/POST_REQUEST';
+export const POST_PROGRESSION_SUCCESS = '@@progression/POST_SUCCESS';
+export const POST_PROGRESSION_FAILURE = '@@progression/POST_FAILURE';
+export const postProgression = (skillRef, testingSlideRef) => async (dispatch, getState, { services, onStartProgression }) => {
+    const state = getState();
+    const token = get(['data', 'token'], state);
+    const action = buildTask({
+        types: [POST_PROGRESSION_REQUEST, POST_PROGRESSION_SUCCESS, POST_PROGRESSION_FAILURE],
+        task: () => testingSlideRef
+            ? services.postSandboxProgression(testingSlideRef, skillRef, token)
+            : services.postProgression(skillRef, token)
+    });
+    const response = await dispatch(action);
+    if (response.type === POST_PROGRESSION_SUCCESS) {
+        const progression = response.payload;
+        const slideRef = progression.state.nextContent.ref;
+        onStartProgression(progression);
+        await dispatch(fetchSlide(slideRef));
+        await dispatch(fetchSkill(skillRef));
+    }
+};

package/es/actions/data/token.js

@@ -0,0 +1,5 @@
+export const STORE_TOKEN = '@@data/token/STORE_TOKEN';
+export const storeToken = (token) => ({
+    type: STORE_TOKEN,
+    payload: token
+});

package/es/actions/ui/answers.js

@@ -0,0 +1,54 @@
+import flatten from 'lodash/fp/flatten';
+import get from 'lodash/fp/get';
+import getOr from 'lodash/fp/getOr';
+import includes from 'lodash/fp/includes';
+import pull from 'lodash/fp/pull';
+export const EDIT_QCM = '@@answer/EDIT_QCM';
+export const EDIT_QCM_GRAPHIC = '@@answer/EDIT_QCM_GRAPHIC';
+export const EDIT_QCM_DRAG = '@@answer/EDIT_QCM_DRAG';
+export const EDIT_TEMPLATE = '@@answer/EDIT_TEMPLATE';
+export const EDIT_BASIC = '@@answer/EDIT_BASIC';
+export const EDIT_SLIDER = '@@answer/EDIT_SLIDER';
+export const ANSWER_EDIT = {
+    qcm: EDIT_QCM,
+    qcmGraphic: EDIT_QCM_GRAPHIC,
+    qcmDrag: EDIT_QCM_DRAG,
+    template: EDIT_TEMPLATE,
+    basic: EDIT_BASIC,
+    slider: EDIT_SLIDER
+};
+const buildAnswer = (userAnswers, questionType, newValue) => {
+    switch (questionType) {
+        case 'qcm':
+        case 'qcmGraphic':
+        case 'qcmDrag': {
+            const firstValue = newValue[0];
+            return includes(firstValue, userAnswers)
+                ? pull(firstValue, userAnswers)
+                : flatten([...userAnswers, firstValue]);
+        }
+        case 'basic':
+        case 'slider':
+        case 'template':
+            return newValue;
+        /* istanbul ignore next */ default:
+            return [];
+    }
+};
+export const editAnswer = (answer) => (dispatch, getState) => {
+    const state = getState();
+    const currentSlideRef = get(['ui', 'currentSlideRef'], state);
+    const userAnswers = getOr([], ['ui', 'answers', currentSlideRef], state);
+    const slide = get(['data', 'slides', currentSlideRef], state);
+    if (!slide)
+        throw new Error('No slide was found');
+    const questionType = get(['question', 'type'], slide);
+    const type = get(questionType, ANSWER_EDIT);
+    if (!type)
+        throw new Error(`Question type ${questionType} is not supported`);
+    return dispatch({
+        type,
+        meta: { slideRef: currentSlideRef },
+        payload: buildAnswer(userAnswers, questionType, answer)
+    });
+};

package/es/actions/ui/navigation.js

@@ -0,0 +1,26 @@
+export const NAVIGATE_TO = '@@navigation/NAVIGATE_TO';
+export const NAVIGATE_BACK = '@@navigation/NAVIGATE_BACK';
+export const START_APP = '@@navigation/START_APP';
+export const navigateTo = (newViewName) => async (dispatch, getState, { callbackOnViewChanged }) => {
+    const action = {
+        type: NAVIGATE_TO,
+        payload: newViewName
+    };
+    const res = await dispatch(action);
+    if (callbackOnViewChanged) {
+        callbackOnViewChanged(newViewName);
+    }
+    return res;
+};
+export const navigateBack = async (dispatch, getState, { callbackOnViewChanged }) => {
+    const action = {
+        type: NAVIGATE_BACK
+    };
+    const res = await dispatch(action);
+    if (callbackOnViewChanged) {
+        const storeState = getState();
+        const viewName = storeState.ui.navigation[storeState.ui.navigation.length - 1];
+        callbackOnViewChanged(viewName);
+    }
+    return res;
+};

package/es/actions/ui/next-slide.js

@@ -0,0 +1,33 @@
+import filter from 'lodash/fp/filter';
+import get from 'lodash/fp/get';
+import { fetchEndRank } from '../api/fetch-rank';
+import { fetchSlidesToReviewBySkillRef } from '../api/fetch-slides-to-review-by-skill-ref';
+import { fetchPropsVideo } from '../api/fetch-video-props';
+export const NEXT_SLIDE = '@@slide/NEXT_SLIDE';
+export const nextSlide = async (dispatch, getState) => {
+    const state = getState();
+    const progression = state.data.progression;
+    const { isCorrect, allAnswers, slides } = progression.state;
+    const correctAnswers = filter((answer) => answer.isCorrect, allAnswers);
+    const nextSlideRef = get(['state', 'nextContent', 'ref'], state.data.progression);
+    const payload = {
+        currentSlideRef: get(['ui', 'currentSlideRef'], state),
+        nextSlideRef,
+        animationType: isCorrect ? 'unstack' : 'restack',
+        totalCorrectAnswers: correctAnswers.length,
+        answeredSlides: slides
+    };
+    const action = {
+        type: NEXT_SLIDE,
+        payload
+    };
+    if (nextSlideRef === 'successExitNode') {
+        await dispatch(fetchEndRank);
+        await dispatch(fetchSlidesToReviewBySkillRef);
+        dispatch(action);
+    }
+    else {
+        dispatch(action);
+        await dispatch(fetchPropsVideo(payload.nextSlideRef));
+    }
+};

package/es/actions/ui/quit-popin.js

@@ -0,0 +1,8 @@
+export const OPEN_POPIN = '@@ui/OPEN_POPIN';
+export const CLOSE_POPIN = '@@ui/CLOSE_POPIN';
+export const openQuitPopin = {
+    type: OPEN_POPIN
+};
+export const closeQuitPopin = {
+    type: CLOSE_POPIN
+};

package/es/actions/ui/show-button-revising.js

@@ -0,0 +1,6 @@
+export const SHOW_BUTTON_REVISING = '@@button/SHOW_BUTTON_REVISING';
+export const showButtonRevising = (dispatch) => {
+    return dispatch({
+        type: SHOW_BUTTON_REVISING
+    });
+};

package/es/actions/ui/slides.js

@@ -0,0 +1,10 @@
+import { fetchPropsVideo } from '../api/fetch-video-props';
+export const SET_CURRENT_SLIDE = '@@slide/SET_CURRENT_SLIDE';
+export const setCurrentSlide = (slideFromAPI) => async (dispatch) => {
+    dispatch({
+        type: SET_CURRENT_SLIDE,
+        payload: slideFromAPI
+    });
+    await dispatch(fetchPropsVideo(slideFromAPI._id));
+    return;
+};

package/es/common/index.js

@@ -0,0 +1,10 @@
+import concat from 'lodash/fp/concat';
+import slice from 'lodash/fp/slice';
+export const slideIndexes = ['0', '1', '2', '3', '4'];
+export const getProgressionSlidesRefs = (progression) => {
+    if (progression.state.step.current <= 5) {
+        const slideRef = progression.state.nextContent.ref;
+        return concat(progression.state.slides, [slideRef]);
+    }
+    return slice(0, 5, progression.state.slides);
+};

package/es/configure-store.js

@@ -0,0 +1,26 @@
+import { applyMiddleware, compose, createStore } from 'redux';
+import thunk from 'redux-thunk';
+import { getServices } from '@coorpacademy/review-services';
+import { identity } from 'lodash/fp';
+import rootReducer from './reducers';
+export default function configureStore(options) {
+    const _compose = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
+        ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
+            name: 'app-review',
+            trace: true,
+            traceLimit: 25
+        })
+        : compose;
+    const locale = options.locale;
+    const thunkOptions = {
+        services: options.services || getServices(locale),
+        callbackOnViewChanged: options.callbackOnViewChanged,
+        appendVideoOptions: options.appendVideoOptions,
+        onStartProgression: options.onStartProgression || identity,
+        onEndProgression: options.onEndProgression || identity
+    };
+    const thunkMiddleware = thunk.withExtraArgument(thunkOptions);
+    const enhancer = _compose(applyMiddleware(thunkMiddleware));
+    const store = createStore(rootReducer, undefined, enhancer);
+    return store;
+}

package/es/helpers/css-register.js

@@ -0,0 +1,2 @@
+import cssRegister from '@coorpacademy/css-modules-require-hook';
+cssRegister();

package/es/index.js

@@ -0,0 +1,48 @@
+import React, { useEffect, useState } from 'react';
+import { useSelector, useDispatch, Provider } from 'react-redux';
+import AppReviewTemplate from '@coorpacademy/components/es/template/app-review';
+import isEmpty from 'lodash/fp/isEmpty';
+import get from 'lodash/fp/get';
+import configureStore from './configure-store';
+import { navigateBack, navigateTo } from './actions/ui/navigation';
+import { storeToken } from './actions/data/token';
+import { postProgression } from './actions/api/post-progression';
+import { mapStateToSlidesProps } from './views/slides';
+const ConnectedApp = (options) => {
+    const dispatch = useDispatch();
+    const props = {
+        viewName: useSelector((state) => state.ui.navigation[state.ui.navigation.length - 1]),
+        slides: useSelector((state) => mapStateToSlidesProps(state, dispatch, options)),
+        navigateBack: () => dispatch(navigateBack)
+    };
+    return React.createElement(AppReviewTemplate, { ...props });
+};
+const storeTokenAndCreateProgression = async (store, options) => {
+    const token = get('token', options);
+    if (store === null || isEmpty(token))
+        return;
+    store.dispatch(storeToken(token));
+    const skillRef = get('skillRef', options);
+    const testingSlideRef = get('testingSlideRef', options);
+    if (skillRef) {
+        store.dispatch(navigateTo('loader'));
+        await store.dispatch(postProgression(skillRef, testingSlideRef));
+        store.dispatch(navigateTo('slides'));
+    }
+};
+const AppReview = ({ options }) => {
+    const [store, setStore] = useState(null);
+    const { translate, onQuitClick, onStartProgression, onEndProgression, skin, backgroundImage } = options;
+    useEffect(() => {
+        const newStore = configureStore(options);
+        setStore(newStore);
+        storeTokenAndCreateProgression(newStore, options);
+        // should create store, store token and create progression only once on mount
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    if (!store)
+        return null;
+    return (React.createElement(Provider, { store: store },
+        React.createElement(ConnectedApp, { onQuitClick: onQuitClick, onStartProgression: onStartProgression, onEndProgression: onEndProgression, translate: translate, skin: skin, backgroundImage: backgroundImage })));
+};
+export default AppReview;

package/es/reducers/data/corrections.js

@@ -0,0 +1,25 @@
+import set from 'lodash/fp/set';
+import { CORRECTION_FETCH_SUCCESS, CORRECTION_FETCH_REQUEST } from '../../actions/api/fetch-correction';
+import { POST_PROGRESSION_REQUEST } from '../../actions/api/post-progression';
+const initialState = {};
+const reducer = (
+// eslint-disable-next-line default-param-last
+state = initialState, action) => {
+    switch (action.type) {
+        case CORRECTION_FETCH_REQUEST: {
+            const { meta } = action;
+            return set([meta.slideRef], null, state);
+        }
+        case CORRECTION_FETCH_SUCCESS: {
+            const { meta } = action;
+            const correction = action.payload;
+            return set([meta.slideRef], correction, state);
+        }
+        case POST_PROGRESSION_REQUEST: {
+            return initialState;
+        }
+        default:
+            return state;
+    }
+};
+export default reducer;

package/es/reducers/data/current-skill.js

@@ -0,0 +1,13 @@
+import { SKILL_FETCH_SUCCESS } from '../../actions/api/fetch-skill';
+const initialState = null;
+const reducer = (
+// eslint-disable-next-line default-param-last
+state = initialState, action) => {
+    switch (action.type) {
+        case SKILL_FETCH_SUCCESS:
+            return action.payload;
+        default:
+            return state;
+    }
+};
+export default reducer;

package/es/reducers/data/index.js

@@ -0,0 +1,17 @@
+import { combineReducers } from 'redux';
+import corrections from './corrections';
+import progression from './progression';
+import slides from './slides';
+import token from './token';
+import rank from './rank';
+import currentSkill from './current-skill';
+import videos from './videos';
+export default combineReducers({
+    corrections,
+    progression,
+    slides,
+    token,
+    rank,
+    currentSkill,
+    videos
+});

package/es/reducers/data/progression.js

@@ -0,0 +1,20 @@
+import { POST_ANSWER_SUCCESS } from '../../actions/api/post-answer';
+import { POST_PROGRESSION_REQUEST, POST_PROGRESSION_SUCCESS } from '../../actions/api/post-progression';
+const initialState = null;
+const reducer = (
+// eslint-disable-next-line default-param-last
+state = initialState, action) => {
+    switch (action.type) {
+        case POST_ANSWER_SUCCESS:
+        case POST_PROGRESSION_SUCCESS: {
+            const progression = action.payload;
+            return progression;
+        }
+        case POST_PROGRESSION_REQUEST: {
+            return initialState;
+        }
+        default:
+            return state;
+    }
+};
+export default reducer;

package/es/reducers/data/rank.js

@@ -0,0 +1,27 @@
+import set from 'lodash/fp/set';
+import { POST_PROGRESSION_REQUEST } from '../../actions/api/post-progression';
+import { RANK_FETCH_START_SUCCESS, RANK_FETCH_END_SUCCESS } from '../../actions/api/fetch-rank';
+const initialState = {
+    start: Number.NaN,
+    end: Number.NaN
+};
+const reducer = (
+// eslint-disable-next-line default-param-last
+state = initialState, action) => {
+    switch (action.type) {
+        case POST_PROGRESSION_REQUEST: {
+            return initialState;
+        }
+        case RANK_FETCH_START_SUCCESS: {
+            const { payload } = action;
+            return set('start', payload.rank, state);
+        }
+        case RANK_FETCH_END_SUCCESS: {
+            const { payload } = action;
+            return set('end', payload.rank, state);
+        }
+        default:
+            return state;
+    }
+};
+export default reducer;

package/es/reducers/data/slides.js

@@ -0,0 +1,20 @@
+import set from 'lodash/fp/set';
+import { SLIDE_FETCH_SUCCESS } from '../../actions/api/fetch-slide';
+import { POST_PROGRESSION_REQUEST } from '../../actions/api/post-progression';
+export const initialState = {};
+const reducer = (
+// eslint-disable-next-line default-param-last
+state = initialState, action) => {
+    switch (action.type) {
+        case SLIDE_FETCH_SUCCESS: {
+            const slide = action.payload;
+            return set([slide._id], slide, state);
+        }
+        case POST_PROGRESSION_REQUEST: {
+            return initialState;
+        }
+        default:
+            return state;
+    }
+};
+export default reducer;

package/es/reducers/data/token.js

@@ -0,0 +1,11 @@
+import { STORE_TOKEN } from '../../actions/data/token';
+// eslint-disable-next-line default-param-last
+const reducer = (state = '', action) => {
+    switch (action.type) {
+        case STORE_TOKEN:
+            return action.payload;
+        default:
+            return state;
+    }
+};
+export default reducer;

package/es/reducers/data/videos.js

@@ -0,0 +1,33 @@
+import { get, set } from 'lodash/fp';
+import { SET_VIDEO_PROPS, SHOW_VIDEO } from '../../actions/api/fetch-video-props';
+import { NEXT_SLIDE } from '../../actions/ui/next-slide';
+export const initialState = {};
+const reducer = (
+// eslint-disable-next-line default-param-last
+state = initialState, action) => {
+    switch (action.type) {
+        case SET_VIDEO_PROPS: {
+            const { slideId, props } = action.payload;
+            return set(slideId, props, state);
+        }
+        case NEXT_SLIDE: {
+            const { currentSlideRef } = action.payload;
+            const isMediaVideo = get(currentSlideRef, state);
+            if (isMediaVideo) {
+                return set([currentSlideRef, 'src', '0', 'loading'], true, state);
+            }
+            return state;
+        }
+        case SHOW_VIDEO: {
+            const { slideId } = action.payload;
+            const isMediaVideo = get(slideId, state);
+            if (isMediaVideo) {
+                return set([slideId, 'src', '0', 'loading'], false, state);
+            }
+            return state;
+        }
+        default:
+            return state;
+    }
+};
+export default reducer;