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

package/es/reducers/data.js

@@ -0,0 +1,76 @@
+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';
+const defaultState = {
+    isFetching: true,
+    slideValidationResult: null,
+    token: null
+};
+// eslint-disable-next-line default-param-last
+const data = (state = defaultState, action) => {
+    switch (action.type) {
+        case STORE_TOKEN: {
+            return setToken(action.payload, state);
+        }
+        case VALIDATE_SLIDE: {
+            const 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/es/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/es/reducers/finished-slides.js

@@ -0,0 +1,32 @@
+import forEach from 'lodash/fp/forEach';
+import { UPDATE_FINISHED_SLIDES } from '../actions/finished-slides';
+import { slideNumbers } from '../common';
+const _forEach = forEach.convert({
+    cap: false
+});
+export const initialState = {
+    slideNumbers
+};
+// -----------------------------------------------------------------------------
+// eslint-disable-next-line default-param-last
+const reducer = (state = initialState, action) => {
+    switch (action.type) {
+        case UPDATE_FINISHED_SLIDES: {
+            const { slideNumbers: _slideNumbers, ...rest } = state;
+            const { slideNumber, value } = action.payload;
+            const _state = {
+                slideNumbers: _slideNumbers
+            };
+            _forEach((finishedSlide, index) => {
+                const previousValue = finishedSlide;
+                _state[index] = previousValue;
+            }, rest);
+            _state[slideNumber] = value;
+            return _state;
+        }
+        default:
+            return state;
+    }
+};
+// -----------------------------------------------------------------------------
+export default reducer;

package/es/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;

package/es/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';
-const rootReducer = combineReducers({
+import reviewStatus from './review-status';
+import slides from './slides';
+import stepItems from './step-items';
+const ui = combineReducers({
     courses,
+    finishedSlides,
     navigation,
-    token
+    reviewStatus,
+    slides,
+    stepItems
+});
+export default combineReducers({
+    ui,
+    data
 });
-export default rootReducer;

package/es/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/es/reducers/navigation.js

@@ -1,6 +1,9 @@
 import { NAVIGATE_BACK, NAVIGATE_TO } from '../actions/navigation';
+// -----------------------------------------------------------------------------
+// export type State = Array<string>;
 export const initialState = ['home'];
 // -----------------------------------------------------------------------------
+// eslint-disable-next-line default-param-last
 const reducer = (state = initialState, action) => {
     switch (action.type) {
         case NAVIGATE_TO: {
@@ -16,6 +19,6 @@ const reducer = (state = initialState, action) => {
     }
 };
 // -----------------------------------------------------------------------------
-export const getCurrentViewName = appState => appState.navigation[appState.navigation.length - 1];
+export const getCurrentViewName = (appState) => appState.ui.navigation[appState.ui.navigation.length - 1];
 // -----------------------------------------------------------------------------
 export default reducer;

package/es/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/es/reducers/review-status.js

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

package/es/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/es/reducers/slides.js

@@ -0,0 +1,112 @@
+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';
+const getInitialState = () => {
+    const state = {
+        slideNumbers
+    };
+    // eslint-disable-next-line fp/no-loops
+    for (let index = 0; index < TOTAL_SLIDES_STACK; index++) {
+        state[index] = { hidden: false, position: index };
+    }
+    return state;
+};
+export const initialState = getInitialState();
+// -----------------------------------------------------------------------------
+const setFirstSlide = (state, slide) => {
+    const _state = {
+        slideNumbers
+    };
+    // eslint-disable-next-line lodash-fp/no-unused-result
+    map(index => {
+        const previousValue = state[index];
+        // Only update the 1st one
+        const content = index === 0 ? { ...previousValue, ...slide } : { ...previousValue };
+        _state[index] = { ...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
+const stateUpdateOnValidation = (state, payload) => {
+    const { slideNumber, newSlideContent, numberOfFinishedSlides, nextSlide } = payload;
+    const _state = {
+        slideNumbers
+    };
+    // eslint-disable-next-line lodash-fp/no-unused-result
+    map(index => {
+        const previousValue = state[index];
+        // the current slide
+        if (index === slideNumber) {
+            // only one slide remaining, presets the next value
+            if (numberOfFinishedSlides === HIGHEST_INDEX) {
+                _state[index] = {
+                    ...previousValue,
+                    nextSlide,
+                    position: newSlideContent.position,
+                    validationResult: newSlideContent.validationResult
+                };
+            }
+            else
+                _state[slideNumber] = { ...previousValue, ...newSlideContent };
+        }
+        else {
+            // updates the rest of the slides here
+            const { hidden, position } = previousValue;
+            _state[index] = { ...nextSlide, endReview: newSlideContent.endReview, hidden, 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)
+const stateUpdateOnNext = (state, payload) => {
+    const { slideNumber, newSlideContent, numberOfFinishedSlides } = payload;
+    const _state = {
+        slideNumbers
+    };
+    // eslint-disable-next-line lodash-fp/no-unused-result
+    map(index => {
+        const 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] = { ...previousValue.nextSlide, position: previousValue.position };
+            }
+            else
+                _state[slideNumber] = newSlideContent;
+        }
+        else {
+            // updates the rest of the slides here
+            const { hidden, position, answerUI, questionText } = previousValue;
+            _state[index] = {
+                hidden,
+                position: position - 1,
+                answerUI,
+                questionText,
+                endReview: newSlideContent.endReview
+            };
+        }
+    }, state.slideNumbers);
+    return _state;
+};
+// -----------------------------------------------------------------------------
+// eslint-disable-next-line default-param-last
+const reducer = (state = initialState, action) => {
+    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/es/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/es/reducers/step-items.js

@@ -0,0 +1,75 @@
+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';
+const getInitialState = () => {
+    const state = {
+        slideNumbers
+    };
+    // eslint-disable-next-line fp/no-loops
+    for (let index = 0; index < TOTAL_SLIDES_STACK; index++) {
+        const current = index === 0;
+        state[index] = { current, value: `${index + 1}`, icon: null };
+    }
+    return state;
+};
+export const initialState = getInitialState();
+// -----------------------------------------------------------------------------
+// ||-------> aux function, finds the next consecutive index
+// to loop from 0 to HIGHEST_INDEX (4) & again to 0
+const getNextIndex = (currentIndex) => 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)
+const calculateNextStepIndex = (currentStepNumber, finishedSlides, lastVisitedIndex = null) => {
+    // only one slide remaining, the step should stay on the same number
+    if (lastVisitedIndex === currentStepNumber) {
+        return currentStepNumber;
+    }
+    const 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;
+};
+const recalculateStepItemsState = (state, stepNumber, stepItemToUpdateProps) => {
+    const nextIndex = get('nextIndex', stepItemToUpdateProps);
+    const _state = {
+        slideNumbers
+    };
+    // eslint-disable-next-line lodash-fp/no-unused-result
+    map(index => {
+        const previousValue = state[index];
+        if (stepNumber === index)
+            _state[stepNumber] = {
+                ...previousValue,
+                ...stepItemToUpdateProps
+            };
+        /* only for UPDATE_STEP_ITEMS_ON_NEXT -> */ else if (nextIndex === index) {
+            _state[index] = { ...previousValue, current: true };
+        }
+        else
+            _state[index] = previousValue;
+    }, state.slideNumbers);
+    return _state;
+};
+// -----------------------------------------------------------------------------
+// eslint-disable-next-line default-param-last
+const reducer = (state = initialState, action) => {
+    switch (action.type) {
+        case UPDATE_STEP_ITEMS_ON_VALIDATION: {
+            const { stepNumber, icon } = action.payload;
+            return recalculateStepItemsState(state, stepNumber, { icon });
+        }
+        case UPDATE_STEP_ITEMS_ON_NEXT: {
+            const { stepNumber, finishedSlides, current } = action.payload;
+            const nextIndex = !current ? calculateNextStepIndex(stepNumber, finishedSlides) : null;
+            return recalculateStepItemsState(state, stepNumber, { current, nextIndex });
+        }
+        default:
+            return state;
+    }
+};
+// -----------------------------------------------------------------------------
+export default reducer;

package/es/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/es/reducers/token.js

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

package/es/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/es/services/fetch-demo.test.d.ts

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

package/es/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/es/services/fetch-responses.js

@@ -1,8 +1,8 @@
 export class ResponseError extends Error {
-    constructor(status, statusText, body = '') {
+    constructor(statusCode, statusText, body = '') {
         super(`${statusText} ${body}`.trim());
         this.name = 'ResponseError';
-        this.statusCode = status;
+        this.statusCode = statusCode;
     }
 }
 export const toJSON = async (response) => {

package/es/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/es/services/fetch.mocks.js

@@ -1,6 +1,6 @@
-export const toResponse = (status, statusText, body) => Promise.resolve({
-    ok: status < 400,
-    status,
+export const toResponse = (statusCode, statusText, body) => Promise.resolve({
+    ok: statusCode < 400,
+    status: statusCode,
     statusText,
     json: () => Promise.resolve(body).then(JSON.parse),
     text: () => Promise.resolve(body)

package/es/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/es/types/common.js

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

package/es/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/es/types/data/index.js

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

package/es/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/es/types/dispatchers.js

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

package/es/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/es/types/finished-slides.js

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

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

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

package/es/types/review-status.js

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