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

package/lib/reducers/index.js

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

package/lib/reducers/navigation.d.ts

@@ -1,7 +1,8 @@
+import { ViewPath } from '../actions/navigation';
 import type { NavigateTo, NavigateBack } from '../actions/navigation';
-export declare type State = Array<string>;
+import { StoreState } from '../types/store-state';
+import { NavigationState as State } from '../types/states';
 export declare const initialState: State;
 declare const reducer: (state: State, action: NavigateTo | NavigateBack) => State;
-export declare const getCurrentViewName: (appState: any) => any;
+export declare const getCurrentViewName: (appState: StoreState) => ViewPath;
 export default reducer;
-//# sourceMappingURL=navigation.d.ts.map

package/lib/reducers/navigation.js

@@ -8,8 +8,11 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { NAVIGATE_BACK, NAVIGATE_TO } from '../actions/navigation';
+// -----------------------------------------------------------------------------
+// export type State = Array<string>;
 export var initialState = ['home'];
 // -----------------------------------------------------------------------------
+// eslint-disable-next-line default-param-last
 var reducer = function (state, action) {
     if (state === void 0) { state = initialState; }
     switch (action.type) {
@@ -26,6 +29,8 @@ var reducer = function (state, action) {
     }
 };
 // -----------------------------------------------------------------------------
-export var getCurrentViewName = function (appState) { return appState.navigation[appState.navigation.length - 1]; };
+export var getCurrentViewName = function (appState) {
+    return appState.ui.navigation[appState.ui.navigation.length - 1];
+};
 // -----------------------------------------------------------------------------
 export default reducer;

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

@@ -0,0 +1,5 @@
+import { UpdateReviewStatus } from '../actions/review-status';
+export declare type State = 'finished' | 'ongoing';
+export declare const initialState: State;
+declare const reducer: (state: State, action: UpdateReviewStatus) => State;
+export default reducer;

package/lib/reducers/review-status.js

@@ -0,0 +1,16 @@
+import { UPDATE_REVIEW_STATUS } from '../actions/review-status';
+export var initialState = 'ongoing';
+// -----------------------------------------------------------------------------
+// eslint-disable-next-line default-param-last
+var reducer = function (state, action) {
+    if (state === void 0) { state = initialState; }
+    switch (action.type) {
+        case UPDATE_REVIEW_STATUS: {
+            return action.payload;
+        }
+        default:
+            return state;
+    }
+};
+// -----------------------------------------------------------------------------
+export default reducer;

package/lib/reducers/slides.d.ts

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

package/lib/reducers/slides.js

@@ -0,0 +1,119 @@
+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);
+};
+import map from 'lodash/fp/map';
+import { STORE_FIRST_SLIDE, UPDATE_SLIDES_ON_NEXT, UPDATE_SLIDES_ON_VALIDATION } from '../actions/slides';
+import { HIGHEST_INDEX, slideNumbers, TOTAL_SLIDES_STACK } from '../common';
+var getInitialState = function () {
+    var state = {
+        slideNumbers: slideNumbers
+    };
+    // eslint-disable-next-line fp/no-loops
+    for (var index = 0; index < TOTAL_SLIDES_STACK; index++) {
+        state[index] = { hidden: false, position: index };
+    }
+    return state;
+};
+export var initialState = getInitialState();
+// -----------------------------------------------------------------------------
+var setFirstSlide = function (state, slide) {
+    var _state = {
+        slideNumbers: slideNumbers
+    };
+    // eslint-disable-next-line lodash-fp/no-unused-result
+    map(function (index) {
+        var previousValue = state[index];
+        // Only update the 1st one
+        var content = index === 0 ? __assign(__assign({}, previousValue), slide) : __assign({}, previousValue);
+        _state[index] = __assign({}, content);
+    }, state.slideNumbers);
+    return _state;
+};
+// ||-------> Handles the updates of a given slide on validation,
+// & then updates de remaining slides if this given change should impact their content
+var stateUpdateOnValidation = function (state, payload) {
+    var slideNumber = payload.slideNumber, newSlideContent = payload.newSlideContent, numberOfFinishedSlides = payload.numberOfFinishedSlides, nextSlide = payload.nextSlide;
+    var _state = {
+        slideNumbers: slideNumbers
+    };
+    // eslint-disable-next-line lodash-fp/no-unused-result
+    map(function (index) {
+        var previousValue = state[index];
+        // the current slide
+        if (index === slideNumber) {
+            // only one slide remaining, presets the next value
+            if (numberOfFinishedSlides === HIGHEST_INDEX) {
+                _state[index] = __assign(__assign({}, previousValue), { nextSlide: nextSlide, position: newSlideContent.position, validationResult: newSlideContent.validationResult });
+            }
+            else
+                _state[slideNumber] = __assign(__assign({}, previousValue), newSlideContent);
+        }
+        else {
+            // updates the rest of the slides here
+            var hidden = previousValue.hidden, position = previousValue.position;
+            _state[index] = __assign(__assign({}, nextSlide), { endReview: newSlideContent.endReview, hidden: hidden, position: position });
+        }
+    }, state.slideNumbers);
+    return _state;
+};
+// ||-------> Handles the updates of a given slide on correction popin's next click,
+// & then updates de remaining slides (updates position to trigger animations)
+var stateUpdateOnNext = function (state, payload) {
+    var slideNumber = payload.slideNumber, newSlideContent = payload.newSlideContent, numberOfFinishedSlides = payload.numberOfFinishedSlides;
+    var _state = {
+        slideNumbers: slideNumbers
+    };
+    // eslint-disable-next-line lodash-fp/no-unused-result
+    map(function (index) {
+        var previousValue = state[index];
+        // the current slide
+        if (index === slideNumber) {
+            // when there is only one slide remaining, updates the slide value
+            if (numberOfFinishedSlides === HIGHEST_INDEX && previousValue.nextSlide) {
+                _state[index] = __assign(__assign({}, previousValue.nextSlide), { position: previousValue.position });
+            }
+            else
+                _state[slideNumber] = newSlideContent;
+        }
+        else {
+            // updates the rest of the slides here
+            var hidden = previousValue.hidden, position = previousValue.position, answerUI = previousValue.answerUI, questionText = previousValue.questionText;
+            _state[index] = {
+                hidden: hidden,
+                position: position - 1,
+                answerUI: answerUI,
+                questionText: questionText,
+                endReview: newSlideContent.endReview
+            };
+        }
+    }, state.slideNumbers);
+    return _state;
+};
+// -----------------------------------------------------------------------------
+// eslint-disable-next-line default-param-last
+var reducer = function (state, action) {
+    if (state === void 0) { state = initialState; }
+    switch (action.type) {
+        case STORE_FIRST_SLIDE: {
+            return setFirstSlide(state, action.payload);
+        }
+        case UPDATE_SLIDES_ON_VALIDATION: {
+            return stateUpdateOnValidation(state, action.payload);
+        }
+        case UPDATE_SLIDES_ON_NEXT: {
+            return stateUpdateOnNext(state, action.payload);
+        }
+        default:
+            return state;
+    }
+};
+// -----------------------------------------------------------------------------
+export default reducer;

