analytica-frontend-lib 1.0.82 → 1.0.84

package/dist/Quiz/useQuizStore/index.d.mts

@@ -0,0 +1,140 @@
+import * as zustand from 'zustand';
+
+declare enum QUESTION_DIFFICULTY {
+    FACIL = "FACIL",
+    MEDIO = "MEDIO",
+    DIFICIL = "DIFICIL"
+}
+declare enum QUESTION_TYPE {
+    ALTERNATIVA = "ALTERNATIVA",
+    DISSERTATIVA = "DISSERTATIVA",
+    MULTIPLA_CHOICE = "MULTIPLA_CHOICE"
+}
+declare enum QUESTION_STATUS {
+    APROVADO = "APROVADO",
+    REPROVADO = "REPROVADO"
+}
+interface Question {
+    id: string;
+    questionText: string;
+    correctOptionId: string;
+    description: string;
+    type: QUESTION_TYPE;
+    status: QUESTION_STATUS;
+    difficulty: QUESTION_DIFFICULTY;
+    examBoard: string | null;
+    examYear: string | null;
+    answerKey: string | null;
+    createdAt: string;
+    updatedAt: string;
+    knowledgeMatrix: {
+        areaKnowledgeId: string;
+        subjectId: string;
+        topicId: string;
+        subtopicId: string;
+        contentId: string;
+    }[];
+    options: {
+        id: string;
+        option: string;
+    }[];
+    createdBy: string;
+}
+interface Simulado {
+    id: string;
+    title: string;
+    category: string;
+    questions: Question[];
+}
+interface Atividade {
+    id: string;
+    title: string;
+    questions: Question[];
+}
+interface Aula {
+    id: string;
+    title: string;
+    questions: Question[];
+}
+interface UserAnswerItem {
+    questionId: string;
+    activityId: string;
+    userId: string;
+    answer: string | null;
+    optionId: string | null;
+}
+interface UserAnswer extends Question {
+    isSkipped: boolean;
+}
+interface QuizState {
+    bySimulated?: Simulado;
+    byActivity?: Atividade;
+    byQuestionary?: Aula;
+    currentQuestionIndex: number;
+    selectedAnswers: Record<string, string>;
+    userAnswers: UserAnswerItem[];
+    timeElapsed: number;
+    isStarted: boolean;
+    isFinished: boolean;
+    userId: string;
+    setBySimulated: (simulado: Simulado) => void;
+    setByActivity: (atividade: Atividade) => void;
+    setByQuestionary: (aula: Aula) => void;
+    setUserId: (userId: string) => void;
+    goToNextQuestion: () => void;
+    goToPreviousQuestion: () => void;
+    goToQuestion: (index: number) => void;
+    getActiveQuiz: () => {
+        quiz: Simulado | Atividade | Aula;
+        type: 'bySimulated' | 'byActivity' | 'byQuestionary';
+    } | null;
+    selectAnswer: (questionId: string, answerId: string) => void;
+    skipQuestion: () => void;
+    addUserAnswer: (questionId: string, answerId?: string) => void;
+    startQuiz: () => void;
+    finishQuiz: () => void;
+    resetQuiz: () => void;
+    updateTime: (time: number) => void;
+    startTimer: () => void;
+    stopTimer: () => void;
+    getCurrentQuestion: () => Question | null;
+    getTotalQuestions: () => number;
+    getAnsweredQuestions: () => number;
+    getUnansweredQuestions: () => number[];
+    getSkippedQuestions: () => number;
+    getProgress: () => number;
+    isQuestionAnswered: (questionId: string) => boolean;
+    isQuestionSkipped: (questionId: string) => boolean;
+    getCurrentAnswer: () => string | undefined;
+    getQuizTitle: () => string;
+    formatTime: (seconds: number) => string;
+    getUserAnswers: () => UserAnswer[];
+    getUnansweredQuestionsFromUserAnswers: () => number[];
+    getQuestionsGroupedBySubject: () => {
+        [key: string]: Question[];
+    };
+    getUserId: () => string;
+    getUserAnswerByQuestionId: (questionId: string) => UserAnswerItem | null;
+    isQuestionAnsweredByUserAnswers: (questionId: string) => boolean;
+    getQuestionStatusFromUserAnswers: (questionId: string) => 'answered' | 'unanswered' | 'skipped';
+    getUserAnswersForActivity: () => UserAnswerItem[];
+}
+declare const useQuizStore: zustand.UseBoundStore<Omit<zustand.StoreApi<QuizState>, "setState" | "devtools"> & {
+    setState(partial: QuizState | Partial<QuizState> | ((state: QuizState) => QuizState | Partial<QuizState>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: QuizState | ((state: QuizState) => QuizState), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}>;
+
+export { QUESTION_DIFFICULTY, QUESTION_STATUS, QUESTION_TYPE, type Question, useQuizStore };

package/dist/Quiz/useQuizStore/index.d.ts

@@ -0,0 +1,140 @@
+import * as zustand from 'zustand';
+
+declare enum QUESTION_DIFFICULTY {
+    FACIL = "FACIL",
+    MEDIO = "MEDIO",
+    DIFICIL = "DIFICIL"
+}
+declare enum QUESTION_TYPE {
+    ALTERNATIVA = "ALTERNATIVA",
+    DISSERTATIVA = "DISSERTATIVA",
+    MULTIPLA_CHOICE = "MULTIPLA_CHOICE"
+}
+declare enum QUESTION_STATUS {
+    APROVADO = "APROVADO",
+    REPROVADO = "REPROVADO"
+}
+interface Question {
+    id: string;
+    questionText: string;
+    correctOptionId: string;
+    description: string;
+    type: QUESTION_TYPE;
+    status: QUESTION_STATUS;
+    difficulty: QUESTION_DIFFICULTY;
+    examBoard: string | null;
+    examYear: string | null;
+    answerKey: string | null;
+    createdAt: string;
+    updatedAt: string;
+    knowledgeMatrix: {
+        areaKnowledgeId: string;
+        subjectId: string;
+        topicId: string;
+        subtopicId: string;
+        contentId: string;
+    }[];
+    options: {
+        id: string;
+        option: string;
+    }[];
+    createdBy: string;
+}
+interface Simulado {
+    id: string;
+    title: string;
+    category: string;
+    questions: Question[];
+}
+interface Atividade {
+    id: string;
+    title: string;
+    questions: Question[];
+}
+interface Aula {
+    id: string;
+    title: string;
+    questions: Question[];
+}
+interface UserAnswerItem {
+    questionId: string;
+    activityId: string;
+    userId: string;
+    answer: string | null;
+    optionId: string | null;
+}
+interface UserAnswer extends Question {
+    isSkipped: boolean;
+}
+interface QuizState {
+    bySimulated?: Simulado;
+    byActivity?: Atividade;
+    byQuestionary?: Aula;
+    currentQuestionIndex: number;
+    selectedAnswers: Record<string, string>;
+    userAnswers: UserAnswerItem[];
+    timeElapsed: number;
+    isStarted: boolean;
+    isFinished: boolean;
+    userId: string;
+    setBySimulated: (simulado: Simulado) => void;
+    setByActivity: (atividade: Atividade) => void;
+    setByQuestionary: (aula: Aula) => void;
+    setUserId: (userId: string) => void;
+    goToNextQuestion: () => void;
+    goToPreviousQuestion: () => void;
+    goToQuestion: (index: number) => void;
+    getActiveQuiz: () => {
+        quiz: Simulado | Atividade | Aula;
+        type: 'bySimulated' | 'byActivity' | 'byQuestionary';
+    } | null;
+    selectAnswer: (questionId: string, answerId: string) => void;
+    skipQuestion: () => void;
+    addUserAnswer: (questionId: string, answerId?: string) => void;
+    startQuiz: () => void;
+    finishQuiz: () => void;
+    resetQuiz: () => void;
+    updateTime: (time: number) => void;
+    startTimer: () => void;
+    stopTimer: () => void;
+    getCurrentQuestion: () => Question | null;
+    getTotalQuestions: () => number;
+    getAnsweredQuestions: () => number;
+    getUnansweredQuestions: () => number[];
+    getSkippedQuestions: () => number;
+    getProgress: () => number;
+    isQuestionAnswered: (questionId: string) => boolean;
+    isQuestionSkipped: (questionId: string) => boolean;
+    getCurrentAnswer: () => string | undefined;
+    getQuizTitle: () => string;
+    formatTime: (seconds: number) => string;
+    getUserAnswers: () => UserAnswer[];
+    getUnansweredQuestionsFromUserAnswers: () => number[];
+    getQuestionsGroupedBySubject: () => {
+        [key: string]: Question[];
+    };
+    getUserId: () => string;
+    getUserAnswerByQuestionId: (questionId: string) => UserAnswerItem | null;
+    isQuestionAnsweredByUserAnswers: (questionId: string) => boolean;
+    getQuestionStatusFromUserAnswers: (questionId: string) => 'answered' | 'unanswered' | 'skipped';
+    getUserAnswersForActivity: () => UserAnswerItem[];
+}
+declare const useQuizStore: zustand.UseBoundStore<Omit<zustand.StoreApi<QuizState>, "setState" | "devtools"> & {
+    setState(partial: QuizState | Partial<QuizState> | ((state: QuizState) => QuizState | Partial<QuizState>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: QuizState | ((state: QuizState) => QuizState), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}>;
+
+export { QUESTION_DIFFICULTY, QUESTION_STATUS, QUESTION_TYPE, type Question, useQuizStore };

package/dist/Quiz/useQuizStore/index.js

@@ -0,0 +1,395 @@
+"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 }),
+        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 updatedQuestions = activeQuiz.quiz.questions.map(
+            (question) => question.id === questionId ? { ...question, answerKey: answerId } : question
+          );
+          const updatedQuiz = {
+            ...activeQuiz.quiz,
+            questions: updatedQuestions
+          };
+          const activityId = activeQuiz.quiz.id;
+          const userId = get().getUserId();
+          if (!userId) {
+            console.warn("selectAnswer called before userId is set");
+            return;
+          }
+          const existingAnswerIndex = userAnswers.findIndex(
+            (answer) => answer.questionId === questionId
+          );
+          const newUserAnswer = {
+            questionId,
+            activityId,
+            userId,
+            answer: answerId,
+            optionId: answerId
+          };
+          let updatedUserAnswers;
+          if (existingAnswerIndex !== -1) {
+            updatedUserAnswers = [...userAnswers];
+            updatedUserAnswers[existingAnswerIndex] = newUserAnswer;
+          } else {
+            updatedUserAnswers = [...userAnswers, newUserAnswer];
+          }
+          set({
+            [activeQuiz.type]: updatedQuiz,
+            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();
+            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();
+          const existingAnswerIndex = userAnswers.findIndex(
+            (answer) => answer.questionId === questionId
+          );
+          const newUserAnswer = {
+            questionId,
+            activityId,
+            userId,
+            answer: answerId || 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.answer !== 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.answer !== null;
+            const isSkipped = userAnswer && userAnswer.answer === null;
+            if (!isAnswered && !isSkipped) {
+              unansweredQuestions.push(index + 1);
+            }
+          });
+          return unansweredQuestions;
+        },
+        getSkippedQuestions: () => {
+          const { userAnswers } = get();
+          return userAnswers.filter((answer) => 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.answer !== null : false;
+        },
+        isQuestionSkipped: (questionId) => {
+          const { userAnswers } = get();
+          const userAnswer = userAnswers.find(
+            (answer) => answer.questionId === questionId
+          );
+          return userAnswer ? 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
+          );
+          return userAnswer?.answer;
+        },
+        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 { getActiveQuiz, userAnswers } = get();
+          const activeQuiz = getActiveQuiz();
+          if (!activeQuiz) return [];
+          return activeQuiz.quiz.questions.map((question) => {
+            const userAnswer = userAnswers.find(
+              (answer) => answer.questionId === question.id
+            );
+            return {
+              ...question,
+              isSkipped: userAnswer ? userAnswer.answer === null : false
+            };
+          });
+        },
+        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.answer !== null;
+            const isSkipped = userAnswer && userAnswer.answer === 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.answer !== null : false;
+        },
+        getQuestionStatusFromUserAnswers: (questionId) => {
+          const { userAnswers } = get();
+          const answer = userAnswers.find(
+            (answer2) => answer2.questionId === questionId
+          );
+          if (!answer) return "unanswered";
+          if (answer.answer === null) return "skipped";
+          return "answered";
+        },
+        getUserAnswersForActivity: () => {
+          const { userAnswers } = get();
+          return userAnswers;
+        }
+      };
+    },
+    {
+      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