@coorpacademy/app-review 0.1.7 → 0.1.9

package/src/actions/api/fetch-slide.ts

@@ -0,0 +1,24 @@
+import type {AnyAction} from 'redux';
+import type {ThunkAction, ThunkDispatch} from 'redux-thunk';
+import buildTask from '@coorpacademy/redux-task';
+import type {StoreState} from '../../reducers';
+import {Options, SlideFromAPI} from '../../types/common';
+
+export const SLIDE_FETCH_REQUEST = '@@slides/FETCH_REQUEST' as const;
+export const SLIDE_FETCH_SUCCESS = '@@slides/FETCH_SUCCESS' as const;
+export const SLIDE_FETCH_FAILURE = '@@slides/FETCH_FAILURE' as const;
+
+export interface ReceivedSlide extends AnyAction {
+  type: typeof SLIDE_FETCH_SUCCESS;
+  payload: SlideFromAPI;
+}
+
+export type FetchSlideAction = ThunkAction<Promise<void>, StoreState, Options, AnyAction>;
+type Dispatch = ThunkDispatch<StoreState, Options, AnyAction>;
+
+export const fetchSlide = (slideRef: string, token: string): FetchSlideAction =>
+  buildTask({
+    types: [SLIDE_FETCH_REQUEST, SLIDE_FETCH_SUCCESS, SLIDE_FETCH_FAILURE],
+    task: (dispatch: Dispatch, getState: () => StoreState, {services}: Options) =>
+      services.fetchSlide(slideRef, token)
+  });

package/src/actions/api/post-progression.ts

@@ -0,0 +1,36 @@
+import type {AnyAction} from 'redux';
+import type {ThunkAction, ThunkDispatch} from 'redux-thunk';
+import buildTask from '@coorpacademy/redux-task';
+import {Options, ProgressionFromAPI} from '../../types/common';
+import type {StoreState} from '../../reducers';
+import {fetchSlide} from './fetch-slide';
+
+export const POST_PROGRESSION_REQUEST = '@@progression/POST_REQUEST' as const;
+export const POST_PROGRESSION_SUCCESS = '@@progression/POST_SUCCESS' as const;
+export const POST_PROGRESSION_FAILURE = '@@progression/POST_FAILURE' as const;
+
+export interface ReceiveProgression extends AnyAction {
+  type: typeof POST_PROGRESSION_SUCCESS;
+  payload: ProgressionFromAPI;
+}
+
+export type PostProgressionAction = ThunkAction<
+  Promise<ProgressionFromAPI>,
+  StoreState,
+  Options,
+  AnyAction
+>;
+
+type Dispatch = ThunkDispatch<StoreState, Options, AnyAction>;
+
+export const postProgression = (skillRef: string, token: string): PostProgressionAction =>
+  buildTask({
+    types: [POST_PROGRESSION_REQUEST, POST_PROGRESSION_SUCCESS, POST_PROGRESSION_FAILURE],
+    task: (dispatch: Dispatch, getState: () => StoreState, {services}: Options) => {
+      return services.postProgression(skillRef, token).then((progression: ProgressionFromAPI) => {
+        const {ref} = progression.state.nextContent;
+        dispatch(fetchSlide(ref, token));
+        return progression;
+      });
+    }
+  });

package/src/actions/data/slides.ts

@@ -1,13 +1,11 @@
-import {Slide as UISlide} from '../../types/slides';
+import {UISlide} from '../../types/slides';
+import {ReceivedSlide} from '../api/fetch-slide';
 
 // -----------------------------------------------------------------------------
 
-export const STORE_FIRST_SLIDE = '@@slide/STORE_FIRST_SLIDE';
 export const UPDATE_SLIDES_ON_VALIDATION = '@@slide/UPDATE_SLIDES_ON_VALIDATION';
 export const UPDATE_SLIDES_ON_NEXT = '@@slide/UPDATE_SLIDES_ON_NEXT';
 export const VALIDATE_SLIDE = '@@slide/VALIDATE';
-export const FETCH_NEXT_CONTENT = '@@slide/FETCH_NEXT_CONTENT';
-export const ERROR_FETCHING_SLIDE = '@@data/slide/ERROR_FETCHING_SLIDE';
 
 // -----------------------------------------------------------------------------
 