package/lib/reducers/step-items.d.ts

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

package/lib/reducers/step-items.js

@@ -0,0 +1,87 @@
+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);
+};
+import isNil from 'lodash/fp/isNil';
+import get from 'lodash/fp/get';
+import has from 'lodash/fp/has';
+import map from 'lodash/fp/map';
+import { UPDATE_STEP_ITEMS_ON_NEXT, UPDATE_STEP_ITEMS_ON_VALIDATION } from '../actions/step-items';
+import { HIGHEST_INDEX, slideNumbers, TOTAL_SLIDES_STACK } from '../common';
+var getInitialState = function () {
+    var state = {
+        slideNumbers: slideNumbers
+    };
+    // eslint-disable-next-line fp/no-loops
+    for (var index = 0; index < TOTAL_SLIDES_STACK; index++) {
+        var current = index === 0;
+        state[index] = { current: current, value: "".concat(index + 1), icon: null };
+    }
+    return state;
+};
+export var initialState = getInitialState();
+// -----------------------------------------------------------------------------
+// ||-------> aux function, finds the next consecutive index
+// to loop from 0 to HIGHEST_INDEX (4) & again to 0
+var getNextIndex = function (currentIndex) {
+    return currentIndex === HIGHEST_INDEX ? 0 : currentIndex + 1;
+};
+// ||-------> calculates which should be the next step to visit (as there can be already answered slides &&
+// they have to be skipped)
+var calculateNextStepIndex = function (currentStepNumber, finishedSlides, lastVisitedIndex) {
+    if (lastVisitedIndex === void 0) { lastVisitedIndex = null; }
+    // only one slide remaining, the step should stay on the same number
+    if (lastVisitedIndex === currentStepNumber) {
+        return currentStepNumber;
+    }
+    var indexToVisit = getNextIndex(isNil(lastVisitedIndex) ? currentStepNumber : lastVisitedIndex);
+    // if the index is already included in the correctly answered (finished) slides, then we proceed to check for the next one
+    return has(indexToVisit, finishedSlides)
+        ? calculateNextStepIndex(currentStepNumber, finishedSlides, indexToVisit)
+        : indexToVisit;
+};
+var recalculateStepItemsState = function (state, stepNumber, stepItemToUpdateProps) {
+    var nextIndex = get('nextIndex', stepItemToUpdateProps);
+    var _state = {
+        slideNumbers: slideNumbers
+    };
+    // eslint-disable-next-line lodash-fp/no-unused-result
+    map(function (index) {
+        var previousValue = state[index];
+        if (stepNumber === index)
+            _state[stepNumber] = __assign(__assign({}, previousValue), stepItemToUpdateProps);
+        /* only for UPDATE_STEP_ITEMS_ON_NEXT -> */ else if (nextIndex === index) {
+            _state[index] = __assign(__assign({}, previousValue), { current: true });
+        }
+        else
+            _state[index] = previousValue;
+    }, state.slideNumbers);
+    return _state;
+};
+// -----------------------------------------------------------------------------
+// eslint-disable-next-line default-param-last
+var reducer = function (state, action) {
+    if (state === void 0) { state = initialState; }
+    switch (action.type) {
+        case UPDATE_STEP_ITEMS_ON_VALIDATION: {
+            var _a = action.payload, stepNumber = _a.stepNumber, icon = _a.icon;
+            return recalculateStepItemsState(state, stepNumber, { icon: icon });
+        }
+        case UPDATE_STEP_ITEMS_ON_NEXT: {
+            var _b = action.payload, stepNumber = _b.stepNumber, finishedSlides = _b.finishedSlides, current = _b.current;
+            var nextIndex = !current ? calculateNextStepIndex(stepNumber, finishedSlides) : null;
+            return recalculateStepItemsState(state, stepNumber, { current: current, nextIndex: nextIndex });
+        }
+        default:
+            return state;
+    }
+};
+// -----------------------------------------------------------------------------
+export default reducer;

