@nualang/nualang-ui-components 0.1.1399 → 0.2.0

package/dist/Exercises/Roleplay/Games/ActItOutGameSpeaking/package.json

@@ -1,6 +0,0 @@
-{
-  "name": "ActItOutGame",
-  "version": "0.0.0",
-  "private": true,
-  "main": "./ActItOutGame.js"
-}

package/dist/Exercises/Roleplay/Games/BeforeElements.js

@@ -1,68 +0,0 @@
-import Box from "@mui/material/Box";
-import Divider from "@mui/material/Divider";
-import Grid from "@mui/material/Grid";
-import Typography from "@mui/material/Typography";
-import RoleplayInfo from "../RoleplayInfo/RoleplayInfo";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-function BeforeElements({
-  t,
-  roleplay,
-  roleplayGame,
-  gameId,
-  handleViewRoleplayPreview,
-  isLiveGame = false
-}) {
-  return /*#__PURE__*/_jsxs(Box, {
-    sx: {
-      mb: 2
-    },
-    children: [/*#__PURE__*/_jsxs(Box, {
-      sx: () => ({
-        mx: "auto",
-        mb: 2,
-        maxWidth: 800
-      }),
-      children: [/*#__PURE__*/_jsx(RoleplayInfo, {
-        ...roleplay,
-        gameId: gameId,
-        t: t,
-        handleViewRoleplayPreview: handleViewRoleplayPreview,
-        isLiveGame: isLiveGame
-      }), /*#__PURE__*/_jsx(Divider, {
-        sx: {
-          borderBottomWidth: 5
-        }
-      })]
-    }), /*#__PURE__*/_jsx(Grid, {
-      sx: {
-        display: "flex",
-        justifyContent: "center"
-      },
-      children: /*#__PURE__*/_jsxs(Box, {
-        sx: {
-          display: "flex",
-          flexDirection: "column"
-        },
-        children: [/*#__PURE__*/_jsx(Typography, {
-          align: "center",
-          variant: "h6",
-          component: "h2",
-          gutterBottom: true,
-          sx: {
-            fontWeight: 600
-          },
-          children: t(roleplayGame?.gameName)
-        }), /*#__PURE__*/_jsx(Typography, {
-          align: "center",
-          variant: "subtitle",
-          color: "textSecondary",
-          sx: {
-            pb: 5
-          },
-          children: t(roleplayGame?.gameDescription)
-        })]
-      })
-    })]
-  });
-}
-export default BeforeElements;

package/dist/Exercises/Roleplay/Games/FillInTheBlanksGame/FillInBlanks.js

