@constructor-io/constructorio-ui-quizzes 1.2.2 → 1.3.0

package/lib/mjs/hooks/useConsoleErrors.js

@@ -0,0 +1,18 @@
+import { useEffect } from 'react';
+const useConsoleErrors = (quizId, resultsPageOptions) => {
+    useEffect(() => {
+        if (!quizId) {
+            // eslint-disable-next-line no-console
+            console.error('quizId is a required field of type string');
+        }
+        if (!resultsPageOptions || Object.keys(resultsPageOptions).length === 0) {
+            // eslint-disable-next-line no-console
+            console.error('resultsPageOptions is a required field of type object');
+        }
+        if (resultsPageOptions && !resultsPageOptions?.onAddToCartClick) {
+            // eslint-disable-next-line no-console
+            console.error('resultsPageOptions.onAddToCartClick is a required field of type function');
+        }
+    }, [quizId, resultsPageOptions, resultsPageOptions?.onAddToCartClick]);
+};
+export default useConsoleErrors;

package/lib/mjs/hooks/useQuiz.js

@@ -0,0 +1,47 @@
+import useCioClient from './useCioClient';
+import useConsoleErrors from './useConsoleErrors';
+import useQuizApiState from './useQuizApiState';
+import useQuizEvents from './useQuizEvents';
+import useQuizLocalState from './useQuizLocalState';
+const useQuiz = ({ quizId, apiKey, cioJsClient, quizVersionId, resultsPageOptions }) => {
+    // Log console errors for required parameters quizId and resultsPageOptions
+    useConsoleErrors(quizId, resultsPageOptions);
+    // Quiz Local state
+    const { quizLocalState, resetQuizLocalState, dispatchLocalState } = useQuizLocalState();
+    // Quiz Cio Client
+    const cioClient = useCioClient({ apiKey, cioJsClient });
+    // Quiz API state
+    const { isFirstQuestion, quizApiState, resetQuizApiState } = useQuizApiState(quizId, quizLocalState, resultsPageOptions, quizVersionId, cioClient);
+    // Quiz callback events
+    const quizEvents = useQuizEvents({
+        cioClient,
+        quizApiState,
+        resultsPageOptions,
+        dispatchLocalState,
+        resetQuizApiState,
+        resetQuizLocalState,
+    });
+    return {
+        cioClient,
+        state: {
+            answers: {
+                inputs: quizLocalState.answerInputs,
+                isLastAnswer: quizLocalState.isLastAnswer,
+            },
+            quiz: {
+                requestState: quizApiState.quizRequestState,
+                versionId: quizApiState.quizVersionId,
+                sessionId: quizApiState.quizSessionId,
+                firstQuestion: quizApiState.quizFirstQuestion,
+                currentQuestion: quizApiState.quizCurrentQuestion,
+                results: quizApiState.quizResults,
+                resultsFilters: quizApiState.quizResultsFilters,
+                isFirstQuestion,
+            },
+        },
+        events: {
+            ...quizEvents,
+        },
+    };
+};
+export default useQuiz;

package/lib/mjs/hooks/useQuizApiState.js