package/lib/reducers/token.d.ts

@@ -1,7 +1,5 @@
-import { StoreToken } from '../actions';
-export declare type State = string;
-export declare const initialState: State;
-declare const reducer: (state: State, action: StoreToken) => State;
-export declare const getToken: (appState: any) => any;
-export default reducer;
-//# sourceMappingURL=token.d.ts.map
+import { StoreState } from '../types/store-state';
+import { DataState } from '../types/data';
+export declare const initialState: DataState['token'];
+export declare const setToken: (token: string, state: DataState) => DataState;
+export declare const getToken: (appState: StoreState) => StoreState['data']['token'];

package/lib/reducers/token.js

@@ -1,17 +1,8 @@
-import { STORE_TOKEN } from '../actions';
+import set from 'lodash/fp/set';
+// -----------------------------------------------------------------------------
 export var initialState = null;
 // -----------------------------------------------------------------------------
-var reducer = function (state, action) {
-    if (state === void 0) { state = initialState; }
-    switch (action.type) {
-        case STORE_TOKEN: {
-            return action.payload;
-        }
-        default:
-            return state;
-    }
-};
+export var setToken = function (token, state) { return set('token', token, state); };
 // -----------------------------------------------------------------------------
-export var getToken = function (appState) { return appState.token; };
+export var getToken = function (appState) { return appState.data.token; };
 // -----------------------------------------------------------------------------
-export default reducer;

package/lib/services/fetch-demo.d.ts

