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, {
  QUESTION_DIFFICULTY: () => QUESTION_DIFFICULTY,
  QUESTION_STATUS: () => QUESTION_STATUS,
  QUESTION_TYPE: () => QUESTION_TYPE,
  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 QUESTION_TYPE = /* @__PURE__ */ ((QUESTION_TYPE2) => {
  QUESTION_TYPE2["ALTERNATIVA"] = "ALTERNATIVA";
  QUESTION_TYPE2["DISSERTATIVA"] = "DISSERTATIVA";
  QUESTION_TYPE2["MULTIPLA_CHOICE"] = "MULTIPLA_CHOICE";
  return QUESTION_TYPE2;
})(QUESTION_TYPE || {});
var QUESTION_STATUS = /* @__PURE__ */ ((QUESTION_STATUS2) => {
  QUESTION_STATUS2["APROVADO"] = "APROVADO";
  QUESTION_STATUS2["REPROVADO"] = "REPROVADO";
  return QUESTION_STATUS2;
})(QUESTION_STATUS || {});
var useQuizStore = (0, import_zustand.create)()(
  (0, import_middleware.devtools)(
    (set, get) => {
      let timerInterval = 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;
        }
      };
      return {
        // Initial State
        currentQuestionIndex: 0,
        selectedAnswers: {},
        userAnswers: [],
        timeElapsed: 0,
        isStarted: false,
        isFinished: false,
        userId: "",
        // Setters
        setBySimulated: (simulado) => set({ bySimulated: simulado }),
        setByActivity: (atividade) => set({ byActivity: atividade }),
        setByQuestionary: (aula) => set({ byQuestionary: aula }),
        setUserId: (userId) => set({ userId }),
        setUserAnswers: (userAnswers) => set({ userAnswers }),
        getUserId: () => get().userId,
        // 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 });
          }
        },
        getActiveQuiz: () => {
          const { bySimulated, byActivity, byQuestionary } = get();
          if (bySimulated)
            return { quiz: bySimulated, type: "bySimulated" };
          if (byActivity)
            return { quiz: byActivity, type: "byActivity" };
          if (byQuestionary)
            return { quiz: byQuestionary, type: "byQuestionary" };
          return null;
        },
        selectAnswer: (questionId, answerId) => {
          const { getActiveQuiz, userAnswers } = get();
          const activeQuiz = getActiveQuiz();
          if (!activeQuiz) return;
          const activityId = activeQuiz.quiz.id;
          const userId = get().getUserId();
          if (!userId || userId === "") {
            console.warn("selectAnswer called before userId is set");
            return;
          }
          const existingAnswerIndex = userAnswers.findIndex(
            (answer) => answer.questionId === questionId
          );
          const newUserAnswer = {
            questionId,
            activityId,
            userId,
            answer: null,
            optionId: answerId
          };
          let updatedUserAnswers;
          if (existingAnswerIndex !== -1) {
            updatedUserAnswers = [...userAnswers];
            updatedUserAnswers[existingAnswerIndex] = newUserAnswer;
          } else {
            updatedUserAnswers = [...userAnswers, newUserAnswer];
          }
          set({
            userAnswers: updatedUserAnswers
          });
        },
        selectMultipleAnswer: (questionId, answerIds) => {
          const { getActiveQuiz, userAnswers } = get();
          const activeQuiz = getActiveQuiz();
          if (!activeQuiz) return;
          const activityId = activeQuiz.quiz.id;
          const userId = get().getUserId();
          if (!userId || userId === "") {
            console.warn("selectMultipleAnswer called before userId is set");
            return;
          }
          const filteredUserAnswers = userAnswers.filter(
            (answer) => answer.questionId !== questionId
          );
          const newUserAnswers = answerIds.map(
            (answerId) => ({
              questionId,
              activityId,
              userId,
              answer: null,
              optionId: answerId
            })
          );
          const updatedUserAnswers = [
            ...filteredUserAnswers,
            ...newUserAnswers
          ];
          set({
            userAnswers: updatedUserAnswers
          });
        },
        skipQuestion: () => {
          const { getCurrentQuestion, userAnswers, getActiveQuiz } = get();
          const currentQuestion = getCurrentQuestion();
          const activeQuiz = getActiveQuiz();
          if (!activeQuiz) return;
          if (currentQuestion) {
            const activityId = activeQuiz.quiz.id;
            const userId = get().getUserId();
            if (!userId || userId === "") {
              console.warn("skipQuestion called before userId is set");
              return;
            }
            const existingAnswerIndex = userAnswers.findIndex(
              (answer) => answer.questionId === currentQuestion.id
            );
            const newUserAnswer = {
              questionId: currentQuestion.id,
              activityId,
              userId,
              answer: null,
              optionId: null
            };
            let updatedUserAnswers;
            if (existingAnswerIndex !== -1) {
              updatedUserAnswers = [...userAnswers];
              updatedUserAnswers[existingAnswerIndex] = newUserAnswer;
            } else {
              updatedUserAnswers = [...userAnswers, newUserAnswer];
            }
            set({
              userAnswers: updatedUserAnswers
            });
          }
        },
        addUserAnswer: (questionId, answerId) => {
          const { getActiveQuiz, userAnswers } = get();
          const activeQuiz = getActiveQuiz();
          if (!activeQuiz) return;
          const activityId = activeQuiz.quiz.id;
          const userId = get().getUserId();
          if (!userId || userId === "") {
            console.warn("addUserAnswer called before userId is set");
            return;
          }
          const existingAnswerIndex = userAnswers.findIndex(
            (answer) => answer.questionId === questionId
          );
          const newUserAnswer = {
            questionId,
            activityId,
            userId,
            answer: null,
            optionId: answerId || null
          };
          if (existingAnswerIndex !== -1) {
            const updatedUserAnswers = [...userAnswers];
            updatedUserAnswers[existingAnswerIndex] = newUserAnswer;
            set({ userAnswers: updatedUserAnswers });
          } else {
            set({ userAnswers: [...userAnswers, newUserAnswer] });
          }
        },
        startQuiz: () => {
          set({ isStarted: true, timeElapsed: 0 });
          startTimer();
        },
        finishQuiz: () => {
          set({ isFinished: true });
          stopTimer();
        },
        resetQuiz: () => {
          stopTimer();
          set({
            currentQuestionIndex: 0,
            selectedAnswers: {},
            userAnswers: [],
            timeElapsed: 0,
            isStarted: false,
            isFinished: false,
            userId: ""
          });
        },
        // Timer
        updateTime: (time) => set({ timeElapsed: time }),
        startTimer,
        stopTimer,
        // Getters
        getCurrentQuestion: () => {
          const { currentQuestionIndex, getActiveQuiz } = get();
          const activeQuiz = getActiveQuiz();
          if (!activeQuiz) {
            return null;
          }
          return activeQuiz.quiz.questions[currentQuestionIndex];
        },
        getTotalQuestions: () => {
          const { getActiveQuiz } = get();
          const activeQuiz = getActiveQuiz();
          return activeQuiz?.quiz?.questions?.length || 0;
        },
        getAnsweredQuestions: () => {
          const { userAnswers } = get();
          return userAnswers.filter((answer) => answer.optionId !== null).length;
        },
        getUnansweredQuestions: () => {
          const { getActiveQuiz, userAnswers } = get();
          const activeQuiz = getActiveQuiz();
          if (!activeQuiz) return [];
          const unansweredQuestions = [];
          activeQuiz.quiz.questions.forEach((question, index) => {
            const userAnswer = userAnswers.find(
              (answer) => answer.questionId === question.id
            );
            const isAnswered = userAnswer && userAnswer.optionId !== null;
            const isSkipped = userAnswer && userAnswer.optionId === null;
            if (!isAnswered && !isSkipped) {
              unansweredQuestions.push(index + 1);
            }
          });
          return unansweredQuestions;
        },
        getSkippedQuestions: () => {
          const { userAnswers } = get();
          return userAnswers.filter((answer) => answer.optionId === 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 : false;
        },
        isQuestionSkipped: (questionId) => {
          const { userAnswers } = get();
          const userAnswer = userAnswers.find(
            (answer) => answer.questionId === questionId
          );
          return userAnswer ? userAnswer.optionId === null : false;
        },
        getCurrentAnswer: () => {
          const { getCurrentQuestion, userAnswers } = get();
          const currentQuestion = getCurrentQuestion();
          if (!currentQuestion) return void 0;
          const userAnswer = userAnswers.find(
            (answer) => answer.questionId === currentQuestion.id
          );
          return userAnswer?.optionId;
        },
        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 { getActiveQuiz } = get();
          const activeQuiz = getActiveQuiz();
          return activeQuiz?.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 { getActiveQuiz, userAnswers } = get();
          const activeQuiz = getActiveQuiz();
          if (!activeQuiz) return [];
          const unansweredQuestions = [];
          activeQuiz.quiz.questions.forEach((question, index) => {
            const userAnswer = userAnswers.find(
              (answer) => answer.questionId === question.id
            );
            const hasAnswer = userAnswer && userAnswer.optionId !== null;
            const isSkipped = userAnswer && userAnswer.optionId === null;
            if (!hasAnswer || isSkipped) {
              unansweredQuestions.push(index + 1);
            }
          });
          return unansweredQuestions;
        },
        getQuestionsGroupedBySubject: () => {
          const { getActiveQuiz } = get();
          const activeQuiz = getActiveQuiz();
          if (!activeQuiz) return {};
          const groupedQuestions = {};
          activeQuiz.quiz.questions.forEach((question) => {
            const subjectId = question.knowledgeMatrix?.[0]?.subjectId || "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 : 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 { getActiveQuiz } = get();
          const activeQuiz = getActiveQuiz();
          if (!activeQuiz) return;
          const questionIndex = activeQuiz.quiz.questions.findIndex(
            (q) => q.id === question.id
          );
          if (questionIndex === -1) {
            console.warn(
              `Question with id "${question.id}" not found in active quiz`
            );
            return;
          }
          set({ currentQuestionIndex: questionIndex });
        }
      };
    },
    {
      name: "quiz-store"
    }
  )
);
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  QUESTION_DIFFICULTY,
  QUESTION_STATUS,
  QUESTION_TYPE,
  useQuizStore
});
//# sourceMappingURL=index.js.map