@@ -0,0 +1,87 @@
+import { useEffect, useReducer } from 'react';
+import { QuizAPIActionTypes } from '../components/CioQuiz/actions';
+import apiReducer, { initialState } from '../components/CioQuiz/quizApiReducer';
+import { nextQuestion, getQuizResults } from '../services';
+const useFetchQuiz = (quizId, quizLocalState, resultsPageOptions, quizVersionIdProp, cioClient) => {
+    const [quizApiState, dispatch] = useReducer(apiReducer, initialState);
+    const firstQuestionId = quizApiState.quizFirstQuestion?.next_question.id;
+    const currentQuestionId = quizApiState.quizCurrentQuestion?.next_question.id;
+    const isFirstQuestion = firstQuestionId === currentQuestionId;
+    useEffect(() => {
+        (async () => {
+            dispatch({
+                type: QuizAPIActionTypes.SET_IS_LOADING,
+            });
+            if (quizLocalState.isLastAnswer) {
+                try {
+                    const quizResults = await getQuizResults(cioClient, quizId, {
+                        answers: quizLocalState.answers,
+                        resultsPerPage: resultsPageOptions?.numResultsToDisplay,
+                        quizVersionId: quizApiState.quizVersionId,
+                        quizSessionId: quizApiState.quizSessionId,
+                    });
+                    // Set quiz results state
+                    dispatch({
+                        type: QuizAPIActionTypes.SET_QUIZ_RESULTS,
+                        payload: {
+                            quizResults,
+                        },
+                    });
+                }
+                catch (error) {
+                    dispatch({
+                        type: QuizAPIActionTypes.SET_IS_ERROR,
+                    });
+                }
+            }
+            else {
+                try {
+                    let quizVersionId = quizApiState.quizVersionId || quizVersionIdProp;
+                    let { quizSessionId } = quizApiState;
+                    const questionResult = await nextQuestion(cioClient, quizId, {
+                        answers: quizLocalState.answers,
+                        quizVersionId,
+                        quizSessionId,
+                    });
+                    if (!quizVersionId && questionResult?.quiz_version_id) {
+                        quizVersionId = questionResult.quiz_version_id;
+                    }
+                    if (!quizSessionId && questionResult?.quiz_session_id) {
+                        quizSessionId = questionResult.quiz_session_id;
+                    }
+                    // Set current question state
+                    dispatch({
+                        type: QuizAPIActionTypes.SET_CURRENT_QUESTION,
+                        payload: {
+                            quizSessionId,
+                            quizVersionId,
+                            quizCurrentQuestion: questionResult,
+                        },
+                    });
+                }
+                catch (error) {
+                    dispatch({
+                        type: QuizAPIActionTypes.SET_IS_ERROR,
+                    });
+                }
+            }
+        })();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        cioClient,
+        quizId,
+        quizLocalState,
+        quizLocalState.isLastAnswer,
+        resultsPageOptions?.numResultsToDisplay,
+    ]);
+    const resetQuizApiState = () => {
+        dispatch({ type: QuizAPIActionTypes.RESET_QUIZ });
+    };
+    return {
+        cioClient,
+        quizApiState,
+        isFirstQuestion,
+        resetQuizApiState,
+    };
+};
+export default useFetchQuiz;

package/lib/mjs/hooks/useQuizEvents/index.js

@@ -0,0 +1,33 @@
+import useQuizResultsLoaded from './useQuizResultsLoaded';
+import useQuizResultClick from './useQuizResultClick';
+import useQuizAddToCart from './useQuizAddToCart';
+import useQuizNextClick from './useQuizNextClick';
+import useQuizBackClick from './useQuizBackClick';
+const useQuizEvents = (options) => {
+    const { cioClient, quizApiState, resultsPageOptions, dispatchLocalState, resetQuizApiState, resetQuizLocalState, } = options;
+    const { onAddToCartClick, onQuizResultClick, onQuizResultsLoaded } = resultsPageOptions;
+    // Quiz Next button click
+    const nextQuestion = useQuizNextClick(quizApiState, dispatchLocalState);
+    // Quiz Back button click callback
+    const previousQuestion = useQuizBackClick(dispatchLocalState);
+    // Quiz result add to cart callback
+    const addToCart = useQuizAddToCart(cioClient, quizApiState, onAddToCartClick);
+    // Quiz result click callback
+    const resultClick = useQuizResultClick(cioClient, quizApiState, onQuizResultClick);
+    // Quiz results loaded event
+    useQuizResultsLoaded(cioClient, quizApiState, onQuizResultsLoaded);
+    const resetQuiz = () => {
+        if (quizApiState.quizResults) {
+            resetQuizApiState();
+            resetQuizLocalState();
+        }
+    };
+    return {
+        addToCart,
+        resultClick,
+        nextQuestion,
+        previousQuestion,
+        resetQuiz,
+    };
+};
+export default useQuizEvents;

package/lib/mjs/hooks/useQuizEvents/useQuizAddToCart.js