@@ -9,4 +9,3 @@ export declare type CatalogHits = {
 export { fetchCourse };
 declare const _default: (token: any, language: any, universalRef: any) => Promise<Course>;
 export default _default;
-//# sourceMappingURL=fetch-demo.d.ts.map

package/lib/services/fetch-demo.js

@@ -46,29 +46,31 @@ var buildUrlQueryParams = function (params) {
         .join('&');
 };
 // -----------------------------------------------------------------------------
-var fetchCourse = function (fetch) { return function (token, language, universalRef) { return __awaiter(void 0, void 0, void 0, function () {
-    var jwt, query, response, hits;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                jwt = decode(token);
-                query = {
-                    type: 'course',
-                    universalRef: universalRef,
-                    lang: language
-                };
-                return [4 /*yield*/, fetch("".concat(jwt.host, "/api/v2/contents?").concat(buildUrlQueryParams(query)), {
-                        headers: { authorization: token }
-                    })];
-            case 1:
-                response = _a.sent();
-                return [4 /*yield*/, toJSON(response)];
-            case 2:
-                hits = (_a.sent()).hits;
-                return [2 /*return*/, hits === null || hits === void 0 ? void 0 : hits[0]];
-        }
-    });
-}); }; };
+var fetchCourse = function (fetch) {
+    return function (token, language, universalRef) { return __awaiter(void 0, void 0, void 0, function () {
+        var jwt, query, response, hits;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    jwt = decode(token);
+                    query = {
+                        type: 'course',
+                        universalRef: universalRef,
+                        lang: language
+                    };
+                    return [4 /*yield*/, fetch("".concat(jwt.host, "/api/v2/contents?").concat(buildUrlQueryParams(query)), {
+                            headers: { authorization: token }
+                        })];
+                case 1:
+                    response = _a.sent();
+                    return [4 /*yield*/, toJSON(response)];
+                case 2:
+                    hits = (_a.sent()).hits;
+                    return [2 /*return*/, hits === null || hits === void 0 ? void 0 : hits[0]];
+            }
+        });
+    }); };
+};
 // -----------------------------------------------------------------------------
 export { fetchCourse };
 export default fetchCourse(crossFetch);

package/lib/services/fetch-demo.test.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=fetch-demo.test.d.ts.map

package/lib/services/fetch-responses.d.ts

@@ -1,4 +1,4 @@
-export declare type Response = {
+export declare type _Response = {
     ok: boolean;
     status: number;
     statusText: string;
@@ -9,12 +9,11 @@ export declare type Fetch = (url?: string, options?: {
     headers: {
         authorization: string;
     };
-}) => Promise<Response>;
+}) => Promise<_Response>;
 export declare class ResponseError extends Error {
     statusCode: number;
-    constructor(status: number, statusText: string, body?: string);
+    constructor(statusCode: number, statusText: string, body?: string);
 }
-export declare const toJSON: (response: Response) => Promise<unknown>;
-export declare const toText: (response: Response) => Promise<string>;
-export declare const toVoid: (response: Response) => Promise<void>;
-//# sourceMappingURL=fetch-responses.d.ts.map
+export declare const toJSON: (response: _Response) => Promise<unknown>;
+export declare const toText: (response: _Response) => Promise<string>;
+export declare const toVoid: (response: _Response) => Promise<void>;

package/lib/services/fetch-responses.js

