@coorpacademy/app-review 0.0.21-alpha.8 → 0.1.2

package/lib/index.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="react" />
-import { AppOptions } from './types/common';
+import type { AppOptions } from './types/common';
 declare const AppReview: ({ options }: {
     options: AppOptions;
 }) => JSX.Element;
@@ -9,4 +8,3 @@ declare global {
     }
 }
 export default AppReview;
-//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -34,22 +34,6 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 import React, { useEffect, useState } from 'react';
 import { connect, Provider } from 'react-redux';
 import AppReviewTemplate from '@coorpacademy/components/es/template/app-review';
@@ -57,11 +41,11 @@ 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 './temp-fixture';
+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/api/validate-slide';
+import { validateSlide } from './actions/data/validate-slide';
 // -----------------------------------------------------------------------------
 var mapDispatchToProps = {
     navigateTo: navigateTo,
@@ -74,49 +58,65 @@ var mapDispatchToProps = {
     updateStepItemsOnNext: updateStepItemsOnNext,
     updateFinishedSlides: updateFinishedSlides
 };
-// StaticProps
-var mapStateToProps = function (state) { return ({
-    viewName: getCurrentViewName(state),
-    slides: {
-        slides: state.slides,
-        validate: {
-            label: '__validate'
-        },
-        finishedSlides: state.finishedSlides,
-        stepItems: state.stepItems,
-        reviewStatus: state.reviewStatus,
-        correctionPopinProps: correctionPopinProps,
-        congratsProps: congratsProps,
-        slideValidationResult: state.api.entities.slideValidationResult
-    }
-}); };
+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 AppReview = function (_a) {
     var options = _a.options;
-    var _b = __read(useState(null), 2), store = _b[0], setStore = _b[1];
+    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();
-    }, [options]);
-    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)));
 };
-// type Props = {options: AppOptions};
 // -----------------------------------------------------------------------------
 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

@@ -4,4 +4,3 @@ import { Action } from '../actions';
 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

@@ -8,6 +8,8 @@ var onStartApp = function (_a) {
     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;

package/lib/reducers/courses.d.ts

@@ -3,4 +3,3 @@ 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

@@ -1,19 +1,3 @@
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
         if (ar || !(i in from)) {
@@ -31,7 +15,7 @@ var reducer = function (state, action) {
     if (state === void 0) { state = initialState; }
     switch (action.type) {
         case RECEIVED_COURSE: {
-            return __spreadArray(__spreadArray([], __read(state), false), [action.payload], false);
+            return __spreadArray(__spreadArray([], state, true), [action.payload], false);
         }
         default:
             return state;

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/{api.js → data.js}

@@ -1,19 +1,26 @@
 import getOr from 'lodash/fp/getOr';
 import noop from 'lodash/fp/noop';
 import set from 'lodash/fp/set';
-import { IS_FETCHING_TRUE } from '../actions/api/is-fetching';
-import { VALIDATE_SLIDE } from '../actions/api/validate-slide';
+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 = {
-    entities: { isFetching: true, slideValidationResult: null }
+    isFetching: true,
+    slideValidationResult: null,
+    token: null
 };
 // eslint-disable-next-line default-param-last
-var api = function (state, action) {
+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, 'entities.slideValidationResult.slideNumber', state);
+            var previousSlideNumber = getOr(-1, 'slideValidationResult.slideNumber', state);
             // hard coded for now
-            return set(['entities', 'slideValidationResult'], {
+            return set('slideValidationResult', {
                 slideNumber: previousSlideNumber + 1,
                 result: 'success',
                 // exitNode
@@ -58,7 +65,7 @@ var api = function (state, action) {
             }, state);
         }
         case IS_FETCHING_TRUE: {
-            return set('entities.isFetching', true, state);
+            return set('isFetching', true, state);
         }
         // case VALIDATE_SLIDE_FAILURE: {
         //   return set('entities.isFetching', false, state);
@@ -67,4 +74,4 @@ var api = function (state, action) {
             return state;
     }
 };
-export default api;
+export default data;

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

@@ -2,6 +2,5 @@ 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: FinishedSlides, action: UpdateFinishedSlides) => FinishedSlides;
+declare const reducer: (state: State, action: UpdateFinishedSlides) => State;
 export default reducer;
-//# sourceMappingURL=finished-slides.d.ts.map

package/lib/reducers/finished-slides.js

@@ -1,57 +1,40 @@
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
+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]];
         }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
+    return t;
 };