@@ -0,0 +1,18 @@
+import { useCallback } from 'react';
+import { trackQuizConversion } from '../../services';
+import { isFunction } from '../../utils';
+const useQuizAddToCart = (cioClient, quizApiState, onAddToCartClick) => {
+    const addToCartClickHandler = useCallback((e, result, price) => {
+        e.preventDefault();
+        if (quizApiState.quizResults) {
+            // Tracking call
+            trackQuizConversion(cioClient, quizApiState.quizResults, result, price);
+            // User custom callback function
+            if (isFunction(onAddToCartClick)) {
+                onAddToCartClick(result);
+            }
+        }
+    }, [quizApiState, cioClient, onAddToCartClick]);
+    return addToCartClickHandler;
+};
+export default useQuizAddToCart;

package/lib/mjs/hooks/useQuizEvents/useQuizBackClick.js

@@ -0,0 +1,11 @@
+import { useCallback } from 'react';
+import { QuestionTypes } from '../../components/CioQuiz/actions';
+const useQuizBackClick = (dispatchLocalState) => {
+    const quizBackHandler = useCallback(() => {
+        if (dispatchLocalState) {
+            dispatchLocalState({ type: QuestionTypes.Back });
+        }
+    }, [dispatchLocalState]);
+    return quizBackHandler;
+};
+export default useQuizBackClick;

package/lib/mjs/hooks/useQuizEvents/useQuizNextClick.js

@@ -0,0 +1,45 @@
+import { useCallback } from 'react';
+import { QuestionTypes } from '../../components/CioQuiz/actions';
+const useQuizNextClick = (quizApiState, dispatchLocalState) => {
+    const quizNextHandler = useCallback((payload) => {
+        const questionType = quizApiState.quizCurrentQuestion?.next_question.type;
+        const currentQuestion = quizApiState.quizCurrentQuestion;
+        switch (questionType) {
+            case QuestionTypes.Cover:
+                dispatchLocalState({
+                    type: QuestionTypes.Cover,
+                    payload: {
+                        isLastQuestion: currentQuestion.is_last_question,
+                    },
+                });
+                break;
+            case QuestionTypes.OpenText:
+                dispatchLocalState({
+                    type: QuestionTypes.OpenText,
+                    payload: {
+                        questionId: currentQuestion.next_question.id,
+                        input: payload,
+                        isLastQuestion: currentQuestion.is_last_question,
+                    },
+                });
+                break;
+            case QuestionTypes.SingleSelect:
+            case QuestionTypes.MultipleSelect:
+                dispatchLocalState({
+                    type: currentQuestion.next_question.type === QuestionTypes.SingleSelect
+                        ? QuestionTypes.SingleSelect
+                        : QuestionTypes.MultipleSelect,
+                    payload: {
+                        questionId: currentQuestion.next_question.id,
+                        input: payload,
+                        isLastQuestion: currentQuestion.is_last_question,
+                    },
+                });
+                break;
+            default:
+                break;
+        }
+    }, [quizApiState, dispatchLocalState]);
+    return quizNextHandler;
+};
+export default useQuizNextClick;

package/lib/mjs/hooks/useQuizEvents/useQuizResultClick.js

@@ -0,0 +1,17 @@
+import { useCallback } from 'react';
+import { trackQuizResultClick } from '../../services';
+import { isFunction } from '../../utils';
+const useQuizResultClick = (cioClient, quizApiState, onQuizResultClick) => {
+    const resultClickHandler = useCallback((result, position) => {
+        if (quizApiState.quizResults) {
+            // Tracking call
+            trackQuizResultClick(cioClient, quizApiState.quizResults, result, position);
+            // User custom callback function
+            if (isFunction(onQuizResultClick)) {
+                onQuizResultClick(result, position);
+            }
+        }
+    }, [quizApiState, cioClient, onQuizResultClick]);
+    return resultClickHandler;
+};
+export default useQuizResultClick;

package/lib/mjs/hooks/useQuizEvents/useQuizResultsLoaded.js

@@ -0,0 +1,19 @@
+import { useEffect } from 'react';
+import { trackQuizResultsLoaded } from '../../services';
+import { isFunction } from '../../utils';
+const useQuizResultsLoaded = (cioClient, quizApiState, onQuizResultsLoaded) => {
+    // Quiz results loaded
+    useEffect(() => {
+        if (quizApiState.quizResults) {
+            // Tracking call
+            trackQuizResultsLoaded(cioClient, quizApiState.quizResults);
+            // User custom callback function
+            if (onQuizResultsLoaded &&
+                isFunction(onQuizResultsLoaded) &&
+                quizApiState.quizResults.response?.results) {
+                onQuizResultsLoaded(quizApiState.quizResults.response.results);
+            }
+        }
+    }, [quizApiState, cioClient, onQuizResultsLoaded]);
+};
+export default useQuizResultsLoaded;