@@ -1,264 +0,0 @@
-import { useState, useEffect } from "react";
-import { Box, Grid, Button, IconButton } from "@mui/material";
-import CloseIcon from "@mui/icons-material/Close";
-import CheckIcon from "@mui/icons-material/Check";
-import { removeAllSymbolsFillInBlanks } from "../../../../utils";
-import { replaceWordWithBlank } from "../../../../utils";
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-const WordButton = ({
-  languageTag,
-  word,
-  fillBlankWord,
-  setClickCounter,
-  clickCounter,
-  removeBlankWord,
-  displayAnswer,
-  currentMessage,
-  isSpeaking
-}) => {
-  const [isClicked, setIsClicked] = useState(false);
-  const [isCorrect, setIsCorrect] = useState(false);
-  const [isIncorrect, setIsIncorrect] = useState(false);
-  const [displayButtonAnswer, setDisplayButtonAnswer] = useState(false);
-  const handleClickWord = () => {
-    fillBlankWord(word, setIsCorrect, setIsIncorrect);
-    setIsClicked(true);
-    setClickCounter(clickCounter + 1);
-  };
-  const handleCancelWord = () => {
-    removeBlankWord(word);
-    setIsClicked(false);
-    setClickCounter(clickCounter - 1);
-    setIsCorrect(false);
-    setIsIncorrect(false);
-    setDisplayButtonAnswer(false);
-  };
-  useEffect(() => {
-    if (displayAnswer && isClicked) {
-      setDisplayButtonAnswer(true);
-      if (currentMessage?.text === currentMessage?.correctAnswer) {
-        setIsClicked(false);
-        setDisplayButtonAnswer(false);
-      }
-    }
-  }, [displayAnswer]);
-  return /*#__PURE__*/_jsx(Grid, {
-    children: /*#__PURE__*/_jsxs(Box, {
-      sx: {
-        display: "flex",
-        p: 0.5
-      },
-      children: [/*#__PURE__*/_jsx(Button, {
-        onClick: () => clickCounter < (currentMessage.blankIndexes || []).length && !isClicked && handleClickWord(),
-        color: displayButtonAnswer ? isCorrect ? "secondary" : isIncorrect ? "error" : "primary" : "primary",
-        variant: displayButtonAnswer ? "contained" : "outlined",
-        disabled: isSpeaking ? true : displayButtonAnswer ? false : isClicked ? true : false,
-        endIcon: displayButtonAnswer && isCorrect ? /*#__PURE__*/_jsx(CheckIcon, {
-          fontSize: "small"
-        }) : null,
-        sx: {
-          textTransform: "none"
-        },
-        lang: languageTag,
-        "aria-label": displayButtonAnswer && isCorrect ? `Correct answer word: ${word}` : isIncorrect ? `Incorrect answer word: ${word}` : "",
-        children: word
-      }), isClicked && !(displayButtonAnswer && isCorrect) && /*#__PURE__*/_jsx(IconButton, {
-        variant: "contained",
-        disabled: isSpeaking,
-        sx: {
-          m: 0,
-          p: 0
-        },
-        style: {
-          backgroundColor: "transparent"
-        },
-        onClick: handleCancelWord,
-        "aria-label": `Remove the incorrect answer word: ${word}`,
-        children: /*#__PURE__*/_jsx(CloseIcon, {
-          fontSize: "small"
-        })
-      })]
-    })
-  });
-};
-function FillInBlanks({
-  t = text => text,
-  message,
-  handleCorrectQuestionAnswer,
-  handleIncorrectQuestionAnswer,
-  setNewChat,
-  showCorrectAnswer,
-  openSnackbar,
-  messageCounter,
-  isSpeaking,
-  languageInformation
-}) {
-  const [currentMessage, setCurrentMessage] = useState(null);
-  const [clickCounter, setClickCounter] = useState(showCorrectAnswer ? 2 : 0);
-  const [displayAnswer, setDisplayAnswer] = useState(showCorrectAnswer);
-  const [previousAnswers, setPreviousAnswers] = useState([]);
-  const [hideSelectButton, setHideSelectButton] = useState(showCorrectAnswer);
-  useEffect(() => {
-    if (!currentMessage && message) {
-      // First message
-      setCurrentMessage(message);
-    } else if (currentMessage && (currentMessage.correctAnswer !== message.correctAnswer || currentMessage.correctAnswer === message.correctAnswer && currentMessage.name !== message.name)) {
-      // New message, reset state
-      setCurrentMessage(message);
-      setClickCounter(0);
-      setDisplayAnswer(false);
-      setPreviousAnswers([]);
-      setHideSelectButton(false);
-    }
-  }, [message, currentMessage]);
-  const getRandomFeedbackMessage = feedbackArray => {
-    const feedback = feedbackArray[Math.floor(Math.random() * feedbackArray.length)];
-    return feedback;
-  };
-  const wordsPerRow = 3;
-  const languageTag = languageInformation.Code;
-  const handleAnswer = () => {
-    setDisplayAnswer(true);
-    previousAnswers.push(currentMessage.text);
-    let textWithBlanks = currentMessage.correctAnswer;
-    currentMessage.blanks.forEach(blank => {
-      textWithBlanks = replaceWordWithBlank(blank, textWithBlanks);
-    });
-    if (currentMessage.text === currentMessage.correctAnswer) {
-      // correct answer
-      setHideSelectButton(true);
-      openSnackbar(getRandomFeedbackMessage(languageInformation?.correctAnswerMessage) || t("correct"), "success");
-      handleCorrectQuestionAnswer(textWithBlanks, currentMessage);
-    } else {
-      openSnackbar(getRandomFeedbackMessage(languageInformation?.incorrectAnswerMessage) || t("incorrect"), "error");
-      handleIncorrectQuestionAnswer(textWithBlanks, currentMessage);
-    }
-  };
-  const fillBlankWord = (word, setIsCorrect, setIsIncorrect) => {
-    const newBlankChat = currentMessage;
-    const textArray = newBlankChat.text.split(" ");
-    const correctAnswerSplit = removeAllSymbolsFillInBlanks(currentMessage.correctAnswer).split(" ");
-    let i = 0;
-    let finished = false;
-    while (!finished) {
-      if (i >= textArray.length) {
-        finished = true;
-        break;
-      } else {
-        if (textArray[i].includes("_____")) {
-          const newWord = textArray[i].replace("_____", word);
-          textArray[i] = newWord;
-          if (correctAnswerSplit[i] === word) {
-            setIsCorrect(true);
-          } else {
-            setIsIncorrect(true);
-          }
-          finished = true;
-          break;
-        }
-        i += 1;
-      }
-    }
-    newBlankChat.text = textArray.join(" ");
-    setNewChat(newBlankChat);
-  };
-  const removeBlankWord = word => {
-    const newBlankChat = currentMessage;
-    const textArray = newBlankChat.text.split(" ");
-    let i = 0;
-    let finished = false;
-    while (!finished) {
-      if (i >= textArray.length) {
-        finished = true;
-        break;
-      } else {
-        if (removeAllSymbolsFillInBlanks(textArray[i]) === word && currentMessage.blankIndexes.includes(i)) {
-          const newWord = textArray[i].replace(word, "_____");
-          textArray[i] = newWord;
-          finished = true;
-          break;
-        }
-        i += 1;
-      }
-    }
-    newBlankChat.text = textArray.join(" ");
-    setNewChat(newBlankChat);
-    if (displayAnswer) {
-      setDisplayAnswer(false);
-    }
-  };
-  const determineWord = word => {
-    if (showCorrectAnswer) {
-      if (currentMessage.blanks.includes(word)) {
-        return true;
-      } else return false;
-    }
-    return false;
-  };
-  return /*#__PURE__*/_jsx(_Fragment, {
-    children: currentMessage && currentMessage.text && currentMessage.blanks && /*#__PURE__*/_jsxs(Box, {
-      sx: {
-        display: "flex",
-        flexDirection: "column",
-        justifyContent: "center",
-        alignItems: "center",
-        pb: 2,
-        mb: 4
-      },
-      children: [/*#__PURE__*/_jsx(Box, {
-        children: /*#__PURE__*/_jsx(Grid, {
-          container: true,
-          sx: {
-            display: "flex",
-            justifyContent: "center",
-            flexDirection: "column"
-          },
-          children: currentMessage.answers && currentMessage.answers.map((word, index) => {
-            return /*#__PURE__*/_jsx(Box, {
-              sx: {
-                display: "flex",
-                justifyContent: "center"
-              },
-              children: index % wordsPerRow === 0 && /*#__PURE__*/_jsx(Box, {
-                sx: {
-                  display: "flex"
-                },
-                children: currentMessage.answers.filter((c, i) => i >= index && i < index + wordsPerRow).map(word => {
-                  return /*#__PURE__*/_jsx(Box, {
-                    children: /*#__PURE__*/_jsx(WordButton, {
-                      languageTag: languageTag,
-                      word: word,
-                      determineWord: determineWord,
-                      fillBlankWord: fillBlankWord,
-                      setClickCounter: setClickCounter,
-                      clickCounter: clickCounter,
-                      removeBlankWord: removeBlankWord,
-                      displayAnswer: displayAnswer,
-                      currentMessage: currentMessage,
-                      isSpeaking: isSpeaking
-                    })
-                  }, `word-button-${word}-${messageCounter}`);
-                })
-              })
-            }, index);
-          })
-        })
-      }), /*#__PURE__*/_jsx(Button, {
-        "data-cy": "select-roleplay-answer",
-        disabled: isSpeaking || clickCounter < (currentMessage.blankIndexes || []).length,
-        color: "secondary",
-        variant: "contained",
-        onClick: () => {
-          handleAnswer();
-        },
-        id: "fillInTheBlanksAnswer",
-        sx: {
-          mt: 2,
-          display: hideSelectButton ? "none" : "auto"
-        },
-        children: t("check_answer")
-      })]
-    })
-  });
-}
-export default FillInBlanks;