+import forEach from 'lodash/fp/forEach';
 import { UPDATE_FINISHED_SLIDES } from '../actions/finished-slides';
-export var initialState = new Map();
+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) {
-    var e_1, _a;
     if (state === void 0) { state = initialState; }
     switch (action.type) {
         case UPDATE_FINISHED_SLIDES: {
-            var _b = action.payload, slideNumber = _b.slideNumber, value = _b.value;
-            var _state = new Map();
-            try {
-                // eslint-disable-next-line fp/no-loops
-                for (var state_1 = __values(state), state_1_1 = state_1.next(); !state_1_1.done; state_1_1 = state_1.next()) {
-                    var _c = __read(state_1_1.value, 2), index = _c[0], previousValue = _c[1];
-                    _state.set(index, previousValue);
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (state_1_1 && !state_1_1.done && (_a = state_1.return)) _a.call(state_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            _state.set(slideNumber, value);
-            return _state;
+            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;

package/lib/reducers/index.d.ts

@@ -1,17 +1,12 @@
 declare const _default: import("redux").Reducer<import("redux").CombinedState<{
-    api: import("../types/api").ApiState | {
-        entities: {
-            isFetching: boolean;
-            slideValidationResult: any;
-        };
-    };
-    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;
-    token: string;
+    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 _default;
-//# sourceMappingURL=index.d.ts.map

package/lib/reducers/index.js

@@ -1,19 +1,20 @@
 import { combineReducers } from 'redux';
-import api from './api';
+import data from './data';
 import courses from './courses';
 import finishedSlides from './finished-slides';
 import navigation from './navigation';
 import reviewStatus from './review-status';
 import slides from './slides';
 import stepItems from './step-items';
-import token from './token';
-export default combineReducers({
-    api: api,
+var ui = combineReducers({
     courses: courses,
     finishedSlides: finishedSlides,
     navigation: navigation,
     reviewStatus: reviewStatus,
     slides: slides,
-    stepItems: stepItems,
-    token: token
+    stepItems: stepItems
+});
+export default combineReducers({
+    ui: ui,
+    data: data
 });

package/lib/reducers/navigation.d.ts

@@ -6,4 +6,3 @@ export declare const initialState: State;
 declare const reducer: (state: State, action: NavigateTo | NavigateBack) => State;
 export declare const getCurrentViewName: (appState: StoreState) => ViewPath;
 export default reducer;
-//# sourceMappingURL=navigation.d.ts.map

package/lib/reducers/navigation.js

@@ -1,19 +1,3 @@
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
 var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
         if (ar || !(i in from)) {
@@ -33,10 +17,10 @@ var reducer = function (state, action) {
     if (state === void 0) { state = initialState; }
     switch (action.type) {
         case NAVIGATE_TO: {
-            return __spreadArray(__spreadArray([], __read(state), false), [action.payload], false);
+            return __spreadArray(__spreadArray([], state, true), [action.payload], false);
         }
         case NAVIGATE_BACK: {
-            var newState = __spreadArray([], __read(state), false);
+            var newState = __spreadArray([], state, true);
             newState.pop();
             return newState;
         }
@@ -46,7 +30,7 @@ var reducer = function (state, action) {
 };
 // -----------------------------------------------------------------------------
 export var getCurrentViewName = function (appState) {
-    return appState.navigation[appState.navigation.length - 1];
+    return appState.ui.navigation[appState.ui.navigation.length - 1];
 };
 // -----------------------------------------------------------------------------
 export default reducer;

package/lib/reducers/review-status.d.ts

@@ -3,4 +3,3 @@ export declare type State = 'finished' | 'ongoing';
 export declare const initialState: State;
 declare const reducer: (state: State, action: UpdateReviewStatus) => State;
 export default reducer;
-//# sourceMappingURL=review-status.d.ts.map

package/lib/reducers/slides.d.ts

@@ -2,6 +2,5 @@ import { SlidesAction } from '../actions/slides';
 import { Slides } from '../types/slides';
 export declare type State = Slides;
 export declare const initialState: State;
-declare const reducer: (state: Slides, action: SlidesAction) => Slides;
+declare const reducer: (state: State, action: SlidesAction) => State;
 export default reducer;
-//# sourceMappingURL=slides.d.ts.map