@@ -51,11 +51,11 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 var ResponseError = /** @class */ (function (_super) {
     __extends(ResponseError, _super);
-    function ResponseError(status, statusText, body) {
+    function ResponseError(statusCode, statusText, body) {
         if (body === void 0) { body = ''; }
         var _this = _super.call(this, "".concat(statusText, " ").concat(body).trim()) || this;
         _this.name = 'ResponseError';
-        _this.statusCode = status;
+        _this.statusCode = statusCode;
         return _this;
     }
     return ResponseError;

package/lib/services/fetch.mocks.d.ts

@@ -1,10 +1,9 @@
-import { Response } from './fetch-responses';
-export declare const toResponse: (status: number, statusText: string, body: string) => Promise<Response>;
-declare type FetchFunction = () => Promise<Response>;
+import { _Response } from './fetch-responses';
+export declare const toResponse: (statusCode: number, statusText: string, body: string) => Promise<_Response>;
+declare type FetchFunction = () => Promise<_Response>;
 export declare const okJSONResponse: (body: unknown) => FetchFunction;
 export declare const internalServerErrorJSONResponse: (body: unknown) => FetchFunction;
 export declare const notFoundJSONResponse: (body: unknown) => FetchFunction;
 export declare const okTextResponse: (body: string) => FetchFunction;
 export declare const internalServerErrorTextResponse: (body: string) => FetchFunction;
 export {};
-//# sourceMappingURL=fetch.mocks.d.ts.map

package/lib/services/fetch.mocks.js

@@ -1,22 +1,34 @@
-export var toResponse = function (status, statusText, body) {
+export var toResponse = function (statusCode, statusText, body) {
     return Promise.resolve({
-        ok: status < 400,
-        status: status,
+        ok: statusCode < 400,
+        status: statusCode,
         statusText: statusText,
         json: function () { return Promise.resolve(body).then(JSON.parse); },
         text: function () { return Promise.resolve(body); }
     });
 };
-export var okJSONResponse = function (body) { return function () {
-    return toResponse(200, 'OK', JSON.stringify(body));
-}; };
-export var internalServerErrorJSONResponse = function (body) { return function () {
-    return toResponse(500, 'InternalServerError', JSON.stringify(body));
-}; };
-export var notFoundJSONResponse = function (body) { return function () {
-    return toResponse(404, 'Not Found', JSON.stringify(body));
-}; };
-export var okTextResponse = function (body) { return function () { return toResponse(200, 'OK', body); }; };
-export var internalServerErrorTextResponse = function (body) { return function () {
-    return toResponse(500, 'InternalServerError', body);
-}; };
+export var okJSONResponse = function (body) {
+    return function () {
+        return toResponse(200, 'OK', JSON.stringify(body));
+    };
+};
+export var internalServerErrorJSONResponse = function (body) {
+    return function () {
+        return toResponse(500, 'InternalServerError', JSON.stringify(body));
+    };
+};
+export var notFoundJSONResponse = function (body) {
+    return function () {
+        return toResponse(404, 'Not Found', JSON.stringify(body));
+    };
+};
+export var okTextResponse = function (body) {
+    return function () {
+        return toResponse(200, 'OK', body);
+    };
+};
+export var internalServerErrorTextResponse = function (body) {
+    return function () {
+        return toResponse(500, 'InternalServerError', body);
+    };
+};

package/lib/types/common.d.ts

@@ -0,0 +1,7 @@
+import { Slide } from './slides';
+export declare type AppOptions = {
+    token: string;
+    theme?: unknown;
+    translations?: unknown;
+    slide?: Slide;
+};

package/lib/types/common.js

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

package/lib/types/data/index.d.ts

@@ -0,0 +1,14 @@
+import { AnswerUI } from '../slides';
+export declare type DataState = {
+    isFetching?: boolean;
+    slideValidationResult?: {
+        slideNumber: number;
+        result: 'success' | 'failure';
+        exitNode?: 'successExitNode' | 'failExitNode';
+        nextSlide: {
+            questionText?: string;
+            answerUI?: AnswerUI;
+        };
+    };
+    token?: string;
+};

package/lib/types/data/index.js

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

package/lib/types/dispatchers.d.ts

@@ -0,0 +1,17 @@
+import { validateSlide } from '../actions/data/validate-slide';
+import { updateFinishedSlides } from '../actions/finished-slides';
+import { navigateBack, navigateTo } from '../actions/navigation';
+import { updateReviewStatus } from '../actions/review-status';
+import { updateSlidesOnValidation, updateSlidesOnNext } from '../actions/slides';
+import { updateStepItemsOnValidation, updateStepItemsOnNext } from '../actions/step-items';
+export declare type Dispatchers = {
+    navigateTo: typeof navigateTo;
+    navigateBack: typeof navigateBack;
+    validateSlide: typeof validateSlide;
+    updateSlidesOnValidation: typeof updateSlidesOnValidation;
+    updateSlidesOnNext: typeof updateSlidesOnNext;
+    updateReviewStatus: typeof updateReviewStatus;
+    updateStepItemsOnValidation: typeof updateStepItemsOnValidation;
+    updateStepItemsOnNext: typeof updateStepItemsOnNext;
+    updateFinishedSlides: typeof updateFinishedSlides;
+};

package/lib/types/dispatchers.js

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

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

@@ -0,0 +1,9 @@
+import { SlideNumber } from './slides';
+export declare type FinishedSlides = {
+    slideNumbers: SlideNumber[];
+    [key: SlideNumber]: true;
+};
+export declare type UpdateFinishedSlidesPayload = {
+    slideNumber: SlideNumber;
+    value: true;
+};

package/lib/types/finished-slides.js

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

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

@@ -0,0 +1 @@
+export declare type UpdateReviewStatusPayload = 'finished';

package/lib/types/review-status.js

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