package/dist/Exercises/Roleplay/Games/FillInTheBlanksGame/FillInTheBlanksGame.js

@@ -1,360 +0,0 @@
-import { useState, useEffect } from "react";
-import { Dialog, Button, Box } from "@mui/material";
-import SpaceBarIcon from "@mui/icons-material/SpaceBar";
-import useRecognition from "../../../../hooks/useRecognition";
-import useExerciseState from "../../../../hooks/useExerciseState";
-import useExerciseDocumentTitle from "../../../../hooks/useExerciseDocumentTitle";
-import FillInBlanks from "./FillInBlanks";
-import Chat from "../../../../Chat/Chat";
-import CloseExerciseMenu from "../../../../Dialogs/ExerciseMenu/Menus/CloseExercise/CloseExercise";
-import InProgressExerciseMenu from "../../../../Dialogs/ExerciseMenu/Menus/InProgressExercise/InProgressExercise";
-import CompletedExcercise from "../../../../Dialogs/ExerciseMenu/Menus/CompletedExcercise/CompletedExcercise";
-import TopBarActions from "../TopBarActions";
-import Transition from "../Transition";
-import BeforeElements from "../BeforeElements";
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-const filterExistingMessages = existingMessages => {
-  if (existingMessages && existingMessages.length && existingMessages[existingMessages.length - 1] && existingMessages[existingMessages.length - 1].text !== existingMessages[existingMessages.length - 1].correctAnswer) {
-    // Remove unanswered messages
-    return existingMessages.filter((_, index) => index !== existingMessages.length - 1);
-  } else {
-    return existingMessages;
-  }
-};
-function RoleplayGame({
-  t = text => text,
-  roleplayGame,
-  roleplay,
-  gameId,
-  handleSpeak,
-  handleStopSpeaking,
-  handleTranslate,
-  learnLang,
-  forLang,
-  handleClose,
-  open = true,
-  exerciseName,
-  existingAnswerAttempts,
-  existingMessages,
-  exerciseStartTime,
-  selectedActor,
-  handleComplete,
-  roleplayCreatedAtId,
-  disableViewReport,
-  handleSaveProgress,
-  handleDeleteProgress,
-  handleDeleteRoleplayProgress,
-  openSnackbar,
-  courseId,
-  sectionId,
-  topicId,
-  stopListening,
-  resetTranscript,
-  toggleMuteSound,
-  history,
-  handleReportProblem,
-  handleShareRoleplay,
-  handleEditRoleplay,
-  handleNextGame,
-  hasNextGame,
-  clearQueue,
-  stopAudio,
-  languageInformation,
-  translationEnabled,
-  parentClassroom,
-  isReadWriteModeStudent = false,
-  goBackToAssignment,
-  assignment,
-  classroomId
-}) {
-  useExerciseDocumentTitle({
-    exerciseTitle: "Fill in the blanks",
-    open
-  });
-  const scriptWithoutQuestions = roleplay.script.filter(scriptLine => !scriptLine?.question);
-  const [currentMessages, setCurrentMessages] = useState([]);
-  const {
-    recognitionState
-  } = useRecognition({
-    openSnackbar
-  });
-  const {
-    finalTranscript,
-    recognizing,
-    interimTranscript
-  } = recognitionState;
-  const languageTag = languageInformation.Code;
-  const exerciseState = useExerciseState({
-    t,
-    open,
-    handleClose,
-    exerciseName,
-    gameId: gameId || roleplayGame.gameId,
-    existingAnswerAttempts,
-    existingMessages: filterExistingMessages(existingMessages),
-    exerciseStartTime,
-    selectedActor,
-    handleComplete,
-    handleSaveProgress,
-    handleDeleteProgress,
-    handleDeleteRoleplayProgress,
-    openSnackbar,
-    courseId,
-    sectionId,
-    topicId,
-    roleplayCreatedAtId,
-    history,
-    handleSpeak,
-    handleStopSpeaking,
-    learnLang,
-    stopListening,
-    resetTranscript,
-    finalTranscript,
-    interimTranscript,
-    toggleMuteSound,
-    roleplay: {
-      ...roleplay,
-      script: scriptWithoutQuestions
-    },
-    clearQueue,
-    stopAudio,
-    languageInformation,
-    isReadWriteModeStudent,
-    classroomId
-  });
-  const {
-    muteSound,
-    answerAttempts,
-    isCloseModalOpen,
-    isInProgressModalOpen,
-    isCompletionModalOpen,
-    roleplayText,
-    roleplayMessages,
-    roleplayHasStarted,
-    isConfidenceOpen,
-    handleCloseConfidence,
-    handleOpenConfidence,
-    handleSkip,
-    disableSkip,
-    startRoleplay,
-    isMyTurn,
-    handleMakeAttempt,
-    handleCorrectQuestionAnswer,
-    handleIncorrectQuestionAnswer,
-    closeCloseModal,
-    handleInputChange,
-    closeInProgressModal,
-    handleMute,
-    handleRestart,
-    handlePlayAgain,
-    handleRestartExercise,
-    viewReport,
-    handleSaveRoleplayExerciseProgress,
-    handleCompleteExercise,
-    handleCloseExercise,
-    voiceSpeed,
-    isVoiceSpeedMenuOpen,
-    handleOpenVoiceSpeedMenu,
-    handleCloseVoiceSpeedMenu,
-    handleChangeVoiceSpeed,
-    isReportProblemOpen,
-    handleCloseReportProblem,
-    handleOpenReportProblem,
-    handleNext,
-    handleCloseClicked,
-    speak,
-    stopSpeaking,
-    isSpeaking,
-    isSpeakingTextContainer,
-    setIsAssignmentExercise
-  } = exerciseState;
-  const [messagesSet, setMessagesSet] = useState(false);
-  const handleContinueExercise = () => {
-    closeInProgressModal();
-    startRoleplay();
-  };
-  useEffect(() => {
-    if (messagesSet && currentMessages.length === 0 && !isCompletionModalOpen) {
-      startRoleplay();
-    }
-  }, [currentMessages.length, messagesSet]);
-  useEffect(() => {
-    assignment ? setIsAssignmentExercise(true) : setIsAssignmentExercise(false);
-  }, [assignment]);
-  const isRoleplayScriptLoaded = roleplay && roleplay.script;
-  useEffect(() => {
-    if (isRoleplayScriptLoaded) {
-      setCurrentMessages(roleplayMessages);
-      setMessagesSet(true);
-    }
-  }, [isRoleplayScriptLoaded, roleplayMessages]);
-  const setFillInBlankIndex = (index, newChat) => {
-    const blankChats = [...currentMessages];
-    const blankChatIndex = blankChats[index];
-    blankChatIndex.text = newChat.text;
-    blankChats[index] = blankChatIndex;
-    setCurrentMessages(blankChats);
-  };
-  const afterElements = /*#__PURE__*/_jsx("div", {
-    children: roleplayHasStarted && /*#__PURE__*/_jsxs(Box, {
-      sx: {
-        display: "flex",
-        justifyContent: "center"
-      },
-      children: [currentMessages && currentMessages.length && /*#__PURE__*/_jsx(FillInBlanks, {
-        t: t,
-        message: currentMessages[currentMessages.length - 1],
-        messageCounter: currentMessages.length,
-        setNewChat: newChat => setFillInBlankIndex(currentMessages.length - 1, newChat),
-        handleCorrectQuestionAnswer: handleCorrectQuestionAnswer,
-        handleIncorrectQuestionAnswer: handleIncorrectQuestionAnswer,
-        openSnackbar: openSnackbar,
-        handleNext: handleNext,
-        isSpeaking: isSpeaking,
-        script: roleplay.script,
-        languageInformation: languageInformation
-      }), (currentMessages && currentMessages.length > 0 &&
-      // if no blanks in chat
-      currentMessages[currentMessages.length - 1].text.split(" ")).length <= 2 && currentMessages.length < roleplay.script.length && /*#__PURE__*/_jsx(Button, {
-        "data-cy": "next-message",
-        color: "secondary",
-        variant: "contained",
-        onClick: handleNext,
-        id: "nextMessage",
-        fullWidth: true,
-        sx: {
-          m: 2,
-          maxWidth: 300
-        },
-        children: t("next")
-      })]
-    })
-  });
-  return /*#__PURE__*/_jsxs(Dialog, {
-    fullScreen: true,
-    open: open,
-    onClose: handleClose,
-    slots: {
-      transition: Transition
-    },
-    children: [/*#__PURE__*/_jsx(Chat, {
-      languageTag: languageTag,
-      t: t,
-      repliesEnabled: roleplay.repliesEnabled,
-      translationEnabled: translationEnabled,
-      messages: currentMessages,
-      answerAttempts: answerAttempts,
-      handleClose: handleCloseClicked,
-      handleInputChange: handleInputChange,
-      inputName: "roleplayText",
-      inputValue: roleplayText,
-      disableInput: !isMyTurn,
-      isListening: recognizing,
-      handleTranslate: handleTranslate,
-      speak: speak,
-      stopSpeaking: stopSpeaking,
-      isSpeaking: isSpeaking,
-      isSpeakingTextContainer: isSpeakingTextContainer,
-      handleSend: () => handleMakeAttempt(),
-      learnLang: learnLang,
-      forLang: forLang,
-      voiceSpeed: voiceSpeed,
-      isPrimaryColor: true,
-      topBarActions: /*#__PURE__*/_jsx(TopBarActions, {
-        t: t,
-        roleplayHasStarted: roleplayHasStarted,
-        currentMessages: currentMessages,
-        roleplay: roleplay,
-        voiceSpeed: voiceSpeed,
-        isVoiceSpeedMenuOpen: isVoiceSpeedMenuOpen,
-        handleOpenVoiceSpeedMenu: handleOpenVoiceSpeedMenu,
-        handleCloseVoiceSpeedMenu: handleCloseVoiceSpeedMenu,
-        handleChangeVoiceSpeed: handleChangeVoiceSpeed,
-        muteSound: isReadWriteModeStudent ? true : muteSound,
-        handleMute: handleMute,
-        isReportProblemOpen: isReportProblemOpen,
-        handleOpenReportProblem: handleOpenReportProblem,
-        handleCloseReportProblem: handleCloseReportProblem,
-        handleReportProblem: handleReportProblem,
-        handleSkip: handleSkip,
-        disableSkip: disableSkip,
-        handleEditRoleplay: handleEditRoleplay,
-        handleRestart: handleRestart,
-        handleShareRoleplay: handleShareRoleplay,
-        parentClassroom: parentClassroom,
-        exercise: gameId
-      }),
-      beforeElements: /*#__PURE__*/_jsx(BeforeElements, {
-        t: t,
-        roleplay: roleplay,
-        roleplayGame: roleplayGame,
-        gameId: gameId
-      }),
-      afterElements: afterElements,
-      disableScroll: !roleplayHasStarted,
-      finalTranscript: finalTranscript,
-      isConfidenceOpen: isConfidenceOpen,
-      handleCloseConfidence: handleCloseConfidence,
-      handleOpenConfidence: handleOpenConfidence,
-      handleCorrectQuestionAnswer: handleCorrectQuestionAnswer,
-      handleIncorrectQuestionAnswer: handleIncorrectQuestionAnswer,
-      handleKeyPress: e => {
-        if (e.key === "Enter") {
-          e.preventDefault();
-          handleMakeAttempt();
-        }
-      },
-      gameId: gameId,
-      formatUnderscores: false,
-      hideBottomBar: true,
-      muteSound: isReadWriteModeStudent ? true : muteSound
-    }), /*#__PURE__*/_jsx(InProgressExerciseMenu, {
-      t: t,
-      open: isInProgressModalOpen,
-      close: closeInProgressModal,
-      onClose: closeInProgressModal,
-      continueExercise: handleContinueExercise,
-      restartExercise: handleRestartExercise,
-      goBack: handleCloseExercise,
-      inTopic: courseId && sectionId && topicId,
-      goBackToAssignment: goBackToAssignment
-    }), /*#__PURE__*/_jsx(CompletedExcercise, {
-      open: isCompletionModalOpen,
-      restartExcercise: () => {
-        const messagesElement = document.getElementById("messages");
-        setTimeout(() => {
-          messagesElement.scrollTo({
-            top: 0,
-            behavior: "smooth"
-          });
-        }, 0);
-        handlePlayAgain();
-      },
-      onClose: () => isCompletionModalOpen(false),
-      goBack: handleCloseExercise,
-      viewReport: viewReport,
-      disableViewReport: disableViewReport,
-      fullScreen: true,
-      t: t,
-      inTopic: courseId && sectionId && topicId,
-      hasNextGame: hasNextGame,
-      handleNextGame: handleNextGame,
-      goBackToAssignment: goBackToAssignment
-    }), /*#__PURE__*/_jsx(CloseExerciseMenu, {
-      t: t,
-      open: isCloseModalOpen,
-      close: closeCloseModal,
-      saveProgress: () => handleSaveRoleplayExerciseProgress(roleplayMessages, answerAttempts, true),
-      finishExercise: handleCompleteExercise,
-      goBack: handleCloseExercise,
-      inTopic: courseId && sectionId && topicId,
-      isFinishExerciseDisabled: true,
-      goBackToAssignment: goBackToAssignment
-    })]
-  });
-}
-RoleplayGame.gameId = "fill-in-the-blanks";
-RoleplayGame.gameName = "fill_in_blanks";
-RoleplayGame.gameDescription = "fill_in_blanks_description";
-RoleplayGame.gameIcon = /*#__PURE__*/_jsx(SpaceBarIcon, {});
-export default RoleplayGame;

package/dist/Exercises/Roleplay/Games/FillInTheBlanksGame/package.json

@@ -1,6 +0,0 @@
-{
-  "name": "FillInTheBlanksGame",
-  "version": "0.0.0",
-  "private": true,
-  "main": "./FillInTheBlanksGame.js"
-}