@coorpacademy/app-review 0.0.21-alpha.4 → 0.1.1

package/lib/fixtures/temp-fixture.js

@@ -0,0 +1,84 @@
+export var correctionPopinProps = {
+    klf: {
+        label: 'Key learning factor',
+        tooltip: 'Some tooltip info.',
+        onClick: function () {
+            console.log('klf onClick');
+        }
+    },
+    information: {
+        label: 'Key learning factor',
+        message: 'info msg'
+    },
+    next: {
+        label: 'Next',
+        ariaLabel: 'Next'
+    },
+    successLabel: 'CORRECT ANSWER',
+    failureLabel: 'WRONG ANSWER'
+};
+var confettiAnimationProps = {
+    'aria-label': 'aria lottie',
+    'data-name': 'default-lottie',
+    className: undefined,
+    animationSrc: 'https://static-staging.coorpacademy.com/animations/review/confetti.json',
+    loop: undefined,
+    autoplay: true,
+    rendererSettings: {
+        hideOnTransparent: false,
+        animationClassName: ''
+    },
+    ie11ImageBackup: 'https://static-staging.coorpacademy.com/animations/review/conffeti_congrats.svg',
+    animationControl: undefined
+};
+var starAnimationProps = {
+    'aria-label': 'Review Card Congrats Container',
+    'data-name': 'card-star',
+    animationLottie: {
+        'aria-label': 'aria lottie',
+        'data-name': 'default-lottie',
+        animationSrc: 'https://static-staging.coorpacademy.com/animations/review/star.json',
+        ie11ImageBackup: 'https://static-staging.coorpacademy.com/animations/review/stars_icon_congrats.svg'
+    },
+    iconAriaLabel: 'Image without information',
+    cardType: 'card-star',
+    reviewCardTitle: 'You have won',
+    reviewCardValue: '100',
+    timerAnimation: 200
+};
+var rankAnimationProps = {
+    'aria-label': 'Review Card Congrats Container',
+    'data-name': 'card-rank',
+    animationLottie: {
+        'aria-label': 'aria lottie',
+        'data-name': 'default-lottie',
+        animationSrc: 'https://static-staging.coorpacademy.com/animations/review/rank.json',
+        ie11ImageBackup: 'https://static-staging.coorpacademy.com/animations/review/rank_icon_congrats.svg'
+    },
+    cardType: 'card-rank',
+    iconAriaLabel: 'Image without information',
+    reviewCardTitle: 'You are now',
+    reviewCardValue: '14',
+    rankSuffix: 'th',
+    timerAnimation: 200
+};
+export var congratsProps = {
+    'aria-label': 'Review Congratulations',
+    'data-name': 'review-congrats',
+    animationLottie: confettiAnimationProps,
+    title: 'Congratulations!',
+    cardCongratsStar: starAnimationProps,
+    cardCongratsRank: rankAnimationProps,
+    buttonRevising: {
+        'aria-label': 'Continue revising button',
+        label: 'Continue revising',
+        onClick: function () { return console.log('Continue revising'); },
+        type: 'tertiary'
+    },
+    buttonRevisingSkill: {
+        label: 'Revise another skill',
+        'aria-label': 'Revise another skill button',
+        onClick: function () { return console.log('Revise another skill'); },
+        type: 'primary'
+    }
+};

package/lib/helpers/css-register.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/helpers/css-register.js

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

package/lib/index.d.ts

@@ -1,17 +1,10 @@
-/// <reference types="react" />
-declare const AppRevision: ({ options }: Props) => JSX.Element;
+import type { AppOptions } from './types/common';
+declare const AppReview: ({ options }: {
+    options: AppOptions;
+}) => JSX.Element;
 declare global {
     interface Window {
         __REDUX_DEVTOOLS_EXTENSION__?: boolean;
     }
 }