package/lib/mjs/hooks/useQuizLocalState.js

@@ -0,0 +1,17 @@
+import { useReducer } from 'react';
+import { QuestionTypes } from '../components/CioQuiz/actions';
+import quizLocalReducer, { initialState } from '../components/CioQuiz/quizLocalReducer';
+const useQuizLocalState = () => {
+    const [quizLocalState, dispatch] = useReducer(quizLocalReducer, initialState);
+    const resetQuizLocalState = () => {
+        dispatch({
+            type: QuestionTypes.Reset,
+        });
+    };
+    return {
+        quizLocalState,
+        resetQuizLocalState,
+        dispatchLocalState: dispatch,
+    };
+};
+export default useQuizLocalState;

package/lib/mjs/services/index.js

@@ -0,0 +1,60 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import ConstructorIOClient from '@constructor-io/constructorio-client-javascript';
+export const getCioClient = (apiKey) => {
+    if (apiKey) {
+        return new ConstructorIOClient({
+            apiKey,
+            sendTrackingEvents: true,
+        });
+    }
+    return undefined;
+};
+export const nextQuestion = (cioClient, quizId, parameters) => cioClient?.quizzes.getQuizNextQuestion(quizId, parameters);
+export const getQuizResults = async (cioClient, quizId, parameters) => cioClient?.quizzes.getQuizResults(quizId, parameters);
+// Tracking requests
+export const trackQuizResultsLoaded = (cioClient, quizResults) => {
+    const { quiz_id, quiz_session_id, quiz_version_id, result_id, request, response } = quizResults;
+    cioClient?.tracker.trackQuizResultsLoaded({
+        quiz_id,
+        quiz_version_id,
+        quiz_session_id,
+        url: window.location.href,
+        section: request?.section,
+        result_count: response?.total_num_results,
+        result_page: request?.page,
+        result_id,
+    });
+};
+export const trackQuizResultClick = (cioClient, quizResults, result, position) => {
+    if (quizResults.request && quizResults.response) {
+        const { quiz_id, quiz_session_id, quiz_version_id, result_id, request: { section, page, num_results_per_page }, response: { total_num_results }, } = quizResults;
+        cioClient?.tracker.trackQuizResultClick({
+            quiz_id,
+            quiz_version_id,
+            quiz_session_id,
+            item_id: result.data?.id,
+            item_name: result?.value,
+            section,
+            result_count: total_num_results,
+            result_page: page,
+            result_id,
+            result_position_on_page: position,
+            num_results_per_page,
+        });
+    }
+};
+export const trackQuizConversion = (cioClient, quizResults, result, price) => {
+    if (quizResults.request) {
+        const { quiz_id, quiz_session_id, quiz_version_id, request: { section }, } = quizResults;
+        cioClient?.tracker.trackQuizConversion({
+            quiz_id,
+            quiz_version_id,
+            quiz_session_id,
+            item_id: result.data?.id,
+            item_name: result.value,
+            section,
+            variation_id: result.data?.variation_id,
+            revenue: (price && String(price)) || undefined,
+        });
+    }
+};

package/lib/mjs/utils.js

@@ -1,5 +1,4 @@
 import React from 'react';
-import ConstructorIOClient from '@constructor-io/constructorio-client-javascript';
 import { QuestionTypes } from './components/CioQuiz/actions';
 export const renderImages = (images, cssClasses) => {
     const { primary_url: primaryUrl, primary_alt: primaryAlt, secondary_url: secondaryUrl, secondary_alt: secondaryAlt, } = images;
@@ -36,21 +35,32 @@ ${templateCode}
         },
     };
 };
