feat: Default questions

src/constants/questions.dummy.ts

@@ -0,0 +1,290 @@
+import type { AnyTypedQuizQuestion } from "../model/questionTypes/shared";
+
+export const QUESTIONS_DUMMY: AnyTypedQuizQuestion[] = [
+  {
+    id: "1",
+    title: "",
+    type: "variant",
+    expanded: true,
+    required: false,
+    deleted: false,
+    deleteTimeoutId: 0,
+    backendId: 1111,
+    description: "",
+    openedModalSettings: false,
+    page: 1,
+    quizId: 1,
+    content: {
+      hint: {
+        text: "",
+        video: "",
+      },
+      rule: {
+        main: [],
+        default: "1",
+      },
+      back: "",
+      originalBack: "",
+      autofill: false,
+      largeCheck: false,
+      multi: false,
+      own: false,
+      innerNameCheck: false,
+      required: false,
+      innerName: "",
+      variants: [],
+    },
+  },
+  {
+    id: "2",
+    title: "Вы идёте в школу",
+    type: "page",
+    expanded: true,
+    required: false,
+    deleted: false,
+    deleteTimeoutId: 0,
+    backendId: 1112,
+    description: "",
+    openedModalSettings: false,
+    page: 1,
+    quizId: 1,
+    content: {
+      hint: {
+        text: "",
+        video: "",
+      },
+      rule: {
+        main: [],
+        default: "1",
+      },
+      back: "",
+      originalBack: "",
+      autofill: false,
+
+      innerNameCheck: false,
+      innerName: "",
+      text: "",
+      picture: "",
+      originalPicture: "",
+      video: "",
+    },
+  },
+  {
+    id: "3",
+    title: "Вы немного опоздали, как поступите?",
+    type: "variant",
+    expanded: true,
+    required: true,
+    deleted: false,
+    deleteTimeoutId: 0,
+    backendId: 1113,
+    description: "",
+    openedModalSettings: false,
+    page: 1,
+    quizId: 1,
+    content: {
+      hint: {
+        text: "",
+        video: "",
+      },
+      rule: {
+        main: [],
+        default: "2",
+      },
+      back: "",
+      originalBack: "",
+      autofill: false,
+      largeCheck: false,
+      multi: false,
+      own: false,
+      innerNameCheck: false,
+      required: false,
+      innerName: "",
+      variants: [
+        {
+          id: "answer1",
+          answer: "Извинюсь за опоздание и займу своё место",
+          extendedText: "",
+          hints: "",
+        },
+        {
+          id: "answer2",
+          answer:
+            "Вынесу дверь с ноги и распинав всех направлюсь к месту у розетки",
+          extendedText: "",
+          hints: "",
+        },
+        {
+          id: "answer3",
+          answer: "Влечу в кабинет, пробегу его и выпрыгну в окно",
+          extendedText: "",
+          hints: "",
+        },
+      ],
+    },
+  },
+  {
+    id: "4",
+    title: "Вы открываете дверь кабинета, приготовившись исполнить задуманное",
+    type: "page",
+    expanded: true,
+    required: false,
+    deleted: false,
+    deleteTimeoutId: 0,
+    backendId: 1114,
+    description: "",
+    openedModalSettings: false,
+    page: 1,
+    quizId: 1,
+    content: {
+      hint: {
+        text: "",
+        video: "",
+      },
+      rule: {
+        main: [
+          //момент выбора куда мы пойдём
+          {
+            next: "7",
+            or: true,
+            rules: [
+              {
+                question: "2",
+                answers: ["answer1"],
+              },
+            ],
+          },
+          {
+            next: "6",
+            or: true,
+            rules: [
+              {
+                question: "2",
+                answers: ["answer2"],
+              },
+            ],
+          },
+          {
+            next: "5",
+            or: true,
+            rules: [
+              {
+                question: "2",
+                answers: ["answer3"],
+              },
+            ],
+          },
+        ],
+        default: "2",
+      },
+      back: "",
+      originalBack: "",
+      autofill: false,
+      innerNameCheck: false,
+      innerName: "",
+      text: "",
+      picture: "",
+      originalPicture: "",
+      video: "",
+    },
+  },
+  {
+    id: "5",
+    title: "Вы умерли",
+    type: "page",
+    expanded: true,
+    required: false,
+    deleted: false,
+    deleteTimeoutId: 0,
+    backendId: 1115,
+    description: "",
+    openedModalSettings: false,
+    page: 1,
+    quizId: 1,
+    content: {
+      hint: {
+        text: "",
+        video: "",
+      },
+      rule: {
+        main: [],
+        default: "",
+      },
+      back: "",
+      originalBack: "",
+      autofill: false,
+      innerNameCheck: false,
+      innerName: "",
+      text: "",
+      picture: "",
+      originalPicture: "",
+      video: "",
+    },
+  },
+  {
+    id: "6",
+    title: "Вас вызвали к директору",
+    type: "page",
+    expanded: true,
+    required: false,
+    deleted: false,
+    deleteTimeoutId: 0,
+    backendId: 1116,
+    description: "",
+    openedModalSettings: false,
+    page: 1,
+    quizId: 1,
+    content: {
+      hint: {
+        text: "",
+        video: "",
+      },
+      rule: {
+        main: [],
+        default: "",
+      },
+      back: "",
+      originalBack: "",
+      autofill: false,
+      innerNameCheck: false,
+      innerName: "",
+      text: "",
+      picture: "",
+      originalPicture: "",
+      video: "",
+    },
+  },
+  {
+    id: "7",
+    title: "Вы получили отлично",
+    type: "page",
+    expanded: true,
+    required: false,
+    deleted: false,
+    deleteTimeoutId: 0,
+    backendId: 1117,
+    description: "",
+    openedModalSettings: false,
+    page: 1,
+    quizId: 1,
+    content: {
+      hint: {
+        text: "",
+        video: "",
+      },
+      rule: {
+        main: [],
+        default: "",
+      },
+      back: "",
+      originalBack: "",
+      autofill: false,
+      innerNameCheck: false,
+      innerName: "",
+      text: "",
+      picture: "",
+      originalPicture: "",
+      video: "",
+    },
+  },
+];