-declare type Props = {
-    options: AppOptions;
-};
-export declare type AppOptions = {
-    token: string;
-    theme?: any;
-    translations?: any;
-};
-export default AppRevision;
-//# sourceMappingURL=index.d.ts.map
+export default AppReview;

package/lib/index.js

@@ -1,14 +1,3 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -47,39 +36,87 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import React, { useEffect, useState } from 'react';
 import { connect, Provider } from 'react-redux';
-import AppReviewRootView from '@coorpacademy/components/es/template/app-review/root-view/root-view';
+import AppReviewTemplate from '@coorpacademy/components/es/template/app-review';
 import configureStore from './configure-store';
 import { navigateTo, navigateBack, startApp } from './actions/navigation';
+import { updateSlidesOnNext, updateSlidesOnValidation } from './actions/slides';
 import { getCurrentViewName } from './reducers/navigation';
+import { congratsProps, correctionPopinProps } from './fixtures/temp-fixture';
+import { updateFinishedSlides } from './actions/finished-slides';
+import { updateReviewStatus } from './actions/review-status';
+import { updateStepItemsOnValidation, updateStepItemsOnNext } from './actions/step-items';
+import { validateSlide } from './actions/data/validate-slide';
 // -----------------------------------------------------------------------------
-var mapStateToProps = function (state, ownProps) {
-    return __assign(__assign({}, ownProps), { viewName: getCurrentViewName(state) });
+var mapDispatchToProps = {
+    navigateTo: navigateTo,
+    navigateBack: navigateBack,
+    validateSlide: validateSlide,
+    updateSlidesOnValidation: updateSlidesOnValidation,
+    updateSlidesOnNext: updateSlidesOnNext,
+    updateReviewStatus: updateReviewStatus,
+    updateStepItemsOnValidation: updateStepItemsOnValidation,
+    updateStepItemsOnNext: updateStepItemsOnNext,
+    updateFinishedSlides: updateFinishedSlides
 };
-var mapDispatchToProps = { navigateTo: navigateTo, navigateBack: navigateBack };
-var App = connect(mapStateToProps, mapDispatchToProps)(AppReviewRootView);
+var mapStateToProps = function (state) {
+    return {
+        viewName: getCurrentViewName(state),
+        slides: {
+            headerProps: {
+                mode: '__revision_mode',
+                skillName: '__agility',
+                onQuitClick: function () {
+                    // eslint-disable-next-line no-console
+                    console.log('onQuitClick');
+                },
+                'aria-label': 'aria-header-wrapper',
+                closeButtonAriaLabel: 'aria-close-button'
+            },
+            slides: state.ui.slides,
+            validate: {
+                label: '__validate'
+            },
+            finishedSlides: state.ui.finishedSlides,
+            stepItems: state.ui.stepItems,
+            reviewStatus: state.ui.reviewStatus,
+            correctionPopinProps: correctionPopinProps,
+            congratsProps: congratsProps,
+            slideValidationResult: state.data.slideValidationResult
+        }
+    };
+};
+// Props = StaticProps && Dispatchers
+var App = connect(mapStateToProps, mapDispatchToProps)(AppReviewTemplate);
 // -----------------------------------------------------------------------------
-var AppRevision = function (_a) {
+var AppReview = function (_a) {
     var options = _a.options;
     var _b = useState(null), store = _b[0], setStore = _b[1];
+    var _c = useState(false), appStarted = _c[0], setAppStarted = _c[1];
     useEffect(function () {
-        var _configure = function () { return __awaiter(void 0, void 0, void 0, function () {
-            var store;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, configureStore()];
-                    case 1:
-                        store = _a.sent();
-                        store.dispatch(startApp(options));
-                        setStore(store);
-                        return [2 /*return*/];
-                }
-            });
-        }); };
-        _configure();
-    }, []);
-    if (!store)
+        if (store) {
+            store.dispatch(startApp(options));
+            setAppStarted(true);
+        }
+        else {
+            var _configure = function () { return __awaiter(void 0, void 0, void 0, function () {
+                var _store;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, configureStore()];
+                        case 1:
+                            _store = _a.sent();
+                            setStore(_store);
+                            return [2 /*return*/];
+                    }
+                });
+            }); };
+            _configure();
+        }
+    }, [options, store]);
+    if (!store || !appStarted)
         return null;
     return (React.createElement(Provider, { store: store },
         React.createElement(App, null)));
 };
