i have xstate in my next.js component, is it possible to get rid of it, and make same functionality by vanilla ts? in other words, could i make it simplier without dependency? here's the code

import { useMachine } from '@xstate/react';                                                                                                               │                                                                               
                                                                               │  1 import dynamic from 'next/dynamic';                                                                                                                       │                                                                               
                                                                               │  2 import React, { useEffect } from 'react';                                                                                                                 │                                                                               
                                                                               │  3 import { assign, createMachine } from 'xstate';                                                                                                           │                                                                               
                                                                               │  4                                                                                                                                                           │                                                                               
                                                                               │  5 import { TestContentBlock } from '@/helpers/types';                                                                                                       │                                                                               
                                                                               │  6                                                                                                                                                           │                                                                               
                                                                               │  7 import TestStart from './TestStart';                                                                                                                      │                                                                               
                                                                               │  8                                                                                                                                                           │                                                                               
                                                                               │  9 const TestQuestion = dynamic(() => import('./TestQuestion'));                                                                                             │                                                                               
                                                                               │ 10 const TestResult = dynamic(() => import('./TestResult'));                                                                                                 │                                                                               
                                                                               │ 11                                                                                                                                                           │                                                                               
                                                                               │ 12 type TestEvent =                                                                                                                                          │                                                                               
                                                                               │ 13 │ | { type: 'SET_QUESTIONS_COUNT'; count: number }                                                                                                        │                                                                               
                                                                               │ 14 │ | { type: 'START_TEST' }                                                                                                                                │                                                                               
                                                                               │ 15 │ | { type: 'NEXT_QUESTION' }                                                                                                                             │                                                                               
                                                                               │ 16 │ | { type: 'INCREMENT_QUESTION_INDEX' }                                                                                                                  │                                                                               
                                                                               │ 17 │ | { type: 'INCREMENT_CORRECT_COUNT' }                                                                                                                   │                                                                               
                                                                               │ 18 │ | { type: 'RESTART' };                                                                                                                                  │                                                                               
                                                                               │ 19                                                                                                                                                           │                                                                               
                                                                               │ 20 interface TestContext {                                                                                                                                   │                                                                               
                                                                               │ 21 │ questionIndex: number;                                                                                                                                  │                                                                               
                                                                               │ 22 │ questionsCount: number;                                                                                                                                 │                                                                               
                                                                               │ 23 │ correctCount: number;                                                                                                                                   │                                                                               
                                                                               │ 24 }                                                                                                                                                         │                                                                               
                                                                               │ 25                                                                                                                                                           │                                                                               
                                                                               │ 26 const testMachine = createMachine<TestContext, TestEvent>({                                                                                               │                                                                               
                                                                               │ 27 │ predictableActionArguments: true,                                                                                                                       │                                                                               
                                                                               │ 28 │ initial: 'start',                                                                                                                                       │                                                                               
                                                                               │ 29 │ context: {                                                                                                                                              │                                                                               
                                                                               │ 30 │ │ questionIndex: 0,                                                                                                                                     │                                                                               
                                                                               │ 31 │ │ questionsCount: 0,                                                                                                                                    │                                                                               
                                                                               │ 32 │ │ correctCount: 0,                                                                                                                                      │                                                                               
                                                                               │ 33 │ },                                                                                                                                                      │                                                                               
                                                                               │ 34 │ states: {                                                                                                                                               │                                                                               
                                                                               │ 35 │ │ start: {                                                                                                                                              │                                                                               
                                                                               │ 36 │ │ │ on: {                                                                                                                                               │                                                                               
                                                                               │ 37 │ │ │ │ SET_QUESTIONS_COUNT: {                                                                                                                            │                                                                               
                                                                               │ 38 │ │ │ │ │ actions: assign({                                                                                                                               │                                                                               
                                                                               │ 39 │ │ │ │ │ │ questionsCount: (_, e) => e.count,                                                                                                            │                                                                               
                                                                               │ 40 │ │ │ │ │ }),                                                                                                                                             │                                                                               
                                                                               │ 41 │ │ │ │ },                                                                                                                                                │                                                                               
                                                                               │ 42 │ │ │ │ START_TEST: {                                                                                                                                     │                                                                               
                                                                               │ 43 │ │ │ │ │ cond: (ctx) => !!ctx.questionsCount,                                                                                                            │                                                                               
                                                                               │ 44 │ │ │ │ │ target: 'question',                                                                                                                             │                                                                               
                                                                               │ 45 │ │ │ │ },                                                                                                                                                │                                                                               
                                                                               │ 46 │ │ │ },                                                                                                                                                  │                                                                               
                                                                               │ 47 │ │ },                                                                                                                                                    │                                                                               
                                                                               │ 48 │ │ question: {                                                                                                                                           │                                                                               
                                                                               │ 49 │ │ │ on: {                                                                                                                                               │                                                                               
                                                                               │ 50 │ │ │ │ INCREMENT_QUESTION_INDEX: {                                                                                                                       │                                                                               
                                                                               │ 51 │ │ │ │ │ actions: assign({ questionIndex: (ctx) => ctx.questionIndex + 1 }),                                                                             │                                                                               
                                                                               │ 52 │ │ │ │ },                                                                                                                                                │                                                                               
                                                                               │ 53 │ │ │ │ INCREMENT_CORRECT_COUNT: {                                                                                                                        │                                                                               
                                                                               │ 54 │ │ │ │ │ actions: assign({ correctCount: (ctx) => ctx.correctCount + 1 }),                                                                               │                                                                               
                                                                               │ 55 │ │ │ │ },                                                                                                                                                │                                                                               
                                                                               │ 56 │ │ │ │ NEXT_QUESTION: {                                                                                                                                  │                                                                               
                                                                               │ 57 │ │ │ │ │ cond: (ctx) => ctx.questionIndex >= ctx.questionsCount,                                                                                         │                                                                               
                                                                               │ 58 │ │ │ │ │ target: 'result',                                                                                                                               │                                                                               
                                                                               │ 59 │ │ │ │ },                                                                                                                                                │                                                                               
                                                                               │ 60 │ │ │ │ RESTART: {                                                                                                                                        │                                                                               
                                                                               │ 61 │ │ │ │ │ target: 'start',                                                                                                                                │                                                                               
                                                                               │ 62 │ │ │ │ │ actions: assign({                                                                                                                               │                                                                               
                                                                               │ 63 │ │ │ │ │ │ questionIndex: (ctx) => (ctx.questionIndex = 0),                                                                                              │                                                                               
                                                                               │ 64 │ │ │ │ │ │                                                                                                                                               │                                                                               
                                                                               │ 65 │ │ │ │ │ │ correctCount: (ctx) => (ctx.correctCount = 0),                                                                                                │                                                                               
                                                                               │ 66 │ │ │ │ │ }),                                                                                                                                             │                                                                               
                                                                               │ 67 │ │ │ │ },                                                                                                                                                │                                                                               
                                                                               │ 68 │ │ │ },                                                                                                                                                  │                                                                               
                                                                               │ 69 │ │ },                                                        


 result: {                                                                                                                                             │                                                                               
                                                                               │ 11 │ │ │ on: {                                                                                                                                               │                                                                               
                                                                               │ 12 │ │ │ │ RESTART: {                                                                                                                                        │                                                                               
                                                                               │ 13 │ │ │ │ │ target: 'start',                                                                                                                                │                                                                               
                                                                               │ 14 │ │ │ │ │ actions: assign({                                                                                                                               │                                                                               
                                                                               │ 15 │ │ │ │ │ │ questionIndex: (ctx) => (ctx.questionIndex = 0),                                                                                              │                                                                               
                                                                               │ 16 │ │ │ │ │ │                                                                                                                                               │                                                                               
                                                                               │ 17 │ │ │ │ │ │ correctCount: (ctx) => (ctx.correctCount = 0),                                                                                                │                                                                               
                                                                               │ 18 │ │ │ │ │ }),                                                                                                                                             │                                                                               
                                                                               │ 19 │ │ │ │ },                                                                                                                                                │                                                                               
                                                                               │ 20 │ │ │ },                                                                                                                                                  │                                                                               
                                                                               │ 21 │ │ },                                                                                                                                                    │                                                                               
                                                                               │ 22 │ },                                                                                                                                                      │                                                                               
                                                                               │ 23 });                                                                                                                                                       │                                                                               
                                                                               │ 24                                                                                                                                                           │                                                                               
                                                                               │ 25 const TestBlock: React.FC<{ item: TestContentBlock }> = ({ item }) => {                                                                                   │                                                                               
                                                                               │ 26 │ const [state, send] = useMachine(testMachine);                                                                                                          │                                                                               
                                                                               │ 27 │ const status = state.value;                                                                                                                             │                                                                               
                                                                               │ 28 │ const { questionIndex, questionsCount, correctCount } = state.context;                                                                                  │                                                                               
                                                                               │ 29 │ const activeQuestion = item.questions[questionIndex];                                                                                                   │                                                                               
                                                                               │ 30 │ const activeResult = item.results.find(                                                                                                                 │                                                                               
                                                                               │ 31 │ │ (el) => el.score[1] >= correctCount && el.score[0] <= correctCount,                                                                                   │                                                                               
                                                                               │ 32 │ );                                                                                                                                                      │                                                                               
                                                                               │ 33 │                                                                                                                                                         │                                                                               
                                                                               │ 34 │ const restart = () => send({ type: 'RESTART' });                                                                                                        │                                                                               
                                                                               │ 35 │                                                                                                                                                         │                                                                               
                                                                               │ 36 │ useEffect(() => {                                                                                                                                       │                                                                               
                                                                               │ 37 │ │ send({ type: 'SET_QUESTIONS_COUNT', count: item.questions.length });                                                                                  │                                                                               
                                                                               │ 38 │ }, [send, item.questions.length]);                                                                                                                      │                                                                               
                                                                               │ 39 │                                                                                                                                                         │                                                                               
                                                                               │ 40 │ return (                                                                                                                                                │                                                                               
                                                                               │ 41 │ │ <>                                                                                                                                                    │                                                                               
                                                                               │ 42 │ │ │ <div className="text-[20px] leading-[28px] lg:text-[22px] lg:leading-[34px] font-bold mb-4 lg:text-2xl">                                            │                                                                               
                                                                               │ 43 │ │ │ │ {item.title}                                                                                                                                      │                                                                               
                                                                               │ 44 │ │ │ </div>                                                                                                                                              │                                                                               
                                                                               │ 45 │ │ │ {status === 'start' && (                                                                                                                            │                                                                               
                                                                               │ 46 │ │ │ │ <TestStart item={item} onStart={() => send({ type: 'START_TEST' })} />                                                                            │                                                                               
                                                                               │ 47 │ │ │ )}                                                                                                                                                  │                                                                               
                                                                               │ 48 │ │ │ {status === 'question' && activeQuestion && (                                                                                                       │                                                                               
                                                                               │ 49 │ │ │ │ <TestQuestion                                                                                                                                     │                                                                               
                                                                               │ 50 │ │ │ │ │ key={questionIndex}                                                                                                                             │                                                                               
                                                                               │ 51 │ │ │ │ │ testId={item.id}                                                                                                                                │                                                                               
                                                                               │ 52 │ │ │ │ │ questionsCount={questionsCount}                                                                                                                 │                                                                               
                                                                               │ 53 │ │ │ │ │ questionIndex={questionIndex}                                                                                                                   │                                                                               
                                                                               │ 54 │ │ │ │ │ question={activeQuestion}                                                                                                                       │                                                                               
                                                                               │ 55 │ │ │ │ │ onAnswer={(isCorrect) => {                                                                                                                      │                                                                               
                                                                               │ 56 │ │ │ │ │ │ if (isCorrect) send({ type: 'INCREMENT_CORRECT_COUNT' });                                                                                     │                                                                               
                                                                               │ 57 │ │ │ │ │ │ send({ type: 'INCREMENT_QUESTION_INDEX' });                                                                                                   │                                                                               
                                                                               │ 58 │ │ │ │ │ │ send({ type: 'NEXT_QUESTION' });                                                                                                              │                                                                               
                                                                               │ 59 │ │ │ │ │ }}                                                                                                                                              │                                                                               
                                                                               │ 60 │ │ │ │ │ onRestart={restart}                                                                                                                             │                                                                               
                                                                               │ 61 │ │ │ │ />                                                                                                                                                │                                                                               
                                                                               │ 62 │ │ │ )}                                                                                                                                                  │                                                                               
                                                                               │ 63 │ │ │ {status === 'result' && activeResult && (                                                                                                           │                                                                               
                                                                               │ 64 │ │ │ │ <TestResult                                                                                                                                       │                                                                               
                                                                               │ 65 │ │ │ │ │ result={activeResult}                                                                                                                           │                                                                               
                                                                               │ 66 │ │ │ │ │ onRestart={restart}                                                                                                                             │                                                                               
                                                                               │ 67 │ │ │ │ │ questionsCount={questionsCount}                                                                                                                 │                                                                               
                                                                               │ 68 │ │ │ │ │ correctCount={correctCount}                                                                                                                     │                                                                               
                                                                               │ 69 │ │ │ │ │ testTitle={item.title}                                                                                                                          │                                                                               
                                                                               │ 70 │ │ │ │ />                                                                                                                                                │                                                                               
                                                                               │ 71 │ │ │ )}                                                                                                                                                  │                                                                               
                                                                               │ 72 │ │ </>                                                                                                                                                   │                                                                               
                                                                               │ 73 │ );                                                                                                                                                      │                                                                               
                                                                               │ 74 };                                                                                                                                                        │                                                                               
                                                                               │ 75                                                                                                                                                           │                                                                               
                                                                               │ 76 export default TestBlock;