src/model/questionTypes/shared.ts

@@ -48,7 +48,7 @@ export type QuestionVariant = {
   /** Дополнительное поле для текста, emoji, ссылки на картинку */
   extendedText: string;
   /** Оригинал изображения (до кропа) */
-  originalImageUrl: string;
+  originalImageUrl?: string;
 };
 
 export interface QuizQuestionBase {

src/pages/Questions/OptionsAndPicture/OptionsAndPicture.tsx

@@ -77,7 +77,7 @@ export default function OptionsAndPicture({ question }: Props) {
                                         setSelectedVariantId(variant.id);
                                         if (variant.extendedText) return openCropModal(
                                             variant.extendedText,
-                                            variant.originalImageUrl
+                                            variant.originalImageUrl || ""
                                         );
 
                                         openImageUploadModal();
@@ -102,7 +102,7 @@ export default function OptionsAndPicture({ question }: Props) {
                                         setSelectedVariantId(variant.id);
                                         if (variant.extendedText) return openCropModal(
                                             variant.extendedText,
-                                            variant.originalImageUrl
+                                            variant.originalImageUrl || ""
                                         );
 
                                         openImageUploadModal();

src/pages/Questions/OptionsPicture/OptionsPicture.tsx

@@ -68,7 +68,7 @@ export default function OptionsPicture({ question }: Props) {
                                         if (variant.extendedText) {
                                             return openCropModal(
                                                 variant.extendedText,
-                                                variant.originalImageUrl
+                                                variant.originalImageUrl || ""
                                             );
                                         }
 
@@ -95,7 +95,7 @@ export default function OptionsPicture({ question }: Props) {
                                         if (variant.extendedText) {
                                             return openCropModal(
                                                 variant.extendedText,
-                                                variant.originalImageUrl
+                                                variant.originalImageUrl || ""
                                             );
                                         }
 

src/pages/Questions/QuestionsPage.tsx

@@ -1,3 +1,4 @@
+import { useEffect } from "react";
 import {
   Box,
   Button,
@@ -6,21 +7,41 @@ import {
   useMediaQuery,
   useTheme,
 } from "@mui/material";
-import { collapseAllQuestions, createUntypedQuestion } from "@root/questions/actions";
+import {
-import { decrementCurrentStep, incrementCurrentStep } from "@root/quizes/actions";
+  collapseAllQuestions,
+  createUntypedQuestion,
+} from "@root/questions/actions";
+import {
+  decrementCurrentStep,
+  incrementCurrentStep,
+} from "@root/quizes/actions";
 import { useCurrentQuiz } from "@root/quizes/hooks";
 import QuizPreview from "@ui_kit/QuizPreview/QuizPreview";
 import { createPortal } from "react-dom";
 import AddPlus from "../../assets/icons/questionsPage/addPlus";
 import ArrowLeft from "../../assets/icons/questionsPage/arrowLeft";
 import { DraggableList } from "./DraggableList";
-
+import { setDefaultState } from "@root/questions/actions";
 
 export default function QuestionsPage() {
   const theme = useTheme();
   const isMobile = useMediaQuery(theme.breakpoints.down(660));
   const quiz = useCurrentQuiz();
 
+  useEffect(() => {
+    const setDefault = ({ code }: KeyboardEvent) => {
+      if (code === "Backslash") {
+        setDefaultState(Number(quiz?.id));
+      }
+    };
+
+    document.addEventListener("keydown", setDefault);
+
+    return () => {
+      document.removeEventListener("keydown", setDefault);
+    };
+  }, []);
+
   if (!quiz) return null;
 
   return (

src/pages/ViewPublicationPage/questions/Date.tsx

@@ -1,4 +1,3 @@
-import { useState } from "react";
 import DatePicker from "react-datepicker";
 import { Box, Typography } from "@mui/material";
 
@@ -14,7 +13,6 @@ type DateProps = {
 };
 
 export const Date = ({ stepNumber, question }: DateProps) => {
-  const [startDate, setStartDate] = useState<Date | null>(new window.Date());
   const { answers } = useQuizViewStore();
   const { answer } = answers.find(({ step }) => step === stepNumber) ?? {};
 
@@ -30,8 +28,8 @@ export const Date = ({ stepNumber, question }: DateProps) => {
         }}
       >
         <DatePicker
-          selected={startDate}
+          selected={answer ? new window.Date(answer) : new window.Date()}
-          onChange={(date) => setStartDate(date)}
+          onChange={(date) => updateAnswer(stepNumber, String(date))}
         />
       </Box>
     </Box>

src/stores/questions.ts

@@ -79,7 +79,7 @@ export const questionStore = create<QuestionStore>()(
                                 if (variant.extendedText.startsWith("blob:")) {
                                     variant.extendedText = "";
                                 }
-                                if (variant.originalImageUrl.startsWith("blob:")) {
+                                if (variant.originalImageUrl?.startsWith("blob:")) {
                                     variant.originalImageUrl = "";
                                 }
                             });
@@ -89,7 +89,7 @@ export const questionStore = create<QuestionStore>()(
                                 if (variant.extendedText.startsWith("blob:")) {
                                     variant.extendedText = "";
                                 }
-                                if (variant.originalImageUrl.startsWith("blob:")) {
+                                if (variant.originalImageUrl?.startsWith("blob:")) {
                                     variant.originalImageUrl = "";
                                 }
                             });
@@ -181,7 +181,9 @@ export const setVariantOriginalImageUrl = (
 
     if (variant.originalImageUrl === url) return;
 
+    if (variant.originalImageUrl) {
         URL.revokeObjectURL(variant.originalImageUrl);
+    }
     variant.originalImageUrl = url;
 }, {
     type: "setVariantOriginalImageUrl",

src/stores/questions/actions.ts

@@ -1,8 +1,17 @@
 import { questionApi } from "@api/question";
 import { devlog } from "@frontend/kitui";
 import { questionToEditQuestionRequest } from "@model/question/edit";
-import { QuestionType, RawQuestion, rawQuestionToQuestion } from "@model/question/question";
+import {
-import { AnyTypedQuizQuestion, QuestionVariant, UntypedQuizQuestion, createQuestionVariant } from "@model/questionTypes/shared";
+  QuestionType,
+  RawQuestion,
+  rawQuestionToQuestion,
+} from "@model/question/question";
+import {
+  AnyTypedQuizQuestion,
+  QuestionVariant,
+  UntypedQuizQuestion,
+  createQuestionVariant,
+} from "@model/questionTypes/shared";
 import { defaultQuestionByType } from "../../constants/default";
 import { produce } from "immer";
 import { nanoid } from "nanoid";
@@ -10,19 +19,38 @@ import { enqueueSnackbar } from "notistack";
 import { isAxiosCanceledError } from "../../utils/isAxiosCanceledError";
 import { RequestQueue } from "../../utils/requestQueue";
 import { QuestionsStore, useQuestionsStore } from "./store";
+import { QUESTIONS_DUMMY } from "../../constants/questions.dummy";
 
+export const setDefaultState = (quizId: number) =>
+  setProducedState(
+    (state) => {
+      QUESTIONS_DUMMY.forEach((question) => {
+        state.questions.push(question);
+      });
+    },
+    {
+      type: "setDefaultState",
+      quizId,
+    }
+  );
 
-export const setQuestions = (questions: RawQuestion[] | null) => setProducedState(state => {
+export const setQuestions = (questions: RawQuestion[] | null) =>
-    const untypedQuestions = state.questions.filter(q => q.type === null);
+  setProducedState(
+    (state) => {
+      const untypedQuestions = state.questions.filter((q) => q.type === null);
 
       state.questions = questions?.map(rawQuestionToQuestion) ?? [];
       state.questions.push(...untypedQuestions);
-}, {
+    },
+    {
       type: "setQuestions",
       questions,
-});
+    }
+  );
 
-export const createUntypedQuestion = (quizId: number) => setProducedState(state => {
+export const createUntypedQuestion = (quizId: number) =>
+  setProducedState(
+    (state) => {
       state.questions.push({
         id: nanoid(),
         quizId,
@@ -32,86 +60,114 @@ export const createUntypedQuestion = (quizId: number) => setProducedState(state
         deleted: false,
         expanded: true,
       });
-}, {
+    },
+    {
       type: "createUntypedQuestion",
       quizId,
-});
+    }
+  );
 
-const removeQuestion = (questionId: string) => setProducedState(state => {
+const removeQuestion = (questionId: string) =>
-    const index = state.questions.findIndex(q => q.id === questionId);
+  setProducedState(
+    (state) => {
+      const index = state.questions.findIndex((q) => q.id === questionId);
       if (index === -1) return;
 
       state.questions.splice(index, 1);
-}, {
+    },
+    {
       type: "removeQuestion",
       questionId,
-});
+    }
+  );
 
 export const updateUntypedQuestion = (
   questionId: string,
-    updateFn: (question: UntypedQuizQuestion) => void,
+  updateFn: (question: UntypedQuizQuestion) => void
 ) => {
-    setProducedState(state => {
+  setProducedState(
-        const question = state.questions.find(q => q.id === questionId);
+    (state) => {
+      const question = state.questions.find((q) => q.id === questionId);
       if (!question) return;
-        if (question.type !== null) throw new Error("Cannot update typed question, use 'updateQuestion' instead");
+      if (question.type !== null)
+        throw new Error(
+          "Cannot update typed question, use 'updateQuestion' instead"
+        );
 
       updateFn(question);
-    }, {
+    },
+    {
       type: "updateUntypedQuestion",
       questionId,
       updateFn: updateFn.toString(),
-    });
+    }
+  );
 };
 
-export const cleanQuestions = () => setProducedState(state => {
+export const cleanQuestions = () =>
+  setProducedState(
+    (state) => {
       state.questions = [];
-}, {
+    },
+    {
       type: "cleanQuestions",
-});
+    }
+  );
 
-const setQuestionBackendId = (questionId: string, backendId: number) => setProducedState(state => {
+const setQuestionBackendId = (questionId: string, backendId: number) =>
-    const question = state.questions.find(q => q.id === questionId);
+  setProducedState(
+    (state) => {
+      const question = state.questions.find((q) => q.id === questionId);
       if (!question) return;
-    if (question.type === null) throw new Error("Cannot set backend id for untyped question");
+      if (question.type === null)
+        throw new Error("Cannot set backend id for untyped question");
 
       question.backendId = backendId;
-}, {
+    },
+    {
       type: "setQuestionBackendId",
       questionId: questionId,
       backendId,
-});
+    }
+  );
 
 export const reorderQuestions = (
   sourceIndex: number,
-    destinationIndex: number,
+  destinationIndex: number
 ) => {
   if (sourceIndex === destinationIndex) return;
 
-    setProducedState(state => {
+  setProducedState(
+    (state) => {
       const [removed] = state.questions.splice(sourceIndex, 1);
       state.questions.splice(destinationIndex, 0, removed);
-    }, {
+    },
+    {
       type: "reorderQuestions",
       sourceIndex,
       destinationIndex,
-    });
+    }
+  );
 };
 
-export const toggleExpandQuestion = (questionId: string) => setProducedState(state => {
+export const toggleExpandQuestion = (questionId: string) =>
-    const question = state.questions.find(q => q.id === questionId);
+  setProducedState(
+    (state) => {
+      const question = state.questions.find((q) => q.id === questionId);
       if (!question) return;
 
       question.expanded = !question.expanded;
-}, {
+    },
+    {
       type: "toggleExpandQuestion",
       questionId,
-});
+    }
-
+  );
-export const collapseAllQuestions = () => setProducedState(state => {
-    state.questions.forEach(question => question.expanded = false);
-}, "collapseAllQuestions");
 
+export const collapseAllQuestions = () =>
+  setProducedState((state) => {
+    state.questions.forEach((question) => (question.expanded = false));
+  }, "collapseAllQuestions");
 
 const REQUEST_DEBOUNCE = 200;
 const requestQueue = new RequestQueue();
@@ -119,31 +175,44 @@ let requestTimeoutId: ReturnType<typeof setTimeout>;
 
 export const updateQuestion = (
   questionId: string,
-    updateFn: (question: AnyTypedQuizQuestion) => void,
+  updateFn: (question: AnyTypedQuizQuestion) => void
 ) => {
-    setProducedState(state => {
+  setProducedState(
-        const question = state.questions.find(q => q.id === questionId);
+    (state) => {
+      const question = state.questions.find((q) => q.id === questionId);
       if (!question) return;
-        if (question.type === null) throw new Error("Cannot update untyped question, use 'updateUntypedQuestion' instead");
+      if (question.type === null)
+        throw new Error(
+          "Cannot update untyped question, use 'updateUntypedQuestion' instead"
+        );
 
       updateFn(question);
-    }, {
+    },
+    {
       type: "updateQuestion",
       questionId,
       updateFn: updateFn.toString(),
-    });
+    }
+  );
 
   clearTimeout(requestTimeoutId);
   requestTimeoutId = setTimeout(() => {
-        requestQueue.enqueue(async () => {
+    requestQueue
-            const q = useQuestionsStore.getState().questions.find(q => q.id === questionId);
+      .enqueue(async () => {
+        const q = useQuestionsStore
+          .getState()
+          .questions.find((q) => q.id === questionId);
         if (!q) return;
-            if (q.type === null) throw new Error("Cannot send update request for untyped question");
+        if (q.type === null)
+          throw new Error("Cannot send update request for untyped question");
 
-            const response = await questionApi.edit(questionToEditQuestionRequest(q));
+        const response = await questionApi.edit(
+          questionToEditQuestionRequest(q)
+        );
 
         setQuestionBackendId(questionId, response.updated);
-        }).catch(error => {
+      })
+      .catch((error) => {
         if (isAxiosCanceledError(error)) return;
 
         devlog("Error editing question", { error, questionId });
@@ -153,7 +222,7 @@ export const updateQuestion = (
 };
 
 export const addQuestionVariant = (questionId: string) => {
-    updateQuestion(questionId, question => {
+  updateQuestion(questionId, (question) => {
     switch (question.type) {
       case "variant":
       case "emoji":
@@ -162,16 +231,24 @@ export const addQuestionVariant = (questionId: string) => {
       case "varimg":
         question.content.variants.push(createQuestionVariant());
         break;
-            default: throw new Error(`Cannot add variant to question of type "${question.type}"`);
+      default:
+        throw new Error(
+          `Cannot add variant to question of type "${question.type}"`
+        );
     }
   });
 };
 
-export const deleteQuestionVariant = (questionId: string, variantId: string) => {
+export const deleteQuestionVariant = (
-    updateQuestion(questionId, question => {
+  questionId: string,
+  variantId: string
+) => {
+  updateQuestion(questionId, (question) => {
     if (!("variants" in question.content)) return;
 
-        const variantIndex = question.content.variants.findIndex(variant => variant.id === variantId);
+    const variantIndex = question.content.variants.findIndex(
+      (variant) => variant.id === variantId
+    );
     if (variantIndex === -1) return;
 
     question.content.variants.splice(variantIndex, 1);
@@ -182,54 +259,54 @@ export const setQuestionVariantField = (
   questionId: string,
   variantId: string,
   field: keyof QuestionVariant,
-    value: QuestionVariant[keyof QuestionVariant],
+  value: QuestionVariant[keyof QuestionVariant]
 ) => {
-    updateQuestion(questionId, question => {
+  updateQuestion(questionId, (question) => {
     if (!("variants" in question.content)) return;
 
-        const variantIndex = question.content.variants.findIndex(variant => variant.id === variantId);
+    const variantIndex = question.content.variants.findIndex(
+      (variant) => variant.id === variantId
+    );
     if (variantIndex === -1) return;
 
     const variant = question.content.variants[variantIndex];
+    
+    if (value) {
       variant[field] = value;
+    }
   });
 };
 
 export const reorderQuestionVariants = (
   questionId: string,
   sourceIndex: number,
-    destinationIndex: number,
+  destinationIndex: number
 ) => {
   if (sourceIndex === destinationIndex) return;
 
-    updateQuestion(questionId, question => {
+  updateQuestion(questionId, (question) => {
     if (!("variants" in question.content)) return;
 
     const [removed] = question.content.variants.splice(sourceIndex, 1);
     question.content.variants.splice(destinationIndex, 0, removed);
-
   });
 };
 
-export const setQuestionBackgroundImage = (
+export const setQuestionBackgroundImage = (questionId: string, url: string) => {
-    questionId: string,
+  updateQuestion(questionId, (question) => {
-    url: string,
-) => {
-    updateQuestion(questionId, question => {
     if (question.content.back === url) return;
 
-        if (
+    if (question.content.back !== question.content.originalBack)
-            question.content.back !== question.content.originalBack
+      URL.revokeObjectURL(question.content.back);
-        ) URL.revokeObjectURL(question.content.back);
     question.content.back = url;
   });
 };
 
 export const setQuestionOriginalBackgroundImage = (
   questionId: string,
-    url: string,
+  url: string
 ) => {
-    updateQuestion(questionId, question => {
+  updateQuestion(questionId, (question) => {
     if (question.content.originalBack === url) return;
 
     URL.revokeObjectURL(question.content.originalBack);
@@ -240,17 +317,20 @@ export const setQuestionOriginalBackgroundImage = (
 export const setVariantImageUrl = (
   questionId: string,
   variantId: string,
-    url: string,
+  url: string
 ) => {
-    updateQuestion(questionId, question => {
+  updateQuestion(questionId, (question) => {
     if (!("variants" in question.content)) return;
 
-        const variant = question.content.variants.find(variant => variant.id === variantId);
+    const variant = question.content.variants.find(
+      (variant) => variant.id === variantId
+    );
     if (!variant) return;
 
     if (variant.extendedText === url) return;
 
-        if (variant.extendedText !== variant.originalImageUrl) URL.revokeObjectURL(variant.extendedText);
+    if (variant.extendedText !== variant.originalImageUrl)
+      URL.revokeObjectURL(variant.extendedText);
     variant.extendedText = url;
   });
 };
@@ -258,44 +338,42 @@ export const setVariantImageUrl = (
 export const setVariantOriginalImageUrl = (
   questionId: string,
   variantId: string,
-    url: string,
+  url: string
 ) => {
-    updateQuestion(questionId, question => {
+  updateQuestion(questionId, (question) => {
     if (!("variants" in question.content)) return;
 
     const variant = question.content.variants.find(
-            variant => variant.id === variantId
+      (variant) => variant.id === variantId
     ) as QuestionVariant | undefined;
     if (!variant) return;
 
     if (variant.originalImageUrl === url) return;
 
+    if (variant.originalImageUrl) {
       URL.revokeObjectURL(variant.originalImageUrl);
+    }
     variant.originalImageUrl = url;
   });
 };
 
-export const setPageQuestionPicture = (
+export const setPageQuestionPicture = (questionId: string, url: string) => {
-    questionId: string,
+  updateQuestion(questionId, (question) => {
-    url: string,
-) => {
-    updateQuestion(questionId, question => {
     if (question.type !== "page") return;
 
     if (question.content.picture === url) return;
 
-        if (
+    if (question.content.picture !== question.content.originalPicture)
-            question.content.picture !== question.content.originalPicture
+      URL.revokeObjectURL(question.content.picture);
-        ) URL.revokeObjectURL(question.content.picture);
     question.content.picture = url;
   });
 };
 
 export const setPageQuestionOriginalPicture = (
   questionId: string,
-    url: string,
+  url: string
 ) => {
-    updateQuestion(questionId, question => {
+  updateQuestion(questionId, (question) => {
     if (question.type !== "page") return;
 
     if (question.content.originalPicture === url) return;
@@ -305,20 +383,14 @@ export const setPageQuestionOriginalPicture = (
   });
 };
 
-export const setQuestionInnerName = (
+export const setQuestionInnerName = (questionId: string, name: string) => {
-    questionId: string,
+  updateQuestion(questionId, (question) => {
-    name: string,
-) => {
-    updateQuestion(questionId, question => {
     question.content.innerName = name;
   });
 };
 
-export const changeQuestionType = (
+export const changeQuestionType = (questionId: string, type: QuestionType) => {
-    questionId: string,
+  updateQuestion(questionId, (question) => {
-    type: QuestionType,
-) => {
-    updateQuestion(questionId, question => {
     question.type = type;
     question.content = defaultQuestionByType[type].content;
   });
@@ -326,11 +398,15 @@ export const changeQuestionType = (
 
 export const createTypedQuestion = async (
   questionId: string,
-    type: QuestionType,
+  type: QuestionType
-) => requestQueue.enqueue(async () => {
+) =>
-    const question = useQuestionsStore.getState().questions.find(q => q.id === questionId);
+  requestQueue.enqueue(async () => {
+    const question = useQuestionsStore
+      .getState()
+      .questions.find((q) => q.id === questionId);
     if (!question) return;
-    if (question.type !== null) throw new Error("Cannot upgrade already typed question");
+    if (question.type !== null)
+      throw new Error("Cannot upgrade already typed question");
 
     try {
       const createdQuestion = await questionApi.create({
@@ -343,25 +419,34 @@ export const createTypedQuestion = async (
         content: JSON.stringify(defaultQuestionByType[type].content),
       });
 
-        setProducedState(state => {
+      setProducedState(
-            const questionIndex = state.questions.findIndex(q => q.id === questionId);
+        (state) => {
-            if (questionIndex !== -1) state.questions.splice(
+          const questionIndex = state.questions.findIndex(
+            (q) => q.id === questionId
+          );
+          if (questionIndex !== -1)
+            state.questions.splice(
               questionIndex,
               1,
               rawQuestionToQuestion(createdQuestion)
             );
-        }, {
+        },
+        {
           type: "createTypedQuestion",
           question,
-        });
+        }
+      );
     } catch (error) {
       devlog("Error creating question", error);
       enqueueSnackbar("Не удалось создать вопрос");
     }
-});
+  });
 
-export const deleteQuestion = async (questionId: string) => requestQueue.enqueue(async () => {
+export const deleteQuestion = async (questionId: string) =>
-    const question = useQuestionsStore.getState().questions.find(q => q.id === questionId);
+  requestQueue.enqueue(async () => {
+    const question = useQuestionsStore
+      .getState()
+      .questions.find((q) => q.id === questionId);
     if (!question) return;
 
     if (question.type === null) {
@@ -377,50 +462,62 @@ export const deleteQuestion = async (questionId: string) => requestQueue.enqueue
       devlog("Error deleting question", error);
       enqueueSnackbar("Не удалось удалить вопрос");
     }
-});
+  });
 
-export const copyQuestion = async (questionId: string, quizId: number) => requestQueue.enqueue(async () => {
+export const copyQuestion = async (questionId: string, quizId: number) =>
-    const question = useQuestionsStore.getState().questions.find(q => q.id === questionId);
+  requestQueue.enqueue(async () => {
+    const question = useQuestionsStore
+      .getState()
+      .questions.find((q) => q.id === questionId);
     if (!question) return;
 
     if (question.type === null) {
       const copiedQuestion = structuredClone(question);
       copiedQuestion.id = nanoid();
 
-        setProducedState(state => {
+      setProducedState(
+        (state) => {
           state.questions.push(copiedQuestion);
-        }, {
+        },
+        {
           type: "copyQuestion",
           questionId,
           quizId,
-        });
+        }
+      );
 
       return;
     }
 
     try {
-        const { updated: newQuestionId } = await questionApi.copy(question.backendId, quizId);
+      const { updated: newQuestionId } = await questionApi.copy(
+        question.backendId,
+        quizId
+      );
 
       const copiedQuestion = structuredClone(question);
       copiedQuestion.backendId = newQuestionId;
       copiedQuestion.id = nanoid();
 
-        setProducedState(state => {
+      setProducedState(
+        (state) => {
           state.questions.push(copiedQuestion);
-        }, {
+        },
+        {
           type: "copyQuestion",
           questionId,
           quizId,
-        });
+        }
+      );
     } catch (error) {
       devlog("Error copying question", error);
       enqueueSnackbar("Не удалось скопировать вопрос");
     }
-});
+  });
 
-function setProducedState<A extends string | { type: unknown; }>(
+function setProducedState<A extends string | { type: unknown }>(
   recipe: (state: QuestionsStore) => void,
-    action?: A,
+  action?: A
 ) {
-    useQuestionsStore.setState(state => produce(state, recipe), false, action);
+  useQuestionsStore.setState((state) => produce(state, recipe), false, action);
 }