-export default AppRevision;
+// -----------------------------------------------------------------------------
+export default AppReview;

package/lib/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.test.js

@@ -0,0 +1,160 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import browserEnv from 'browser-env';
+import test from 'ava';
+import React from 'react';
+import { render, fireEvent, act } from '@testing-library/react';
+import { slide } from './fixtures/qcm-slide';
+import AppReview from '.';
+browserEnv({ pretendToBeVisual: true });
+var elementExists = function (foundElements) {
+    return foundElements && foundElements[0];
+};
+var sleep = function (msToSleep) {
+    return new Promise(function (resolve) {
+        setTimeout(resolve, msToSleep);
+    });
+};
+var waitForChanges = function (msToWait) {
+    if (msToWait === void 0) { msToWait = 3000; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, sleep(msToWait)];
+                                case 1:
+                                    _a.sent(); // wait *just* a little longer than the timeout in the component
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+var LIMIT = 5;
+var clickAllSlides = function (t, container, accumulator) {
+    if (accumulator === void 0) { accumulator = 0; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var validateButton, nextButton;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (accumulator === LIMIT)
+                        return [2 /*return*/];
+                    if (!(accumulator === 4)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, sleep(1000)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    validateButton = container.querySelectorAll("[data-name=\"slide-validate-button-".concat(accumulator, "\"]"));
+                    t.truthy(elementExists(validateButton));
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, fireEvent.click(validateButton[0])];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 3:
+                    _a.sent();
+                    nextButton = container.querySelectorAll("[data-name=\"next-question-button-".concat(accumulator, "\"]"));
+                    t.truthy(elementExists(nextButton));
+                    return [4 /*yield*/, act(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, fireEvent.click(nextButton[0])];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                case 4:
+                    _a.sent();
+                    return [4 /*yield*/, clickAllSlides(t, container, accumulator + 1)];
+                case 5:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+};
+var appOptions = {
+    token: process.env.API_TEST_TOKEN || '',
+    slide: slide
+};
+test('should validate all the slides (all correct scenario)', function (t) { return __awaiter(void 0, void 0, void 0, function () {
+    var container, wrapper, stackedSlidesContainer;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                t.plan(13);
+                container = render(React.createElement(AppReview, { options: appOptions, key: 0 })).container;
+                return [4 /*yield*/, waitForChanges(1000)];
+            case 1:
+                _a.sent();
+                wrapper = container.querySelector('[data-name="slides-revision-container"]');
+                t.truthy(wrapper);
+                stackedSlidesContainer = wrapper.querySelector('[data-name="stacked-slides-container"]');
+                t.truthy(stackedSlidesContainer);
+                return [4 /*yield*/, clickAllSlides(t, container)];
+            case 2:
+                _a.sent();
+                t.pass();
+                return [2 /*return*/];
+        }
+    });
+}); });

package/lib/middlewares/on-start-app.d.ts

@@ -1,7 +1,6 @@
 import type { Middleware } from 'redux';
 import { Dispatch } from 'redux';
 import { Action } from '../actions';
-import { StoreState } from '../configure-store';
+import { StoreState } from '../types/store-state';
 declare const onStartApp: Middleware<{}, StoreState, Dispatch<Action>>;
 export default onStartApp;
-//# sourceMappingURL=on-start-app.d.ts.map

package/lib/middlewares/on-start-app.js