@@ -23,16 +21,6 @@ export type Slide = UISlide & {
 };
 
 // TODO: complete or modify typing as needed on Fetch Slide ticket
-export type SlideFromAPI = {
-  question: {
-    content: {
-      choices: Record<string, unknown>[];
-    };
-  };
-  klf: string;
-  universalRef: string;
-};
-
 export type ValidationPayload = {
   slideNumber: number;
   newSlideContent: Slide;
@@ -44,11 +32,6 @@ export type OnNextPayload = Omit<ValidationPayload, 'nextContent'>;
 
 // -----------------------------------------------------------------------------
 
-export type StoreFirstSlide = {
-  type: typeof STORE_FIRST_SLIDE;
-  payload: SlideFromAPI;
-};
-
 export type UpdateSlidesOnValidation = {
   type: typeof UPDATE_SLIDES_ON_VALIDATION;
   payload: ValidationPayload;
@@ -63,20 +46,10 @@ export type ValidateSlide = {
   type: typeof VALIDATE_SLIDE;
 };
 
-export type ErrorFetchingSlide = {
-  type: typeof ERROR_FETCHING_SLIDE;
-  payload: Error;
-};
-
-export type SlidesAction = StoreFirstSlide | UpdateSlidesOnValidation | UpdateSlidesOnNext;
+export type SlidesAction = ReceivedSlide | UpdateSlidesOnValidation | UpdateSlidesOnNext;
 
 // -----------------------------------------------------------------------------
 
-export const storeFirstSlide = (slide: SlideFromAPI): StoreFirstSlide => ({
-  type: STORE_FIRST_SLIDE,
-  payload: slide
-});
-
 export const updateSlidesOnValidation = (payload: ValidationPayload): UpdateSlidesOnValidation => ({
   type: UPDATE_SLIDES_ON_VALIDATION,
   payload
@@ -90,8 +63,3 @@ export const updateSlidesOnNext = (payload: OnNextPayload): UpdateSlidesOnNext =
 export const validateSlide = (): ValidateSlide => ({
   type: VALIDATE_SLIDE
 });
-
-export const errorFetchingSlide = (error: Error): ErrorFetchingSlide => ({
-  type: ERROR_FETCHING_SLIDE,
-  payload: error
-});

package/src/actions/index.ts

@@ -1,27 +1,21 @@
-import {
-  StoreFirstSlide,
-  updateSlidesOnValidation,
-  updateSlidesOnNext,
-  validateSlide
-} from './data/slides';
-import {ErrorFetchingSkills, ReceivedSkills} from './data/skills';
+import {updateSlidesOnValidation, updateSlidesOnNext, validateSlide} from './data/slides';
 import {StoreToken} from './data/token';
 
 import {updateFinishedSlides} from './ui/finished-slides';
 import {navigateBack, navigateTo, NavigateBack, NavigateTo, StartApp} from './ui/navigation';
 import {updateReviewStatus} from './ui/review-status';
 import {updateStepItemsOnValidation, updateStepItemsOnNext} from './ui/step-items';
-import {ErrorCreatingProgression, ReceiveProgression} from './data/progression';
+import {ReceivedSlide} from './api/fetch-slide';
+import {ReceiveProgression} from './api/post-progression';
+import {ReceivedSkills} from './api/fetch-skills';
 
 export type Action =
   | NavigateBack
   | NavigateTo
   | ReceivedSkills
-  | ErrorFetchingSkills
   | StartApp
-  | StoreFirstSlide
+  | ReceivedSlide
   | StoreToken
-  | ErrorCreatingProgression
   | ReceiveProgression;
 
 export type Dispatchers = {

package/src/actions/ui/navigation.ts

@@ -28,8 +28,3 @@ export const navigateTo = (newPath: ViewPath): NavigateTo => ({
 export const navigateBack = (): NavigateBack => ({
   type: NAVIGATE_BACK
 });
-
-export const startApp = (options: AppOptions): StartApp => ({
-  type: START_APP,
-  payload: options
-});

package/src/actions/ui/step-items.ts

@@ -1,20 +1,8 @@
-import {FinishedSlidesState} from '../../reducers/ui/finished-slides';
-
-// -----------------------------------------------------------------------------
+import {FinishedSlides, IconValue} from '../../types/common';
 
 export const UPDATE_STEP_ITEMS_ON_VALIDATION = '@@step-items/UPDATE_STEP_ITEMS_ON_VALIDATION';
 export const UPDATE_STEP_ITEMS_ON_NEXT = '@@step-items/UPDATE_STEP_ITEMS_ON_NEXT';
 
-const ICON_VALUES = {
-  right: 'right',
-  wrong: 'wrong',
-  'no-answer': 'no-answer'
-} as const;
-
-// -----------------------------------------------------------------------------
-
-export type IconValue = keyof typeof ICON_VALUES;
-
 type UpdateStepItemsOnValidationClickPayload = {
   stepNumber: number;
   icon: IconValue;
@@ -22,7 +10,7 @@ type UpdateStepItemsOnValidationClickPayload = {
 
 type UpdateStepItemsOnNextClickPayload = {
   stepNumber: number;
-  finishedSlides: FinishedSlidesState;
+  finishedSlides: FinishedSlides;
   current: boolean;
 };
 

package/src/configure-store.ts

@@ -1,43 +1,11 @@
 import {AnyAction, applyMiddleware, compose, createStore, Store} from 'redux';
 import thunk from 'redux-thunk';
+import rootReducer, {StoreState} from './reducers';
+import {getServices} from './services';
 
-import rootReducer from './reducers';
-import onStartApp from './middlewares/on-start-app';
-import onReceiveProgression from './middlewares/on-receive-progression';
+import {AppOptions} from './types/common';
 
-import {SkillsState} from './reducers/data/skills';
-import {SlidesState} from './reducers/data/slides';
-import {TokenState} from './reducers/data/token';
-import {NavigationState} from './reducers/ui/navigation';
-import {ReviewStatusState} from './reducers/ui/review-status';
-import {StepItemsState} from './reducers/ui/step-items';
-import {FinishedSlidesState} from './reducers/ui/finished-slides';
-import {ProgressionState} from './reducers/data/progression';
-
-// -----------------------------------------------------------------------------
-
-type DataState = {
-  isFetching?: boolean;
-  progression?: ProgressionState;
-  skills: SkillsState;
-  slides: SlidesState;
-  token?: TokenState;
-};
-
-export type StoreState = {
-  ui: {
-    navigation: NavigationState;
-    stepItems: StepItemsState;
-    finishedSlides: FinishedSlidesState;
-    reviewStatus: ReviewStatusState;
-    // progression: UiProgression;
-  };
-  data: DataState;
-};
-
-// -----------------------------------------------------------------------------
-
-export default function configureStore(): Store<StoreState, AnyAction> {
+export default function configureStore(options: AppOptions): Store<StoreState, AnyAction> {
   const _compose = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
     ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
         name: 'app-review',
@@ -46,7 +14,8 @@ export default function configureStore(): Store<StoreState, AnyAction> {
       })
     : compose;
 
-  const enhancer = _compose(applyMiddleware(thunk, onStartApp, onReceiveProgression));
+  const thunkMiddleware = thunk.withExtraArgument({services: options.services || getServices()});
+  const enhancer = _compose(applyMiddleware(thunkMiddleware));
   const store = createStore(rootReducer, undefined, enhancer);
 
   return store;

package/src/fixtures/qcm-slide.ts

@@ -1,7 +1,7 @@
 import noop from 'lodash/fp/noop';
-import {Slide} from '../types/slides';
+import {UISlide} from '../types/slides';
 
-export const slide: Slide = {
+export const slide: UISlide = {
   questionText: 'QCM',
   answerUI: {
     help: '__help',

package/src/index.tsx

@@ -1,24 +1,28 @@
 import React, {useEffect, useState} from 'react';
+import type {} from 'redux-thunk/extend-redux'; // https://github.com/reduxjs/redux-thunk/issues/333
 import {AnyAction, Store} from 'redux';
 import {connect, Provider} from 'react-redux';
 import AppReviewTemplate from '@coorpacademy/components/es/template/app-review';
 import {TemplateContext} from '@coorpacademy/components/es/template/app-review/template-context';
 
-import configureStore, {StoreState} from './configure-store';
+import configureStore from './configure-store';
 import {congratsProps, correctionPopinProps} from './fixtures/temp-fixture';
 
 import type {AppOptions} from './types/common';
+import type {StoreState} from './reducers';
 import {SkillsProps} from './types/views/skills';
 import type {SlidesViewStaticProps} from './types/views/slides';
 
 import {Dispatchers} from './actions';
 import {updateSlidesOnNext, updateSlidesOnValidation, validateSlide} from './actions/data/slides';
-import {navigateTo, navigateBack, startApp, ViewPath} from './actions/ui/navigation';
+import {navigateTo, navigateBack, ViewPath} from './actions/ui/navigation';
+import {storeToken} from './actions/data/token';
 import {updateFinishedSlides} from './actions/ui/finished-slides';
 import {updateReviewStatus} from './actions/ui/review-status';
 import {updateStepItemsOnValidation, updateStepItemsOnNext} from './actions/ui/step-items';
-
-// -----------------------------------------------------------------------------
+import {fetchSkills} from './actions/api/fetch-skills';
+import {postProgression} from './actions/api/post-progression';
+import {VIEWS} from './common';
 
 type StaticProps = {
   viewName: 'skills' | 'onboarding' | 'slides';
@@ -26,8 +30,6 @@ type StaticProps = {
   skills: SkillsProps | null;
 };
 
-// -----------------------------------------------------------------------------
-
 const mapDispatchToProps: Dispatchers = {
   navigateTo,
   navigateBack,
@@ -43,8 +45,6 @@ const mapDispatchToProps: Dispatchers = {
 const getCurrentViewName = (storeState: StoreState): ViewPath =>
   storeState.ui.navigation[storeState.ui.navigation.length - 1];
 
-// -----------------------------------------------------------------------------
-
 const mapStateToSkillsProps = (state: StoreState): SkillsProps | null => {
   if (!state.data.skills) {
     return null;
@@ -72,8 +72,6 @@ const mapStateToSkillsProps = (state: StoreState): SkillsProps | null => {
   };
 };
 
-// -----------------------------------------------------------------------------
-
 const mapStateToSlidesProps = (state: StoreState): SlidesViewStaticProps | null => {
   if (!state.data.slides) {
     return null;
@@ -103,38 +101,53 @@ const mapStateToSlidesProps = (state: StoreState): SlidesViewStaticProps | null
   };
 };
 
-// -----------------------------------------------------------------------------
-
-const mapStateToProps = (state: StoreState): StaticProps => ({
-  viewName: getCurrentViewName(state),
-  slides: mapStateToSlidesProps(state),
-  skills: mapStateToSkillsProps(state)
-});
-
-// Props = StaticProps && Dispatchers
+const mapStateToProps = (state: StoreState): StaticProps => {
+  return {
+    viewName: getCurrentViewName(state),
+    slides: mapStateToSlidesProps(state),
+    skills: mapStateToSkillsProps(state)
+  };
+};
 
 const App = connect(mapStateToProps, mapDispatchToProps)(AppReviewTemplate);
 
-// -----------------------------------------------------------------------------
-
 const AppReview = ({options}: {options: AppOptions}): JSX.Element | null => {
   const [store, setStore] = useState<Store<StoreState, AnyAction> | null>(null);
-  const [appStarted, setAppStarted] = useState<boolean>(false);
 
   useEffect(() => {
-    if (store) {
-      store.dispatch(startApp(options));
-      setAppStarted(true);
-    } else {
-      const _configure = async (): Promise<void> => {
-        const newStore = await configureStore();
-        setStore(newStore);
-      };
-      _configure();
-    }
+    if (store) return;
+
+    const newStore = configureStore(options);
+    setStore(newStore);
+  }, [options, store]);
+
+  useEffect(() => {
+    if (store === null) return;
+
+    const {skillRef} = options;
+    const initialView: ViewPath = skillRef ? VIEWS.slides : VIEWS.skills;
+    store.dispatch(navigateTo(initialView));
+  }, [options, store]);
+
+  useEffect(() => {
+    if (store === null) return;
+
+    const {token} = options;
+    store.dispatch(storeToken(token));
+  }, [options, store]);
+
+  useEffect(() => {
+    if (store === null) return;
+
+    const {skillRef, token} = options;
+    // ThunkAction is not assignable to parameter of type 'AnyAction'
+    // ts problem describre here = https://github.com/reduxjs/redux-thunk/issues/333
+    skillRef
+      ? store.dispatch(postProgression(skillRef, token))
+      : store.dispatch(fetchSkills(token));
   }, [options, store]);
 
-  if (!store || !appStarted) return null;
+  if (!store) return null;
 
   const {templateContext: values} = options;
 
@@ -147,15 +160,11 @@ const AppReview = ({options}: {options: AppOptions}): JSX.Element | null => {
   );
 };
 
-// -----------------------------------------------------------------------------
-
 declare global {
   // eslint-disable-next-line no-shadow
   interface Window {
-    __REDUX_DEVTOOLS_EXTENSION__?: boolean;
+    __REDUX_DEVTOOLS_EXTENSION_COMPOSE__?: Function;
   }
 }
 
-// -----------------------------------------------------------------------------
-
 export default AppReview;

package/src/reducers/data/index.ts

@@ -1,9 +1,17 @@
 import {combineReducers} from 'redux';
 
-import progression from './progression';
-import skills from './skills';
-import slides from './slides';
-import token from './token';
+import progression, {ProgressionState} from './progression';
+import skills, {SkillsState} from './skills';
+import slides, {SlidesState} from './slides';
+import token, {TokenState} from './token';
+
+export type DataState = {
+  isFetching?: boolean;
+  progression?: ProgressionState;
+  skills: SkillsState;
+  slides: SlidesState;
+  token?: TokenState;
+};
 
 export default combineReducers({
   progression,

package/src/reducers/data/progression.ts

@@ -1,11 +1,7 @@
 import {getOr} from 'lodash/fp';
-import {ReceiveProgression, RECEIVE_PROGRESSION} from '../../actions/data/progression';
 import {ValidateSlide, VALIDATE_SLIDE} from '../../actions/data/slides';
+import {POST_PROGRESSION_SUCCESS, ReceiveProgression} from '../../actions/api/post-progression';
 
-// -----------------------------------------------------------------------------
-
-// TODO: transform this into UI data / fix on components' repo when
-// fetch slide is addressed
 export type ProgressionState = {
   _id?: string;
   state: {
@@ -22,17 +18,11 @@ export type ProgressionState = {
   // TO refactor: (slideNumber)
   // virtual field
   slideNumber?: number;
-} | null;
-
-// -----------------------------------------------------------------------------
-
-export const initialState: ProgressionState = null;
-
-// -----------------------------------------------------------------------------
+} | null; // TODO: ça ressemble beaucoup à ProgressionFromAPI et ça devrait l'être
 
 const reducer = (
   // eslint-disable-next-line default-param-last
-  state: ProgressionState = initialState,
+  state: ProgressionState = null,
   action: ValidateSlide | ReceiveProgression
 ): ProgressionState => {
   switch (action.type) {
@@ -57,8 +47,8 @@ const reducer = (
         }
       };
     }
-    case RECEIVE_PROGRESSION: {
-      const {progression} = action.payload;
+    case POST_PROGRESSION_SUCCESS: {
+      const progression = action.payload;
       return progression;
     }
     default:

package/src/reducers/data/skills.ts

@@ -1,21 +1,16 @@
-import {ReceivedSkills, RECEIVED_SKILLS} from '../../actions/data/skills';
-import {Skills} from '../../types/skills';
+import {Skill} from '../../types/common';
+import {ReceivedSkills, SKILLS_FETCH_SUCCESS} from '../../actions/api/fetch-skills';
 
-export type SkillsState = Skills;
-export const initialState: SkillsState = [];
-
-// -----------------------------------------------------------------------------
+export type SkillsState = Skill[];
 
 // eslint-disable-next-line default-param-last
-const reducer = (state: SkillsState = initialState, action: ReceivedSkills): SkillsState => {
+const reducer = (state: SkillsState = [], action: ReceivedSkills): SkillsState => {
   switch (action.type) {
-    case RECEIVED_SKILLS:
+    case SKILLS_FETCH_SUCCESS:
       return action.payload;
     default:
       return state;
   }
 };
 
-// -----------------------------------------------------------------------------
-
 export default reducer;

package/src/reducers/data/slides.ts

@@ -1,26 +1,22 @@
 import map from 'lodash/fp/map';
 import {
   OnNextPayload,
-  Slide,
   SlidesAction,
-  STORE_FIRST_SLIDE,
   UPDATE_SLIDES_ON_NEXT,
   UPDATE_SLIDES_ON_VALIDATION,
   ValidationPayload
 } from '../../actions/data/slides';
-import {Slide as UISlide} from '../../types/slides';
+import {UISlide} from '../../types/slides';
 import {HIGHEST_INDEX, slideNumbers, TOTAL_SLIDES_STACK} from '../../common';
 import {slide as qcmSlide} from '../../fixtures/qcm-slide';
-
-// -----------------------------------------------------------------------------
+import {SLIDE_FETCH_SUCCESS} from '../../actions/api/fetch-slide';
+import {Slide} from '../../types/common';
 
 export type SlidesState = {
   slideNumbers: number[];
   [key: number]: Slide;
 };
 
-// -----------------------------------------------------------------------------
-
 const getInitialState = (): SlidesState => {
   const state: SlidesState = {
     slideNumbers
@@ -121,7 +117,7 @@ const stateUpdateOnNext = (state: SlidesState, payload: OnNextPayload): SlidesSt
 // eslint-disable-next-line default-param-last
 const reducer = (state: SlidesState = initialState, action: SlidesAction): SlidesState => {
   switch (action.type) {
-    case STORE_FIRST_SLIDE: {
+    case SLIDE_FETCH_SUCCESS: {
       // TODO: An intermediate slide transform is needed here (or in fetchSlide)
       // const apiSlide = action.payload;
       // apiSlide adapt to uiSlide

package/src/reducers/data/token.ts

@@ -1,17 +1,9 @@
 import {StoreToken, STORE_TOKEN} from '../../actions/data/token';
 
-// -----------------------------------------------------------------------------
-
 export type TokenState = string | null;
 
-// -----------------------------------------------------------------------------
-
-export const initialState: TokenState = null;
-
-// -----------------------------------------------------------------------------
-
 // eslint-disable-next-line default-param-last
-const reducer = (state: TokenState = initialState, action: StoreToken): TokenState => {
+const reducer = (state: TokenState = null, action: StoreToken): TokenState => {
   switch (action.type) {
     case STORE_TOKEN:
       return action.payload;
@@ -20,6 +12,4 @@ const reducer = (state: TokenState = initialState, action: StoreToken): TokenSta
   }
 };
 
-// -----------------------------------------------------------------------------
-
 export default reducer;

package/src/reducers/index.ts

@@ -1,7 +1,12 @@
 import {combineReducers} from 'redux';
 
-import data from './data';
-import ui from './ui';
+import data, {DataState} from './data';
+import ui, {UIState} from './ui';
+
+export type StoreState = {
+  ui: UIState;
+  data: DataState;
+};
 
 export default combineReducers({
   data,

package/src/reducers/ui/finished-slides.ts

@@ -2,21 +2,15 @@ import forEach from 'lodash/fp/forEach';
 import {UpdateFinishedSlides, UPDATE_FINISHED_SLIDES} from '../../actions/ui/finished-slides';
 import {slideNumbers} from '../../common';
 
-// -----------------------------------------------------------------------------
-// Stores only successful slides
 export type FinishedSlidesState = {
   slideNumbers: number[];
   [key: number]: true;
 };
 
-// -----------------------------------------------------------------------------
-
-export const initialState: FinishedSlidesState = {
+const initialState: FinishedSlidesState = {
   slideNumbers
 };
 
-// -----------------------------------------------------------------------------
-
 const _forEach: <T>(
   iteratee: (value: T[keyof T], index: number) => void,
   collection: T

package/src/reducers/ui/index.ts

@@ -1,9 +1,16 @@
 import {combineReducers} from 'redux';
 
-import finishedSlides from './finished-slides';
-import navigation from './navigation';
-import reviewStatus from './review-status';
-import stepItems from './step-items';
+import finishedSlides, {FinishedSlidesState} from './finished-slides';
+import navigation, {NavigationState} from './navigation';
+import reviewStatus, {ReviewStatusState} from './review-status';
+import stepItems, {StepItemsState} from './step-items';
+
+export type UIState = {
+  navigation: NavigationState;
+  stepItems: StepItemsState;
+  finishedSlides: FinishedSlidesState;
+  reviewStatus: ReviewStatusState;
+};
 
 export default combineReducers({
   finishedSlides,