-export const defaultAddToCartCallbackCode = `"addToCartCallback": (item) => console.dir(item)`;
+export const defaultOnAddToCartClickCode = `"onAddToCartClick": (item) => console.dir(item)`;
+export const defaultOnQuizResultClickCode = `"onQuizResultClick": (result, position) => console.dir(result, position)`;
+export const defaultOnQuizResultsLoadedCode = `"onQuizResultsLoaded": (results) => console.dir(results)`;
 export const stringifyWithDefaults = (obj) => {
-    const { addToCartCallback, cioJsClient, ...rest } = obj;
-    let res = JSON.stringify(rest, null, '  ');
+    const { resultsPageOptions, cioJsClient, ...rest } = obj;
+    const { onAddToCartClick, onQuizResultsLoaded, onQuizResultClick } = resultsPageOptions;
+    let res = JSON.stringify({ ...rest, resultsPageOptions }, null, '  ');
     if (cioJsClient) {
         res = res.replace('"resultsPageOptions": {', `"cioJsClient": cioJsClient,
   "resultsPageOptions": {`);
     }
-    res = res.replace('"resultsPageOptions": {', `"resultsPageOptions": {
-    ${defaultAddToCartCallbackCode},`);
+    if (onQuizResultsLoaded) {
+        res = res.replace('"resultsPageOptions": {', `"resultsPageOptions": {
+    ${defaultOnQuizResultsLoadedCode},`);
+    }
+    if (onQuizResultClick) {
+        res = res.replace('"resultsPageOptions": {', `"resultsPageOptions": {
+    ${defaultOnQuizResultClickCode},`);
+    }
+    if (onAddToCartClick) {
+        res = res.replace('"resultsPageOptions": {', `"resultsPageOptions": {
+    ${defaultOnAddToCartClickCode},`);
+    }
     return res;
 };
 export const stringify = (obj) => JSON.stringify(obj, null, '  ');
-export const getNextQuestion = (cioClient, quizId, parameters) => cioClient?.quizzes.getQuizNextQuestion(quizId, parameters);
-export const getQuizResults = async (cioClient, quizId, parameters) => cioClient?.quizzes.getQuizResults(quizId, parameters);
 export const getQuestionTypes = (questionType) => {
     const isOpenQuestion = questionType === QuestionTypes.OpenText;
     const isCoverQuestion = questionType === QuestionTypes.Cover;
@@ -65,15 +75,6 @@ export const getQuestionTypes = (questionType) => {
         isSelectQuestion,
     };
 };
-export const getCioClient = (apiKey) => {
-    if (apiKey) {
-        return new ConstructorIOClient({
-            apiKey,
-            sendTrackingEvents: true,
-        });
-    }
-    return undefined;
-};
 export function getPreferredColorScheme() {
     let colorScheme = 'light';
     // Check if the dark-mode Media-Query matches
@@ -82,3 +83,24 @@ export function getPreferredColorScheme() {
     }
     return colorScheme;
 }
+export function isFunction(fn) {
+    return fn && typeof fn === 'function';
+}
+const isValueExpression = (exp) => 'name' in exp && 'value' in exp;
+const isAndFilter = (exp) => 'and' in exp;
+const isOrFilter = (exp) => 'or' in exp;
+export const getFilterValuesFromExpression = (exp) => {
+    if (!exp) {
+        return [];
+    }
+    if (isAndFilter(exp)) {
+        return exp.and.flatMap((innerExpression) => getFilterValuesFromExpression(innerExpression));
+    }
+    if (isOrFilter(exp)) {
+        return exp.or.flatMap((innerExpression) => getFilterValuesFromExpression(innerExpression));
+    }
+    if (isValueExpression(exp)) {
+        return [exp.value];
+    }
+    return [];
+};

package/lib/types/components/CioQuiz/actions.d.ts

