analytica-frontend-lib/dist/Quiz/useQuizStore/index.js

Repositório público dos componentes utilizados nas plataformas da Analytica Ensino

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/components/Quiz/useQuizStore.ts
var useQuizStore_exports = {};
__export(useQuizStore_exports, {
  ANSWER_STATUS: () => ANSWER_STATUS,
  MINUTE_INTERVAL_MS: () => MINUTE_INTERVAL_MS,
  QUESTION_DIFFICULTY: () => QUESTION_DIFFICULTY,
  QUESTION_STATUS: () => QUESTION_STATUS,
  QUESTION_TYPE: () => QUESTION_TYPE,
  QUIZ_TYPE: () => QUIZ_TYPE,
  SUBTYPE_ENUM: () => SUBTYPE_ENUM,
  useQuizStore: () => useQuizStore
});
module.exports = __toCommonJS(useQuizStore_exports);
var import_zustand = require("zustand");
var import_middleware = require("zustand/middleware");
var QUESTION_DIFFICULTY = /* @__PURE__ */ ((QUESTION_DIFFICULTY2) => {
  QUESTION_DIFFICULTY2["FACIL"] = "FACIL";
  QUESTION_DIFFICULTY2["MEDIO"] = "MEDIO";
  QUESTION_DIFFICULTY2["DIFICIL"] = "DIFICIL";
  return QUESTION_DIFFICULTY2;
})(QUESTION_DIFFICULTY || {});
var QUIZ_TYPE = /* @__PURE__ */ ((QUIZ_TYPE2) => {
  QUIZ_TYPE2["SIMULADO"] = "SIMULADO";
  QUIZ_TYPE2["QUESTIONARIO"] = "QUESTIONARIO";
  QUIZ_TYPE2["ATIVIDADE"] = "ATIVIDADE";
  return QUIZ_TYPE2;
})(QUIZ_TYPE || {});
var QUESTION_TYPE = /* @__PURE__ */ ((QUESTION_TYPE2) => {
  QUESTION_TYPE2["ALTERNATIVA"] = "ALTERNATIVA";
  QUESTION_TYPE2["DISSERTATIVA"] = "DISSERTATIVA";
  QUESTION_TYPE2["MULTIPLA_ESCOLHA"] = "MULTIPLA_ESCOLHA";
  QUESTION_TYPE2["VERDADEIRO_FALSO"] = "VERDADEIRO_FALSO";
  QUESTION_TYPE2["LIGAR_PONTOS"] = "LIGAR_PONTOS";
  QUESTION_TYPE2["PREENCHER"] = "PREENCHER";
  QUESTION_TYPE2["IMAGEM"] = "IMAGEM";
  return QUESTION_TYPE2;
})(QUESTION_TYPE || {});
var QUESTION_STATUS = /* @__PURE__ */ ((QUESTION_STATUS2) => {
  QUESTION_STATUS2["PENDENTE_AVALIACAO"] = "PENDENTE_AVALIACAO";
  QUESTION_STATUS2["RESPOSTA_CORRETA"] = "RESPOSTA_CORRETA";
  QUESTION_STATUS2["RESPOSTA_INCORRETA"] = "RESPOSTA_INCORRETA";
  QUESTION_STATUS2["NAO_RESPONDIDO"] = "NAO_RESPONDIDO";
  return QUESTION_STATUS2;
})(QUESTION_STATUS || {});
var ANSWER_STATUS = /* @__PURE__ */ ((ANSWER_STATUS2) => {
  ANSWER_STATUS2["RESPOSTA_CORRETA"] = "RESPOSTA_CORRETA";
  ANSWER_STATUS2["RESPOSTA_INCORRETA"] = "RESPOSTA_INCORRETA";
  ANSWER_STATUS2["PENDENTE_AVALIACAO"] = "PENDENTE_AVALIACAO";
  ANSWER_STATUS2["NAO_RESPONDIDO"] = "NAO_RESPONDIDO";
  return ANSWER_STATUS2;
})(ANSWER_STATUS || {});
var SUBTYPE_ENUM = /* @__PURE__ */ ((SUBTYPE_ENUM2) => {
  SUBTYPE_ENUM2["PROVA"] = "PROVA";
  SUBTYPE_ENUM2["ENEM_PROVA_1"] = "ENEM_PROVA_1";
  SUBTYPE_ENUM2["ENEM_PROVA_2"] = "ENEM_PROVA_2";
  SUBTYPE_ENUM2["VESTIBULAR"] = "VESTIBULAR";
  SUBTYPE_ENUM2["SIMULADO"] = "SIMULADO";
  SUBTYPE_ENUM2["SIMULADAO"] = "SIMULADAO";
  return SUBTYPE_ENUM2;
})(SUBTYPE_ENUM || {});
var MINUTE_INTERVAL_MS = 6e4;
var useQuizStore = (0, import_zustand.create)()(
  (0, import_middleware.devtools)(
    (set, get) => {
      let timerInterval = null;
      let minuteCallbackInterval = null;
      const startTimer = () => {
        if (get().isFinished) {
          return;
        }
        if (timerInterval) {
          clearInterval(timerInterval);
        }
        timerInterval = setInterval(() => {
          const { timeElapsed } = get();
          set({ timeElapsed: timeElapsed + 1 });
        }, 1e3);
      };
      const stopTimer = () => {
        if (timerInterval) {
          clearInterval(timerInterval);
          timerInterval = null;
        }
      };
      const setMinuteCallback = (callback) => {
        set({ minuteCallback: callback });
      };
      const startMinuteCallback = () => {
        const { minuteCallback, isFinished } = get();
        if (isFinished || !minuteCallback) {
          return;
        }
        if (minuteCallbackInterval) {
          clearInterval(minuteCallbackInterval);
        }
        minuteCallbackInterval = setInterval(() => {
          const {
            minuteCallback: currentCallback,
            isFinished: currentIsFinished
          } = get();
          if (currentIsFinished || !currentCallback) {
            stopMinuteCallback();
            return;
          }
          currentCallback();
        }, MINUTE_INTERVAL_MS);
      };
      const stopMinuteCallback = () => {
        if (minuteCallbackInterval) {
          clearInterval(minuteCallbackInterval);
          minuteCallbackInterval = null;
        }
      };
      return {
        // Initial State
        quiz: null,
        currentQuestionIndex: 0,
        selectedAnswers: {},
        userAnswers: [],
        timeElapsed: 0,
        isStarted: false,
        isFinished: false,
        userId: "",
        variant: "default",
        minuteCallback: null,
        dissertativeCharLimit: void 0,
        questionsResult: null,
        currentQuestionResult: null,
        // Setters
        setQuiz: (quiz) => set({ quiz }),
        setUserId: (userId) => set({ userId }),
        setUserAnswers: (userAnswers) => set({ userAnswers }),
        getUserId: () => get().userId,
        setVariant: (variant) => set({ variant }),
        setQuestionResult: (questionsResult) => set({ questionsResult }),
        setDissertativeCharLimit: (limit) => set({ dissertativeCharLimit: limit }),
        getDissertativeCharLimit: () => get().dissertativeCharLimit,
        // Navigation
        goToNextQuestion: () => {
          const { currentQuestionIndex, getTotalQuestions } = get();
          const totalQuestions = getTotalQuestions();
          if (currentQuestionIndex < totalQuestions - 1) {
            set({ currentQuestionIndex: currentQuestionIndex + 1 });
          }
        },
        goToPreviousQuestion: () => {
          const { currentQuestionIndex } = get();
          if (currentQuestionIndex > 0) {
            set({ currentQuestionIndex: currentQuestionIndex - 1 });
          }
        },
        goToQuestion: (index) => {
          const { getTotalQuestions } = get();
          const totalQuestions = getTotalQuestions();
          if (index >= 0 && index < totalQuestions) {
            set({ currentQuestionIndex: index });
          }
        },
        selectAnswer: (questionId, answerId) => {
          const { quiz, userAnswers } = get();
          if (!quiz) return;
          const activityId = quiz.id;
          const userId = get().getUserId();
          if (!userId || userId === "") {
            return;
          }
          const question = quiz.questions.find((q) => q.id === questionId);
          if (!question) return;
          const existingAnswerIndex = userAnswers.findIndex(
            (answer) => answer.questionId === questionId
          );
          const newUserAnswer = {
            questionId,
            activityId,
            userId,
            answer: question.questionType === "DISSERTATIVA" /* DISSERTATIVA */ ? answerId : null,
            optionId: question.questionType === "DISSERTATIVA" /* DISSERTATIVA */ ? null : answerId,
            questionType: question.questionType,
            answerStatus: "PENDENTE_AVALIACAO" /* PENDENTE_AVALIACAO */
          };
          let updatedUserAnswers;
          if (existingAnswerIndex !== -1) {
            updatedUserAnswers = [...userAnswers];
            updatedUserAnswers[existingAnswerIndex] = newUserAnswer;
          } else {
            updatedUserAnswers = [...userAnswers, newUserAnswer];
          }
          set({
            userAnswers: updatedUserAnswers
          });
        },
        selectMultipleAnswer: (questionId, answerIds) => {
          const { quiz, userAnswers } = get();
          if (!quiz) return;
          const activityId = quiz.id;
          const userId = get().getUserId();
          if (!userId || userId === "") {
            return;
          }
          const question = quiz.questions.find((q) => q.id === questionId);
          if (!question) return;
          const filteredUserAnswers = userAnswers.filter(
            (answer) => answer.questionId !== questionId
          );
          const newUserAnswers = answerIds.map(
            (answerId) => ({
              questionId,
              activityId,
              userId,
              answer: null,
              // selectMultipleAnswer is for non-dissertative questions
              optionId: answerId,
              // selectMultipleAnswer should only set optionId
              questionType: question.questionType,
              answerStatus: "PENDENTE_AVALIACAO" /* PENDENTE_AVALIACAO */
            })
          );
          const updatedUserAnswers = [
            ...filteredUserAnswers,
            ...newUserAnswers
          ];
          set({
            userAnswers: updatedUserAnswers
          });
        },
        selectDissertativeAnswer: (questionId, answer) => {
          const { quiz, userAnswers, dissertativeCharLimit } = get();
          if (!quiz) return;
          const activityId = quiz.id;
          const userId = get().getUserId();
          if (!userId || userId === "") {
            return;
          }
          const question = quiz.questions.find((q) => q.id === questionId);
          if (!question || question.questionType !== "DISSERTATIVA" /* DISSERTATIVA */) {
            return;
          }
          let validatedAnswer = answer;
          if (dissertativeCharLimit !== void 0 && answer.length > dissertativeCharLimit) {
            validatedAnswer = answer.substring(0, dissertativeCharLimit);
          }
          const existingAnswerIndex = userAnswers.findIndex(
            (answerItem) => answerItem.questionId === questionId
          );
          const newUserAnswer = {
            questionId,
            activityId,
            userId,
            answer: validatedAnswer,
            optionId: null,
            questionType: "DISSERTATIVA" /* DISSERTATIVA */,
            answerStatus: "PENDENTE_AVALIACAO" /* PENDENTE_AVALIACAO */
          };
          let updatedUserAnswers;
          if (existingAnswerIndex !== -1) {
            updatedUserAnswers = [...userAnswers];
            updatedUserAnswers[existingAnswerIndex] = newUserAnswer;
          } else {
            updatedUserAnswers = [...userAnswers, newUserAnswer];
          }
          set({
            userAnswers: updatedUserAnswers
          });
        },
        skipQuestion: () => {
          const { getCurrentQuestion, userAnswers, quiz } = get();
          const currentQuestion = getCurrentQuestion();
          if (!quiz) return;
          if (currentQuestion) {
            const activityId = quiz.id;
            const userId = get().getUserId();
            if (!userId || userId === "") {
              return;
            }
            const existingAnswerIndex = userAnswers.findIndex(
              (answer) => answer.questionId === currentQuestion.id
            );
            const newUserAnswer = {
              questionId: currentQuestion.id,
              activityId,
              userId,
              answer: null,
              optionId: null,
              questionType: currentQuestion.questionType,
              answerStatus: "PENDENTE_AVALIACAO" /* PENDENTE_AVALIACAO */
            };
            let updatedUserAnswers;
            if (existingAnswerIndex !== -1) {
              updatedUserAnswers = [...userAnswers];
              updatedUserAnswers[existingAnswerIndex] = newUserAnswer;
            } else {
              updatedUserAnswers = [...userAnswers, newUserAnswer];
            }
            set({
              userAnswers: updatedUserAnswers
            });
          }
        },
        skipCurrentQuestionIfUnanswered: () => {
          const { getCurrentQuestion, getCurrentAnswer, skipQuestion } = get();
          const currentQuestion = getCurrentQuestion();
          const currentAnswer = getCurrentAnswer();
          if (!currentQuestion) return;
          if (!currentAnswer || currentAnswer.optionId === null && currentAnswer.answer === null) {
            skipQuestion();
          }
        },
        addUserAnswer: (questionId, answerId) => {
          const { quiz, userAnswers } = get();
          if (!quiz) return;
          const activityId = quiz.id;
          const userId = get().getUserId();
          if (!userId || userId === "") {
            return;
          }
          const question = quiz.questions.find((q) => q.id === questionId);
          if (!question) return;
          const existingAnswerIndex = userAnswers.findIndex(
            (answer) => answer.questionId === questionId
          );
          const newUserAnswer = {
            questionId,
            activityId,
            userId,
            answer: question.questionType === "DISSERTATIVA" /* DISSERTATIVA */ ? answerId || null : null,
            optionId: question.questionType !== "DISSERTATIVA" /* DISSERTATIVA */ ? answerId || null : null,
            questionType: question.questionType,
            answerStatus: "PENDENTE_AVALIACAO" /* PENDENTE_AVALIACAO */
          };
          if (existingAnswerIndex !== -1) {
            const updatedUserAnswers = [...userAnswers];
            updatedUserAnswers[existingAnswerIndex] = newUserAnswer;
            set({ userAnswers: updatedUserAnswers });
          } else {
            set({ userAnswers: [...userAnswers, newUserAnswer] });
          }
        },
        startQuiz: () => {
          set({ isStarted: true, timeElapsed: 0 });
          startTimer();
          startMinuteCallback();
        },
        finishQuiz: () => {
          set({ isFinished: true });
          stopTimer();
          stopMinuteCallback();
        },
        resetQuiz: () => {
          stopTimer();
          stopMinuteCallback();
          set({
            quiz: null,
            currentQuestionIndex: 0,
            selectedAnswers: {},
            userAnswers: [],
            timeElapsed: 0,
            isStarted: false,
            isFinished: false,
            userId: "",
            variant: "default",
            minuteCallback: null,
            dissertativeCharLimit: void 0,
            questionsResult: null,
            currentQuestionResult: null
          });
        },
        // Timer
        updateTime: (time) => set({ timeElapsed: time }),
        startTimer,
        stopTimer,
        // Minute Callback
        setMinuteCallback,
        startMinuteCallback,
        stopMinuteCallback,
        // Getters
        getCurrentQuestion: () => {
          const { currentQuestionIndex, quiz } = get();
          if (!quiz) {
            return null;
          }
          return quiz.questions[currentQuestionIndex];
        },
        getTotalQuestions: () => {
          const { quiz } = get();
          return quiz?.questions?.length || 0;
        },
        getAnsweredQuestions: () => {
          const { userAnswers } = get();
          return userAnswers.filter(
            (answer) => answer.optionId !== null || answer.answer !== null
          ).length;
        },
        getUnansweredQuestions: () => {
          const { quiz, userAnswers } = get();
          if (!quiz) return [];
          const unansweredQuestions = [];
          quiz.questions.forEach((question, index) => {
            const userAnswer = userAnswers.find(
              (answer) => answer.questionId === question.id
            );
            const isAnswered = userAnswer && (userAnswer.optionId !== null || userAnswer.answer !== null);
            const isSkipped = userAnswer && userAnswer.optionId === null && userAnswer.answer === null;
            if (!isAnswered && !isSkipped) {
              unansweredQuestions.push(index + 1);
            }
          });
          return unansweredQuestions;
        },
        getSkippedQuestions: () => {
          const { userAnswers } = get();
          return userAnswers.filter(
            (answer) => answer.optionId === null && answer.answer === null
          ).length;
        },
        getProgress: () => {
          const { getTotalQuestions, getAnsweredQuestions } = get();
          const total = getTotalQuestions();
          const answered = getAnsweredQuestions();
          return total > 0 ? answered / total * 100 : 0;
        },
        isQuestionAnswered: (questionId) => {
          const { userAnswers } = get();
          const userAnswer = userAnswers.find(
            (answer) => answer.questionId === questionId
          );
          return userAnswer ? userAnswer.optionId !== null || userAnswer.answer !== null : false;
        },
        isQuestionSkipped: (questionId) => {
          const { userAnswers } = get();
          const userAnswer = userAnswers.find(
            (answer) => answer.questionId === questionId
          );
          return userAnswer ? userAnswer.optionId === null && userAnswer.answer === null : false;
        },
        getCurrentAnswer: () => {
          const { getCurrentQuestion, userAnswers } = get();
          const currentQuestion = getCurrentQuestion();
          if (!currentQuestion) return void 0;
          const userAnswer = userAnswers.find(
            (answer) => answer.questionId === currentQuestion.id
          );
          const hasAnswerContent = (ua) => !!ua && (ua.optionId !== null && ua.optionId !== "" || ua.answer !== null && ua.answer !== "");
          if (!hasAnswerContent(userAnswer)) {
            return void 0;
          }
          return userAnswer;
        },
        getAllCurrentAnswer: () => {
          const { getCurrentQuestion, userAnswers } = get();
          const currentQuestion = getCurrentQuestion();
          if (!currentQuestion) return void 0;
          const userAnswer = userAnswers.filter(
            (answer) => answer.questionId === currentQuestion.id
          );
          return userAnswer;
        },
        getQuizTitle: () => {
          const { quiz } = get();
          return quiz?.title || "Quiz";
        },
        formatTime: (seconds) => {
          const minutes = Math.floor(seconds / 60);
          const remainingSeconds = seconds % 60;
          return `${minutes.toString().padStart(2, "0")}:${remainingSeconds.toString().padStart(2, "0")}`;
        },
        getUserAnswers: () => {
          const { userAnswers } = get();
          return userAnswers;
        },
        getUnansweredQuestionsFromUserAnswers: () => {
          const { quiz, userAnswers } = get();
          if (!quiz) return [];
          const unansweredQuestions = [];
          quiz.questions.forEach((question, index) => {
            const userAnswer = userAnswers.find(
              (answer) => answer.questionId === question.id
            );
            const hasAnswer = userAnswer && (userAnswer.optionId !== null || userAnswer.answer !== null);
            const isSkipped = userAnswer && userAnswer.optionId === null && userAnswer.answer === null;
            if (!hasAnswer || isSkipped) {
              unansweredQuestions.push(index + 1);
            }
          });
          return unansweredQuestions;
        },
        getQuestionsGroupedBySubject: () => {
          const { getQuestionResult, quiz, variant } = get();
          const questions = variant == "result" ? getQuestionResult()?.answers : quiz?.questions;
          if (!questions) return {};
          const groupedQuestions = {};
          questions.forEach((question) => {
            const subjectId = question.knowledgeMatrix?.[0]?.subject?.id || "Sem mat\xE9ria";
            if (!groupedQuestions[subjectId]) {
              groupedQuestions[subjectId] = [];
            }
            groupedQuestions[subjectId].push(question);
          });
          return groupedQuestions;
        },
        // New methods for userAnswers
        getUserAnswerByQuestionId: (questionId) => {
          const { userAnswers } = get();
          return userAnswers.find((answer) => answer.questionId === questionId) || null;
        },
        isQuestionAnsweredByUserAnswers: (questionId) => {
          const { userAnswers } = get();
          const answer = userAnswers.find(
            (answer2) => answer2.questionId === questionId
          );
          return answer ? answer.optionId !== null || answer.answer !== null : false;
        },
        getQuestionStatusFromUserAnswers: (questionId) => {
          const { userAnswers } = get();
          const answer = userAnswers.find(
            (answer2) => answer2.questionId === questionId
          );
          if (!answer) return "unanswered";
          if (answer.optionId === null) return "skipped";
          return "answered";
        },
        getUserAnswersForActivity: () => {
          const { userAnswers } = get();
          return userAnswers;
        },
        setCurrentQuestion: (question) => {
          const { quiz, variant, questionsResult } = get();
          if (!quiz) return;
          let questionIndex = 0;
          if (variant == "result") {
            if (!questionsResult) return;
            const questionResult = questionsResult.answers.find((q) => q.id === question.id) ?? questionsResult.answers.find((q) => q.questionId === question.id);
            if (!questionResult) return;
            questionIndex = quiz.questions.findIndex(
              (q) => q.id === questionResult.questionId
            );
          } else {
            questionIndex = quiz.questions.findIndex(
              (q) => q.id === question.id
            );
          }
          if (questionIndex === -1) {
            return;
          }
          set({ currentQuestionIndex: questionIndex });
        },
        setAnswerStatus: (questionId, status) => {
          const { userAnswers } = get();
          const existingAnswerIndex = userAnswers.findIndex(
            (answer) => answer.questionId === questionId
          );
          if (existingAnswerIndex !== -1) {
            const updatedUserAnswers = [...userAnswers];
            updatedUserAnswers[existingAnswerIndex] = {
              ...updatedUserAnswers[existingAnswerIndex],
              answerStatus: status
            };
            set({ userAnswers: updatedUserAnswers });
          }
        },
        getAnswerStatus: (questionId) => {
          const { userAnswers } = get();
          const userAnswer = userAnswers.find(
            (answer) => answer.questionId === questionId
          );
          return userAnswer ? userAnswer.answerStatus : null;
        },
        getQuestionIndex: (questionId) => {
          const { questionsResult, variant, quiz } = get();
          if (variant == "result") {
            if (!questionsResult) return 0;
            let idx = questionsResult.answers.findIndex(
              (q) => q.questionId === questionId
            );
            if (idx === -1) {
              idx = questionsResult.answers.findIndex(
                (q) => q.id === questionId
              );
            }
            return idx !== -1 ? idx + 1 : 0;
          } else {
            if (!quiz) return 0;
            const idx = quiz.questions.findIndex((q) => q.id === questionId);
            return idx !== -1 ? idx + 1 : 0;
          }
        },
        // Question Result
        getQuestionResultByQuestionId: (questionId) => {
          const { questionsResult } = get();
          const question = questionsResult?.answers.find(
            (answer) => answer.questionId === questionId
          );
          return question || null;
        },
        getQuestionResultStatistics: () => {
          const { questionsResult } = get();
          return questionsResult?.statistics || null;
        },
        getQuestionResult: () => {
          const { questionsResult } = get();
          return questionsResult;
        },
        setQuestionsResult: (questionsResult) => {
          set({ questionsResult });
        },
        setCurrentQuestionResult: (currentQuestionResult) => {
          set({ currentQuestionResult });
        },
        getCurrentQuestionResult: () => {
          const { currentQuestionResult } = get();
          return currentQuestionResult;
        }
      };
    },
    {
      name: "quiz-store"
    }
  )
);
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ANSWER_STATUS,
  MINUTE_INTERVAL_MS,
  QUESTION_DIFFICULTY,
  QUESTION_STATUS,
  QUESTION_TYPE,
  QUIZ_TYPE,
  SUBTYPE_ENUM,
  useQuizStore
});
//# sourceMappingURL=index.js.map