@@ -1,20 +1,33 @@
-import { receivedCourse, START_APP, storeToken } from '../actions';
-import fetchCourse from '../services/fetch-demo';
+// import fetchCourse from '../services/fetch-demo';
+import { VIEWS } from '../common';
+import { navigateTo, START_APP } from '../actions/navigation';
+import { storeToken } from '../actions/token';
+import { storeFirstSlide } from '../actions/slides';
 var onStartApp = function (_a) {
     var dispatch = _a.dispatch;
-    return function (next) { return function (action) {
-        if (action.type === START_APP) {
-            var token = action.payload.token;
-            dispatch(storeToken(token));
-            // --------------
-            // demo service
-            var language = 'fr';
-            var universalRef = 'dis_xxx15';
-            fetchCourse(token, language, universalRef).then(function (course) {
-                dispatch(receivedCourse(course));
-            });
-        }
-        return next(action);
-    }; };
+    return function (next) {
+        return function (action) {
+            if (action.type === START_APP) {
+                // eslint-disable-next-line no-warning-comments
+                // TODO: fetchProgression + fetchSlide à partir de la progression passée dans les options de l'app
+                var slide = action.payload.slide;
+                if (slide) {
+                    var token = action.payload.token;
+                    dispatch(storeToken(token));
+                    dispatch(storeFirstSlide(slide));
+                }
+                var initialView = slide ? VIEWS.slides : VIEWS.onboarding;
+                dispatch(navigateTo(initialView));
+                // --------------
+                // demo service
+                // const language = 'fr';
+                // const universalRef = 'dis_xxx15';
+                // fetchCourse(token, language, universalRef).then(course => {
+                //   dispatch(receivedCourse(course));
+                // });
+            }
+            return next(action);
+        };
+    };
 };
 export default onStartApp;

package/lib/reducers/courses.d.ts

@@ -1,6 +1,5 @@
-import { ReceivedCourse } from '../actions';
-export declare type State = Array<any>;
+import { ReceivedCourse } from '../actions/courses';
+export declare type State = Array<unknown>;
 export declare const initialState: State;
 declare const reducer: (state: State, action: ReceivedCourse) => State;
 export default reducer;
-//# sourceMappingURL=courses.d.ts.map

package/lib/reducers/courses.js

@@ -7,9 +7,10 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { RECEIVED_COURSE } from '../actions';
+import { RECEIVED_COURSE } from '../actions/courses';
 export var initialState = [];
 // -----------------------------------------------------------------------------