@@ -1,3 +1,4 @@
+import { NextQuestionResponse, QuizResultsResponse } from '../../types';
 export declare enum QuestionTypes {
     OpenText = "open",
     Cover = "cover",
@@ -22,4 +23,23 @@ interface Action<Type, Payload = {}> {
 }
 export type ActionAnswerInputQuestion = Action<QuestionTypes.OpenText, OpenTextQuestionPayload> | Action<QuestionTypes.SingleSelect, SelectQuestionPayload> | Action<QuestionTypes.MultipleSelect, SelectQuestionPayload>;
 export type ActionAnswerQuestion = ActionAnswerInputQuestion | Action<QuestionTypes.Cover, CoverQuestionPayload> | Action<QuestionTypes.Back> | Action<QuestionTypes.Reset>;
+export declare enum QuizAPIActionTypes {
+    SET_IS_LOADING = 0,
+    SET_IS_ERROR = 1,
+    SET_QUIZ_RESULTS = 2,
+    SET_CURRENT_QUESTION = 3,
+    RESET_QUIZ = 4
+}
+export type ActionSetIsLoading = Action<QuizAPIActionTypes.SET_IS_LOADING>;
+export type ActionSetIsError = Action<QuizAPIActionTypes.SET_IS_ERROR>;
+export type ActionSetQuizResults = Action<QuizAPIActionTypes.SET_QUIZ_RESULTS, {
+    quizResults: QuizResultsResponse;
+}>;
+export type ActionSetCurrentQuestion = Action<QuizAPIActionTypes.SET_CURRENT_QUESTION, {
+    quizCurrentQuestion: NextQuestionResponse;
+    quizSessionId?: string;
+    quizVersionId?: string;
+}>;
+export type ActionResetQuiz = Action<QuizAPIActionTypes.RESET_QUIZ>;
+export type ActionQuizAPI = ActionSetIsLoading | ActionSetIsError | ActionSetQuizResults | ActionSetCurrentQuestion | ActionResetQuiz;
 export {};

package/lib/types/components/CioQuiz/context.d.ts

@@ -1,19 +1,15 @@
 import React from 'react';
 import ConstructorIOClient from '@constructor-io/constructorio-client-javascript';
-import { RequestStates } from '../../constants';
-import { NextQuestionResponse, QuizResultsResponse } from '../../types';
-import { ActionAnswerQuestion } from './actions';
-import { QuizReducerState } from './reducer';
-interface QuizContextValue {
-    state: QuizReducerState;
-    requestState: RequestStates;
-    questionResponse: NextQuestionResponse;
-    resultsResponse: QuizResultsResponse;
-    isFirstQuestion: boolean;
-    quizNextHandler: (action?: ActionAnswerQuestion) => void;
-    quizBackHandler: () => void;
-    dispatch: React.Dispatch<ActionAnswerQuestion>;
-    cioClient: ConstructorIOClient;
+import { QuizEventsReturn, QuizReturnState } from '../../types';
+export interface QuizContextValue {
+    cioClient?: ConstructorIOClient;
+    state?: QuizReturnState;
+    resetQuiz: QuizEventsReturn.ResetQuiz;
+    nextQuestion?: QuizEventsReturn.NextQuestion;
+    previousQuestion?: QuizEventsReturn.PreviousQuestion;
+    addToCart: QuizEventsReturn.AddToCart;
+    resultClick: QuizEventsReturn.ResultClick;
+    customClickItemCallback: boolean;
 }
 declare const _default: React.Context<Partial<QuizContextValue>>;
 export default _default;

package/lib/types/components/CioQuiz/index.d.ts

@@ -1,14 +1,3 @@
 /// <reference types="react" />
-import ConstructorIOClient from '@constructor-io/constructorio-client-javascript';
-import { ResultsProps } from '../Results/Results';
-export interface ResultsPageOptions extends ResultsProps {
-    numResultsToDisplay?: number;
-}
-export interface IQuizProps {
-    quizId: string;
-    apiKey?: string;
-    cioJsClient?: ConstructorIOClient;
-    resultsPageOptions: ResultsPageOptions;
-    quizVersionId?: string;
-}
+import { IQuizProps } from '../../types';
 export default function CioQuiz(props: IQuizProps): JSX.Element | null;

package/lib/types/components/CioQuiz/quizApiReducer.d.ts

@@ -0,0 +1,14 @@
+import { RequestStates } from '../../constants';
+import { NextQuestionResponse, QuizResultsResponse } from '../../types';
+import { ActionQuizAPI } from './actions';
+export type QuizAPIReducerState = {
+    quizRequestState: RequestStates;
+    quizVersionId?: string;
+    quizSessionId?: string;
+    quizFirstQuestion?: NextQuestionResponse;
+    quizCurrentQuestion?: NextQuestionResponse;
+    quizResults?: QuizResultsResponse;
+    quizResultsFilters?: string[];
+};
+export declare const initialState: QuizAPIReducerState;
+export default function apiReducer(state: QuizAPIReducerState, action: ActionQuizAPI): QuizAPIReducerState;

package/lib/types/components/CioQuiz/{reducer.d.ts → quizLocalReducer.d.ts}

@@ -1,6 +1,6 @@
 import { ActionAnswerQuestion, OpenTextQuestionPayload, SelectQuestionPayload } from './actions';
 export type Answers = string[][];
-export type QuizReducerState = {
+export type QuizLocalReducerState = {
     answers: Answers;
     answerInputs: {};
     isLastAnswer: boolean;
@@ -8,5 +8,5 @@ export type QuizReducerState = {
 export type AnswerInputState = {
     [key: string]: OpenTextQuestionPayload | SelectQuestionPayload;
 };
-export declare const initialState: QuizReducerState;
-export default function reducer(state: QuizReducerState, action: ActionAnswerQuestion): QuizReducerState;
+export declare const initialState: QuizLocalReducerState;
+export default function quizLocalReducer(state: QuizLocalReducerState, action: ActionAnswerQuestion): QuizLocalReducerState;

package/lib/types/components/QuizQuestions/index.d.ts

@@ -1,5 +1,2 @@
 /// <reference types="react" />
-import { NextQuestionResponse } from '../../types';
-export default function QuizQuestions(props: {
-    questionResponse: NextQuestionResponse;
-}): JSX.Element;
+export default function QuizQuestions(): JSX.Element;

package/lib/types/components/ResultCard/ResultCard.d.ts

@@ -1,9 +1,7 @@
 /// <reference types="react" />
-import { BrowseResultData } from '../../types';
+import { QuizResultDataPartial } from '../../types';
 interface ResultCardProps {
-    result: Partial<BrowseResultData>;
-    addToCartCallback: (clickedResult: Partial<BrowseResultData>) => any;
-    clickItemCallback?: (clickedResult: Partial<BrowseResultData>) => any;
+    result: QuizResultDataPartial;
     salePriceKey?: string;
     regularPriceKey?: string;
     resultPosition: number;

package/lib/types/components/ResultContainer/ResultContainer.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="react" />
-import { ResultsProps } from '../Results/Results';
+import { ResultsProps } from '../../types';
 export interface IResultContainerProps {
     options: ResultsProps;
-    resetQuizSessionId: () => void;
 }
 export default function ResultContainer(props: IResultContainerProps): JSX.Element;

package/lib/types/components/ResultCtaButton/ResultCtaButton.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="react" />
-import { BrowseResultData } from '../../types';
+import { QuizResultDataPartial } from '../../types';
 interface ResultCtaButtonProps {
-    item: Partial<BrowseResultData>;
+    item: QuizResultDataPartial;
     className?: string;
-    callback?: (item: Partial<BrowseResultData>) => any;
     price?: number;
 }
 export default function ResultCtaButton(props: ResultCtaButtonProps): JSX.Element;

package/lib/types/components/ResultFilters/ResultFilters.d.ts

@@ -1,6 +1,3 @@
-import React from 'react';
-interface ResultFiltersProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
-    filters?: any;
-}
-declare function ResultFilters(props: ResultFiltersProps): JSX.Element;
+/// <reference types="react" />
+declare function ResultFilters(): JSX.Element;
 export default ResultFilters;

package/lib/types/components/Results/Results.d.ts

@@ -1,10 +1,4 @@
 /// <reference types="react" />
-import { BrowseResultData } from '../../types';
-export interface ResultsProps {
-    addToCartCallback: (item: Partial<BrowseResultData>) => any;
-    clickItemCallback?: (item: Partial<BrowseResultData>) => any;
-    resultCardSalePriceKey?: string;
-    resultCardRegularPriceKey?: string;
-}
+import { ResultsProps } from '../../types';
 declare function Results(props: ResultsProps): JSX.Element;
 export default Results;

package/lib/types/components/ZeroResults/ZeroResults.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 interface ZeroResultsProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
-    onResetClick?: () => {};
+    resetQuizClickHandler?: () => {};
 }
 declare function ZeroResults(props: ZeroResultsProps): JSX.Element;
 export default ZeroResults;