+// eslint-disable-next-line default-param-last
 var reducer = function (state, action) {
     if (state === void 0) { state = initialState; }
     switch (action.type) {

package/lib/reducers/data.d.ts

@@ -0,0 +1,7 @@
+import { StoreToken } from '../actions/token';
+import { IsFetching } from '../actions/data/is-fetching';
+import { ValidateSlide } from '../actions/data/validate-slide';
+import { DataState } from '../types/data';
+declare type ApiActions = IsFetching | ValidateSlide | StoreToken;
+declare const data: (state: DataState, action: ApiActions) => DataState;
+export default data;

package/lib/reducers/data.js

@@ -0,0 +1,77 @@
+import getOr from 'lodash/fp/getOr';
+import noop from 'lodash/fp/noop';
+import set from 'lodash/fp/set';
+import { STORE_TOKEN } from '../actions/token';
+import { IS_FETCHING_TRUE } from '../actions/data/is-fetching';
+import { VALIDATE_SLIDE } from '../actions/data/validate-slide';
+import { setToken } from './token';
+var defaultState = {
+    isFetching: true,
+    slideValidationResult: null,
+    token: null
+};
+// eslint-disable-next-line default-param-last
+var data = function (state, action) {
+    if (state === void 0) { state = defaultState; }
+    switch (action.type) {
+        case STORE_TOKEN: {
+            return setToken(action.payload, state);
+        }
+        case VALIDATE_SLIDE: {
+            var previousSlideNumber = getOr(-1, 'slideValidationResult.slideNumber', state);
+            // hard coded for now
+            return set('slideValidationResult', {
+                slideNumber: previousSlideNumber + 1,
+                result: 'success',
+                // exitNode
+                nextSlide: {
+                    questionText: 'Test',
+                    answerUI: {
+                        model: {
+                            answers: [
+                                {
+                                    title: 'There is no need for a password',
+                                    onClick: noop,
+                                    selected: false
+                                },
+                                {
+                                    title: 'Lorem ipsum',
+                                    onClick: noop,
+                                    selected: false
+                                },
+                                {
+                                    title: 'Lorem',
+                                    onClick: noop,
+                                    selected: true,
+                                    order: 1
+                                },
+                                {
+                                    title: 'You need to have a password',
+                                    onClick: noop,
+                                    selected: false
+                                },
+                                {
+                                    title: 'Pouet',
+                                    onClick: noop,
+                                    selected: true,
+                                    order: 0
+                                }
+                            ],
+                            type: 'qcmDrag'
+                        },
+                        help: 'Help text will appear here'
+                    }
+                }
+            }, state);
+        }
+        case IS_FETCHING_TRUE: {
+            return set('isFetching', true, state);
+        }
+        // case VALIDATE_SLIDE_FAILURE: {
+        //   return set('entities.isFetching', false, state);
+        // }
+        default:
+            return state;
+    }
+};
+export default data;

package/lib/reducers/finished-slides.d.ts

@@ -0,0 +1,6 @@
+import { UpdateFinishedSlides } from '../actions/finished-slides';
+import { FinishedSlides } from '../types/finished-slides';
+export declare type State = FinishedSlides;
+export declare const initialState: State;
+declare const reducer: (state: State, action: UpdateFinishedSlides) => State;
+export default reducer;

package/lib/reducers/finished-slides.js

@@ -0,0 +1,44 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import forEach from 'lodash/fp/forEach';
+import { UPDATE_FINISHED_SLIDES } from '../actions/finished-slides';
+import { slideNumbers } from '../common';
+var _forEach = forEach.convert({
+    cap: false
+});
+export var initialState = {
+    slideNumbers: slideNumbers
+};
+// -----------------------------------------------------------------------------
+// eslint-disable-next-line default-param-last
+var reducer = function (state, action) {
+    if (state === void 0) { state = initialState; }
+    switch (action.type) {
+        case UPDATE_FINISHED_SLIDES: {
+            var _slideNumbers = state.slideNumbers, rest = __rest(state, ["slideNumbers"]);
+            var _a = action.payload, slideNumber = _a.slideNumber, value = _a.value;
+            var _state_1 = {
+                slideNumbers: _slideNumbers
+            };
+            _forEach(function (finishedSlide, index) {
+                var previousValue = finishedSlide;
+                _state_1[index] = previousValue;
+            }, rest);
+            _state_1[slideNumber] = value;
+            return _state_1;
+        }
+        default:
+            return state;
+    }
+};
+// -----------------------------------------------------------------------------
+export default reducer;

package/lib/reducers/index.d.ts

@@ -1,7 +1,12 @@
-declare const rootReducer: import("redux").Reducer<import("redux").CombinedState<{
-    courses: import("./courses").State;
-    navigation: import("./navigation").State;
-    token: string;
+declare const _default: import("redux").Reducer<import("redux").CombinedState<{
+    ui: import("redux").CombinedState<{
+        courses: import("./courses").State;
+        finishedSlides: import("../types/finished-slides").FinishedSlides;
+        navigation: import("../types/states").NavigationState;
+        reviewStatus: import("./review-status").State;
+        slides: import("../types/slides").Slides;
+        stepItems: import("../types/step-items").StepItems;
+    }>;
+    data: import("../types/data").DataState;
 }>, import("redux").AnyAction>;
-export default rootReducer;
-//# sourceMappingURL=index.d.ts.map
+export default _default;