@testgorilla/tgo-typing-test 0.0.1

package/src/lib/helpers/test/test-logic.ts

@@ -0,0 +1,1039 @@
+import Config from '../../helpers/config';
+import QuotesController from '../controllers/quotes-controller';
+import * as Misc from '../../utils/misc';
+import * as ManualRestart from './manual-restart-tracker';
+import * as TestUI from './test-ui';
+import * as CustomText from './custom-text';
+import * as TestStats from './test-stats';
+import * as Focus from './focus';
+import * as Caret from './caret';
+import * as TimerProgress from './timer-progress';
+import * as OutOfFocus from './out-of-focus';
+import * as TestTimer from './test-timer';
+import * as Replay from './replay';
+import * as WeakSpot from './weak-spot';
+import * as Wordset from './wordset';
+import * as EnglishPunctuation from './english-punctuation';
+import * as ActivePage from '../states/active-page';
+import * as TestActive from '../states/test-active';
+import * as TestInput from './test-input';
+import * as TestState from './test-state';
+import * as TestWords from './test-words';
+import * as PageTransition from '../states/page-transition';
+import { BehaviorSubject, Subject } from 'rxjs';
+import * as TimerEvent from '../observables/timer-event';
+import { MonkeyTypes } from '../../types/types';
+
+let failReason = '';
+
+let wordsInput: HTMLInputElement;
+
+export const startTestSubject = new BehaviorSubject<boolean>(false);
+export const resultSub = new Subject<any>();
+
+export let notSignedInLastResult: MonkeyTypes.Result<MonkeyTypes.Mode> | null = null;
+
+export function setWordsInputElementTestLogic(wordsElement: HTMLInputElement) {
+  wordsInput = wordsElement;
+}
+
+export function clearNotSignedInResult(): void {
+  notSignedInLastResult = null;
+}
+
+function shouldCapitalize(lastChar: string): boolean {
+  return /[?!.؟]/.test(lastChar);
+}
+
+function addDecimalPoint(word: string): string {
+  if (Math.random() < 0.8) {
+    const decimal = Misc.getNumbers(3, 0);
+    if (decimal != '') {
+      word = word + '.' + decimal;
+    }
+  }
+  return word;
+}
+
+let spanishSentenceTracker = '';
+export async function punctuateWord(
+  previousWord: string,
+  currentWord: string,
+  index: number,
+  maxindex: number
+): Promise<string> {
+  let word = currentWord;
+
+  const currentLanguage = Config.language.split('_')[0];
+
+  const lastChar = Misc.getLastChar(previousWord);
+
+  if (Config.funbox === '58008') {
+    if (currentWord.length > 3) {
+      if (Math.random() < 0.5) {
+        word = Misc.setCharAt(word, Misc.randomIntFromRange(1, word.length - 2), '.');
+      }
+      if (Math.random() < 0.75) {
+        const index = Misc.randomIntFromRange(1, word.length - 2);
+        if (word[index - 1] !== '.' && word[index + 1] !== '.' && word[index + 1] !== '0') {
+          const special = Misc.randomElementFromArray(['/', '*', '-', '+']);
+          word = Misc.setCharAt(word, index, special);
+        }
+      }
+    }
+  } else if (Config.funbox === 'tenKeyMode') {
+    word = addDecimalPoint(word);
+    const special = Misc.randomElementFromArray(['/', '*', '-', '+']);
+    word = word + special + Misc.getNumbers(4);
+    // 2nd number of expression
+    word = addDecimalPoint(word);
+  } else {
+    if (currentLanguage != 'code' && (index == 0 || shouldCapitalize(lastChar))) {
+      //always capitalise the first word or if there was a dot unless using a code alphabet
+
+      word = Misc.capitalizeFirstLetterOfEachWord(word);
+
+      if (currentLanguage == 'turkish') {
+        word = word.replace(/I/g, 'İ');
+      }
+
+      if (currentLanguage == 'spanish' || currentLanguage == 'catalan') {
+        const rand = Math.random();
+        if (rand > 0.9) {
+          word = '¿' + word;
+          spanishSentenceTracker = '?';
+        } else if (rand > 0.8) {
+          word = '¡' + word;
+          spanishSentenceTracker = '!';
+        }
+      }
+    } else if (
+      (Math.random() < 0.1 && lastChar != '.' && lastChar != ',' && index != maxindex - 2) ||
+      index == maxindex - 1
+    ) {
+      if (currentLanguage == 'spanish' || currentLanguage == 'catalan') {
+        if (spanishSentenceTracker == '?' || spanishSentenceTracker == '!') {
+          word += spanishSentenceTracker;
+          spanishSentenceTracker = '';
+        }
+      } else {
+        const rand = Math.random();
+        if (rand <= 0.8) {
+          if (currentLanguage == 'kurdish') {
+            word += '.';
+          } else {
+            word += '.';
+          }
+        } else if (rand > 0.8 && rand < 0.9) {
+          if (currentLanguage == 'french') {
+            word = '?';
+          } else if (
+            currentLanguage == 'arabic' ||
+            currentLanguage == 'persian' ||
+            currentLanguage == 'urdu' ||
+            currentLanguage == 'kurdish'
+          ) {
+            word += '؟';
+          } else if (currentLanguage == 'greek') {
+            word += ';';
+          } else {
+            word += '?';
+          }
+        } else {
+          if (currentLanguage == 'french') {
+            word = '!';
+          } else {
+            word += '!';
+          }
+        }
+      }
+    } else if (
+      Math.random() < 0.01 &&
+      lastChar != ',' &&
+      lastChar != '.' &&
+      currentLanguage !== 'russian'
+    ) {
+      word = `"${word}"`;
+    } else if (
+      Math.random() < 0.011 &&
+      lastChar != ',' &&
+      lastChar != '.' &&
+      currentLanguage !== 'russian' &&
+      currentLanguage !== 'ukrainian'
+    ) {
+      word = `'${word}'`;
+    } else if (Math.random() < 0.012 && lastChar != ',' && lastChar != '.') {
+      if (currentLanguage == 'code') {
+        const r = Math.random();
+        if (r < 0.25) {
+          word = `(${word})`;
+        } else if (r < 0.5) {
+          word = `{${word}}`;
+        } else if (r < 0.75) {
+          word = `[${word}]`;
+        } else {
+          word = `<${word}>`;
+        }
+      } else {
+        word = `(${word})`;
+      }
+    } else if (
+      Math.random() < 0.013 &&
+      lastChar != ',' &&
+      lastChar != '.' &&
+      lastChar != ';' &&
+      lastChar != '؛' &&
+      lastChar != ':'
+    ) {
+      if (currentLanguage == 'french') {
+        word = ':';
+      } else if (currentLanguage == 'greek') {
+        word = '·';
+      } else {
+        word += ':';
+      }
+    } else if (Math.random() < 0.014 && lastChar != ',' && lastChar != '.' && previousWord != '-') {
+      word = '-';
+    } else if (
+      Math.random() < 0.015 &&
+      lastChar != ',' &&
+      lastChar != '.' &&
+      lastChar != ';' &&
+      lastChar != '؛' &&
+      lastChar != ':'
+    ) {
+      if (currentLanguage == 'french') {
+        word = ';';
+      } else if (currentLanguage == 'greek') {
+        word = '·';
+      } else if (currentLanguage == 'arabic' || currentLanguage == 'kurdish') {
+        word += '؛';
+      } else {
+        word += ';';
+      }
+    } else if (Math.random() < 0.2 && lastChar != ',') {
+      if (
+        currentLanguage == 'arabic' ||
+        currentLanguage == 'urdu' ||
+        currentLanguage == 'persian' ||
+        currentLanguage == 'kurdish'
+      ) {
+        word += '،';
+      } else {
+        word += ',';
+      }
+    } else if (Math.random() < 0.25 && currentLanguage == 'code') {
+      const specials = ['{', '}', '[', ']', '(', ')', ';', '=', '+', '%', '/'];
+
+      word = Misc.randomElementFromArray(specials);
+    } else if (
+      Math.random() < 0.5 &&
+      currentLanguage === 'english' &&
+      (await EnglishPunctuation.check(word))
+    ) {
+      word = await applyEnglishPunctuationToWord(word);
+    }
+  }
+  return word;
+}
+
+async function applyEnglishPunctuationToWord(word: string): Promise<string> {
+  return EnglishPunctuation.replace(word);
+}
+
+export function startTest(): boolean {
+  if (PageTransition.get()) {
+    return false;
+  }
+  startTestSubject.next(true);
+  TestActive.set(true);
+  Replay.startReplayRecording();
+  Replay.replayGetWordsList(TestWords.words.list);
+  TestInput.resetKeypressTimings();
+  TimerProgress.update();
+  TestTimer.clear();
+
+  TestStats.setStart(performance.now());
+  TestTimer.start();
+  return true;
+}
+
+interface RestartOptions {
+  withSameWordset?: boolean;
+  nosave?: boolean;
+  event?: { shiftKey: any };
+  practiseMissed?: boolean;
+  noAnim?: boolean;
+}
+
+export function restart(options = {} as RestartOptions): void {
+  const defaultOptions = {
+    withSameWordset: false,
+    practiseMissed: false,
+    noAnim: false,
+    nosave: false,
+  };
+
+  options = { ...defaultOptions, ...options };
+
+  if (TestUI.testRestarting || TestUI.resultCalculating) {
+    event?.preventDefault();
+    return;
+  }
+  if (ActivePage.get() == 'test' && !TestUI.resultVisible) {
+    if (!ManualRestart.get()) {
+      if (TestWords.hasTab && !options.event?.shiftKey && Config.quickRestart !== 'esc') {
+        return;
+      }
+      if (Config.mode !== 'zen') event?.preventDefault();
+      if (!Misc.canQuickRestart(Config.mode, Config.words, Config.time, CustomText)) {
+        return;
+      }
+    }
+  }
+  if (TestActive.get()) {
+    if (
+      Config.repeatQuotes === 'typing' &&
+      Config.mode === 'quote' &&
+      Config.language.replace(/_\d*k$/g, '') === TestWords.randomQuote.language
+    ) {
+      options.withSameWordset = true;
+    }
+    if (TestState.isRepeated) {
+      options.withSameWordset = true;
+    }
+
+    TestInput.pushKeypressesToHistory();
+    const testSeconds = TestStats.calculateTestSeconds(performance.now());
+    const afkseconds = TestStats.calculateAfkSeconds(testSeconds);
+    let tt = testSeconds - afkseconds;
+    if (tt < 0) tt = 0;
+    TestStats.incrementIncompleteSeconds(tt);
+    TestStats.incrementRestartCount();
+  }
+
+  let repeatWithPace = false;
+  if (TestUI.resultVisible && Config.repeatedPace && options.withSameWordset) {
+    repeatWithPace = true;
+  }
+
+  ManualRestart.reset();
+  TestTimer.clear();
+  TestStats.restart();
+  TestInput.restart();
+  TestInput.corrected.reset();
+  startTestSubject.next(false);
+  Caret.hide();
+  TestActive.set(false);
+  TestInput.setBailout(false);
+
+  if (ActivePage.get() == 'test' && window.scrollY > 0) {
+    window.scrollTo({ top: 0, behavior: 'smooth' });
+  }
+
+  wordsInput.value = ' ';
+
+  TestUI.reset();
+
+  TestUI.setResultVisible(false);
+  PageTransition.set(true);
+  TestUI.setTestRestarting(true);
+  (async () => {
+    if (ActivePage.get() == 'test') {
+      Focus.set(false);
+    }
+    TestUI.focusWords();
+    wordsInput.value = ' ';
+    let shouldQuoteRepeat = false;
+    if (Config.mode === 'quote' && Config.repeatQuotes === 'typing' && failReason !== '') {
+      shouldQuoteRepeat = true;
+    }
+
+    if (!options.withSameWordset && !shouldQuoteRepeat) {
+      TestState.setRepeated(false);
+      TestState.setPaceRepeat(repeatWithPace);
+      TestWords.setHasTab(false);
+      try {
+        await init();
+      } catch {
+        TestUI.setTestRestarting(false);
+        return;
+      }
+    } else {
+      TestState.setRepeated(true);
+      TestState.setPaceRepeat(repeatWithPace);
+      TestActive.set(false);
+      TestWords.words.resetCurrentIndex();
+      TestInput.input.reset();
+      TestUI.showWords();
+    }
+    failReason = '';
+
+    let fbtext = '';
+    if (Config.funbox !== 'none') {
+      fbtext = ' ' + Config.funbox;
+    }
+
+    TestUI.setTestRestarting(false);
+    TestTimer.clear();
+    PageTransition.set(false);
+
+    // Added by me
+    startTest();
+  })();
+}
+
+function applyFunboxesToWord(word: string, wordset?: Wordset.Wordset): string {
+  if (Config.funbox === 'rAnDoMcAsE') {
+    let randomcaseword = '';
+    for (let i = 0; i < word.length; i++) {
+      if (i % 2 != 0) {
+        randomcaseword += word[i].toUpperCase();
+      } else {
+        randomcaseword += word[i];
+      }
+    }
+    word = randomcaseword;
+  } else if (Config.funbox === 'capitals') {
+    word = Misc.capitalizeFirstLetterOfEachWord(word);
+  } else if (Config.funbox === 'gibberish') {
+    word = Misc.getGibberish();
+  } else if (Config.funbox === 'arrows') {
+    word = Misc.getArrows();
+  } else if (Config.funbox === 'tenKeyMode') {
+    word = Misc.getNumbers(Config.punctuation ? 4 : 5, Config.punctuation ? 1 : 2);
+    if (Config.language.split('_')[0] === 'kurdish') {
+      word = Misc.convertNumberToArabicIndic(word);
+    }
+  } else if (Config.funbox === '58008') {
+    word = Misc.getNumbers(7);
+    if (Config.language.split('_')[0] === 'kurdish') {
+      word = Misc.convertNumberToArabicIndic(word);
+    }
+  } else if (Config.funbox === 'specials') {
+    word = Misc.getSpecials();
+  } else if (Config.funbox === 'ascii') {
+    word = Misc.getASCII();
+  } else if (wordset !== undefined && Config.funbox === 'weakspot') {
+    word = WeakSpot.getWord(wordset);
+  }
+  return word;
+}
+
+async function getNextWord(
+  wordset: Wordset.Wordset,
+  language: MonkeyTypes.LanguageObject,
+  wordsBound: number
+): Promise<string> {
+  let randomWord = wordset.randomWord();
+  const previousWord = TestWords.words.get(TestWords.words.length - 1, true);
+  const previousWord2 = TestWords.words.get(TestWords.words.length - 2, true);
+
+  // Added by TG
+  if (Config.customTGQuotes) {
+    if (TestWords.words.length - TestWords.words.currentIndex <= 40) {
+      const randomQuote = QuotesController.getRandomQuote();
+      let rq: MonkeyTypes.Quote | undefined | null = undefined;
+      rq = randomQuote;
+
+      if (rq !== (undefined || null)) {
+        rq.text = rq.text.replace(/ +/gm, ' ');
+        rq.text = rq.text.replace(/\\\\t/gm, '\t');
+        rq.text = rq.text.replace(/\\\\n/gm, '\n');
+        rq.text = rq.text.replace(/\\t/gm, '\t');
+        rq.text = rq.text.replace(/\\n/gm, '\n');
+        rq.text = rq.text.replace(/( *(\r\n|\r|\n) *)/g, '\n ');
+        rq.text = rq.text.replace(/…/g, '...');
+        rq.text = rq.text.trim();
+        rq.textSplit = rq.text.split(' ');
+        rq.language = Config.language.replace(/_\d*k$/g, '');
+        TestWords.setRandomQuote(rq);
+      }
+
+      return TestWords.randomQuote.text;
+    }
+  } else if (Config.mode === 'quote') {
+    randomWord = TestWords.randomQuote.textSplit?.[TestWords.words.length] ?? '';
+  } else if (Config.mode == 'custom' && !CustomText.isWordRandom && !CustomText.isTimeRandom) {
+    randomWord = CustomText.text[TestWords.words.length];
+  } else {
+    let regenarationCount = 0; //infinite loop emergency stop button
+    while (
+      regenarationCount < 100 &&
+      (previousWord == randomWord ||
+        previousWord2 == randomWord ||
+        (Config.mode !== 'custom' && !Config.punctuation && randomWord == 'I') ||
+        (Config.mode !== 'custom' &&
+          !Config.punctuation &&
+          /[-=_+[\]{};'\\:"|,./<>?]/i.test(randomWord)))
+    ) {
+      regenarationCount++;
+      randomWord = wordset.randomWord();
+    }
+  }
+
+  if (randomWord === undefined) {
+    randomWord = wordset.randomWord();
+  }
+
+  randomWord = randomWord.replace(/ +/gm, ' ');
+  randomWord = randomWord.replace(/^ | $/gm, '');
+  randomWord = applyFunboxesToWord(randomWord, wordset);
+
+  if (Config.punctuation) {
+    randomWord = await punctuateWord(
+      TestWords.words.get(TestWords.words.length - 1),
+      randomWord,
+      TestWords.words.length,
+      wordsBound
+    );
+  }
+  if (Config.numbers) {
+    if (Math.random() < 0.1) {
+      randomWord = Misc.getNumbers(4);
+
+      if (Config.language.split('_')[0] === 'kurdish') {
+        randomWord = Misc.convertNumberToArabicIndic(randomWord);
+      }
+    }
+  }
+
+  return randomWord;
+}
+
+export async function init(): Promise<void> {
+  TestActive.set(false);
+  TestWords.words.reset();
+  TestUI.setCurrentWordElementIndex(0);
+
+  TestInput.input.resetHistory();
+  TestInput.input.resetCurrent();
+
+  let language;
+  try {
+    language = await Misc.getLanguage(Config.language);
+  } catch (e) {
+    Misc.emitQuoteNetworkError();
+    throw e;
+  }
+
+  let wordsBound = 100;
+  if (Config.showAllLines) {
+    if (Config.mode === 'quote') {
+      wordsBound = 100;
+    } else if (Config.mode === 'custom') {
+      if (CustomText.isWordRandom) {
+        wordsBound = CustomText.word;
+      } else if (CustomText.isTimeRandom) {
+        wordsBound = 100;
+      } else {
+        wordsBound = CustomText.text.length;
+      }
+    } else if (Config.mode != 'time') {
+      wordsBound = Config.words;
+    }
+  } else {
+    if (Config.mode === 'words' && Config.words < wordsBound) {
+      wordsBound = Config.words;
+    }
+    if (Config.mode == 'custom' && CustomText.isWordRandom && CustomText.word < wordsBound) {
+      wordsBound = CustomText.word;
+    }
+    if (Config.mode == 'custom' && CustomText.isTimeRandom) {
+      wordsBound = 100;
+    }
+    if (
+      Config.mode == 'custom' &&
+      !CustomText.isWordRandom &&
+      !CustomText.isTimeRandom &&
+      CustomText.text.length < wordsBound
+    ) {
+      wordsBound = CustomText.text.length;
+    }
+  }
+
+  if (
+    (Config.mode === 'custom' && CustomText.isWordRandom && CustomText.word == 0) ||
+    (Config.mode === 'custom' && CustomText.isTimeRandom && CustomText.time == 0)
+  ) {
+    wordsBound = 100;
+  }
+
+  if (Config.mode === 'words' && Config.words === 0) {
+    wordsBound = 100;
+  }
+  if (Config.funbox === 'plus_one') {
+    wordsBound = 2;
+    if (Config.mode === 'words' && Config.words < wordsBound) {
+      wordsBound = Config.words;
+    }
+  }
+  if (Config.funbox === 'plus_two') {
+    wordsBound = 3;
+    if (Config.mode === 'words' && Config.words < wordsBound) {
+      wordsBound = Config.words;
+    }
+  }
+
+  if (
+    (Config.mode == 'time' || Config.mode == 'words' || Config.mode == 'custom') &&
+    !Config.customTGQuotes
+  ) {
+    let wordList = language.words;
+    if (Config.mode == 'custom') {
+      wordList = CustomText.text;
+    }
+    const wordset = Wordset.withWords(wordList, Config.funbox);
+
+    if ((Config.funbox == 'wikipedia' || Config.funbox == 'poetry') && Config.mode != 'custom') {
+      // Skip word generation for wikipedia/poetry funboxes in non-custom mode
+    } else {
+      for (let i = 0; i < wordsBound; i++) {
+        const randomWord = await getNextWord(wordset, language, wordsBound);
+
+        if (/\t/g.test(randomWord)) {
+          TestWords.setHasTab(true);
+        }
+
+        const te = randomWord.replace('\n', '\n ').trim();
+
+        if (/ +/.test(te)) {
+          const randomList = te.split(' ');
+          let id = 0;
+          while (id < randomList.length) {
+            TestWords.words.push(randomList[id]);
+            id++;
+
+            if (
+              TestWords.words.length == wordsBound &&
+              Config.mode == 'custom' &&
+              CustomText.isWordRandom
+            ) {
+              break;
+            }
+          }
+          if (Config.mode == 'custom' && !CustomText.isWordRandom && !CustomText.isTimeRandom) {
+            // Custom mode with fixed text - no adjustment needed
+          } else {
+            i = TestWords.words.length - 1;
+          }
+        } else {
+          TestWords.words.push(randomWord);
+        }
+      }
+    }
+  }
+
+  // Added by TG
+  if (Config.customTGQuotes) {
+    let quotesCollection;
+
+    try {
+      quotesCollection = await QuotesController.getQuotes(
+        Config.language,
+        Config.testVersion,
+        Config.quoteLength
+      );
+    } catch (e) {
+      Misc.emitQuoteNetworkError();
+      throw e;
+    }
+
+    let rq: MonkeyTypes.Quote | undefined | null = undefined;
+    const randomQuote = QuotesController.getRandomQuote();
+    rq = randomQuote;
+
+    if (rq === (undefined || null)) return;
+
+    rq.text = rq.text.replace(/ +/gm, ' ');
+    rq.text = rq.text.replace(/\\\\t/gm, '\t');
+    rq.text = rq.text.replace(/\\\\n/gm, '\n');
+    rq.text = rq.text.replace(/\\t/gm, '\t');
+    rq.text = rq.text.replace(/\\n/gm, '\n');
+    rq.text = rq.text.replace(/( *(\r\n|\r|\n) *)/g, '\n ');
+    rq.text = rq.text.replace(/…/g, '...');
+    rq.text = rq.text.trim();
+    rq.textSplit = rq.text.split(' ');
+    rq.language = Config.language.replace(/_\d*k$/g, '');
+
+    TestWords.setRandomQuote(rq);
+
+    const w = TestWords.randomQuote.textSplit;
+
+    if (w === undefined) return;
+
+    for (let i = 0; i < w.length; i++) {
+      if (/\t/g.test(w[i])) {
+        TestWords.setHasTab(true);
+      }
+
+      w[i] = applyFunboxesToWord(w[i]);
+
+      TestWords.words.push(w[i]);
+    }
+  }
+
+  TestUI.showWords();
+}
+
+export async function addWord(): Promise<void> {
+  let bound = 100;
+  if (Config.funbox === 'plus_one') bound = 1;
+  if (Config.funbox === 'plus_two') bound = 2;
+  if (
+    TestWords.words.length - TestInput.input.history.length > bound ||
+    (Config.mode === 'words' && TestWords.words.length >= Config.words && Config.words > 0) ||
+    (Config.mode === 'custom' &&
+      CustomText.isWordRandom &&
+      TestWords.words.length >= CustomText.word &&
+      CustomText.word != 0) ||
+    (Config.mode === 'custom' &&
+      !CustomText.isWordRandom &&
+      !CustomText.isTimeRandom &&
+      TestWords.words.length >= CustomText.text.length) ||
+    (Config.mode === 'quote' &&
+      TestWords.words.length >= (TestWords.randomQuote.textSplit?.length ?? 0))
+  ) {
+    return;
+  }
+
+  const language: MonkeyTypes.LanguageObject =
+    Config.mode !== 'custom'
+      ? await Misc.getCurrentLanguage(Config.language)
+      : {
+          //borrow the direction of the current language
+          ...(await Misc.getCurrentLanguage(Config.language)),
+          words: CustomText.text,
+        };
+  const wordset = Wordset.withWords(language.words, Config.funbox);
+
+  const randomWord = await getNextWord(wordset, language, bound);
+
+  const split = randomWord.split(' ');
+
+  if (!Config.customTGQuotes) {
+    if (split.length > 1) {
+      split.forEach(word => {
+        TestWords.words.push(word);
+        TestUI.addWord(word);
+      });
+    } else {
+      TestWords.words.push(randomWord);
+      TestUI.addWord(randomWord);
+    }
+  } else {
+    if (split.length > 1) {
+      split.forEach(word => {
+        TestWords.words.push(word);
+        TestUI.addWord(word);
+      });
+    }
+  }
+}
+
+interface CompletedEvent extends MonkeyTypes.Result<MonkeyTypes.Mode> {
+  keySpacing: number[] | 'toolong';
+  keyDuration: number[] | 'toolong';
+  customText: MonkeyTypes.CustomText;
+  smoothConsistency: number;
+  wpmConsistency: number;
+  lang: string;
+  challenge?: string | null;
+}
+
+type PartialCompletedEvent = Omit<Partial<CompletedEvent>, 'chartData'> & {
+  chartData: Partial<MonkeyTypes.ChartData>;
+};
+
+interface RetrySaving {
+  completedEvent: CompletedEvent | null;
+  canRetry: boolean;
+}
+
+const retrySaving: RetrySaving = {
+  completedEvent: null,
+  canRetry: false,
+};
+
+function buildCompletedEvent(difficultyFailed: boolean): CompletedEvent {
+  //build completed event object
+  const completedEvent: PartialCompletedEvent = {
+    wpm: undefined,
+    rawWpm: undefined,
+    kph: -1,
+    charStats: undefined,
+    acc: undefined,
+    mode: Config.mode,
+    mode2: undefined as never,
+    quoteLength: -1,
+    punctuation: Config.punctuation,
+    numbers: Config.numbers,
+    lazyMode: Config.lazyMode,
+    timestamp: Date.now(),
+    language: Config.language,
+    restartCount: TestStats.restartCount,
+    incompleteTestSeconds:
+      TestStats.incompleteSeconds < 0 ? 0 : Misc.roundTo2(TestStats.incompleteSeconds),
+    difficulty: Config.difficulty,
+    blindMode: Config.blindMode,
+    tags: undefined,
+    keySpacing: TestInput.keypressTimings.spacing.array,
+    keyDuration: TestInput.keypressTimings.duration.array,
+    consistency: undefined,
+    keyConsistency: undefined,
+    funbox: Config.funbox,
+    bailedOut: TestInput.bailout,
+    chartData: {
+      wpm: TestInput.wpmHistory,
+      raw: undefined,
+      err: undefined,
+    },
+    customText: undefined,
+    testDuration: undefined,
+    afkDuration: undefined,
+  };
+
+  // stats
+  const stats = TestStats.calculateStats();
+  if (stats.time % 1 != 0 && Config.mode !== 'time') {
+    TestStats.setLastSecondNotRound();
+  }
+  TestStats.setLastTestWpm(stats.wpm);
+  completedEvent.wpm = stats.wpm;
+  completedEvent.rawWpm = stats.wpmRaw;
+  completedEvent.charStats = [
+    stats.correctChars + stats.correctSpaces,
+    stats.incorrectChars,
+    stats.extraChars,
+    stats.missedChars,
+  ];
+  completedEvent.acc = stats.acc;
+  if (Config.funbox === 'tenKeyMode') {
+    completedEvent.kph = stats.wpm * 5 * 60;
+  }
+
+  // if the last second was not rounded, add another data point to the history
+  if (TestStats.lastSecondNotRound && !difficultyFailed) {
+    const wpmAndRaw = TestStats.calculateWpmAndRaw();
+    TestInput.pushToWpmHistory(wpmAndRaw.wpm);
+    TestInput.pushToRawHistory(wpmAndRaw.raw);
+    TestInput.pushKeypressesToHistory();
+  }
+
+  //consistency
+  const rawPerSecond = TestInput.keypressPerSecond.map(f => Math.round((f.count / 5) * 60));
+  const stddev = Misc.stdDev(rawPerSecond);
+  const avg = Misc.mean(rawPerSecond);
+  let consistency = Misc.roundTo2(Misc.kogasa(stddev / avg));
+  let keyConsistencyArray =
+    TestInput.keypressTimings.spacing.array === 'toolong'
+      ? []
+      : TestInput.keypressTimings.spacing.array.slice();
+  if (keyConsistencyArray.length > 0) {
+    keyConsistencyArray = keyConsistencyArray.slice(0, keyConsistencyArray.length - 1);
+  }
+  let keyConsistency = Misc.roundTo2(
+    Misc.kogasa(Misc.stdDev(keyConsistencyArray) / Misc.mean(keyConsistencyArray))
+  );
+  if (!consistency || isNaN(consistency)) {
+    consistency = 0;
+  }
+  if (!keyConsistency || isNaN(keyConsistency)) {
+    keyConsistency = 0;
+  }
+  completedEvent.keyConsistency = keyConsistency;
+  completedEvent.consistency = consistency;
+  const smoothedraw = Misc.smooth(rawPerSecond, 1);
+  completedEvent.chartData.raw = smoothedraw;
+  completedEvent.chartData.unsmoothedRaw = rawPerSecond;
+
+  //smoothed consistency
+  const stddev2 = Misc.stdDev(smoothedraw);
+  const avg2 = Misc.mean(smoothedraw);
+  const smoothConsistency = Misc.roundTo2(Misc.kogasa(stddev2 / avg2));
+  completedEvent.smoothConsistency = smoothConsistency;
+
+  //wpm consistency
+  const stddev3 = Misc.stdDev(completedEvent.chartData.wpm ?? []);
+  const avg3 = Misc.mean(completedEvent.chartData.wpm ?? []);
+  const wpmConsistency = Misc.roundTo2(Misc.kogasa(stddev3 / avg3));
+  completedEvent.wpmConsistency = wpmConsistency;
+
+  completedEvent.testDuration = parseFloat(stats.time.toString());
+  completedEvent.afkDuration = TestStats.calculateAfkSeconds(completedEvent.testDuration);
+
+  completedEvent.chartData.err = [];
+  for (let i = 0; i < TestInput.keypressPerSecond.length; i++) {
+    completedEvent.chartData.err.push(TestInput.keypressPerSecond[i].errors);
+  }
+
+  if (Config.mode === 'quote') {
+    completedEvent.quoteLength = TestWords.randomQuote.group;
+    completedEvent.language = Config.language.replace(/_\d*k$/g, '');
+  } else {
+    delete completedEvent.quoteLength;
+  }
+
+  // @ts-expect-error TODO fix this
+  completedEvent.mode2 = Misc.getMode2(Config, TestWords.randomQuote);
+
+  if (Config.mode === 'custom') {
+    completedEvent.customText = <MonkeyTypes.CustomText>{};
+    completedEvent.customText.textLen = CustomText.text.length;
+    completedEvent.customText.isWordRandom = CustomText.isWordRandom;
+    completedEvent.customText.isTimeRandom = CustomText.isTimeRandom;
+    completedEvent.customText.word = CustomText.word;
+    completedEvent.customText.time = CustomText.time;
+  } else {
+    delete completedEvent.customText;
+  }
+
+  //tags
+  const activeTagsIds: string[] = [];
+  completedEvent.tags = activeTagsIds;
+
+  if (completedEvent.mode != 'custom') delete completedEvent.customText;
+
+  return <CompletedEvent>completedEvent;
+}
+
+export function stopTest(): void {
+  TestActive.set(false);
+  Focus.set(false);
+  Caret.hide();
+  OutOfFocus.hide();
+  TestTimer.clear();
+}
+
+export async function finish(difficultyFailed = false): Promise<void> {
+  if (!TestActive.get()) return;
+
+  startTestSubject.next(false);
+
+  TestInput.recordKeypressSpacing(); //this is needed in case there is afk time at the end - to make sure test duration makes sense
+
+  TestUI.setResultCalculating(true);
+  TestUI.setResultVisible(true);
+  TestStats.setEnd(performance.now());
+  TestActive.set(false);
+  Focus.set(false);
+  Caret.hide();
+  OutOfFocus.hide();
+  TestTimer.clear();
+
+  if (TestInput.burstHistory.length !== TestInput.input.getHistory().length) {
+    const burst = TestStats.calculateBurst();
+    TestInput.pushBurstToHistory(burst);
+  }
+
+  if (Config.mode == 'zen' || TestInput.bailout) {
+    TestStats.removeAfkData();
+  }
+
+  const completedEvent = buildCompletedEvent(difficultyFailed);
+
+  function countUndefined(input: unknown): number {
+    if (typeof input === 'undefined') {
+      return 1;
+    } else if (typeof input === 'object' && input !== null) {
+      return Object.values(input).reduce((a, b) => a + countUndefined(b), 0) as number;
+    } else {
+      return 0;
+    }
+  }
+
+  if (countUndefined(completedEvent) > 0) {
+    console.log(completedEvent);
+    return;
+  }
+
+  const kps = TestInput.keypressPerSecond.slice(-5);
+  let afkDetected = kps.every(second => second.afk);
+  if (TestInput.bailout) afkDetected = false;
+
+  let tooShort = false;
+  let dontSave = false;
+  if (difficultyFailed) {
+    dontSave = true;
+  } else if (afkDetected) {
+    dontSave = true;
+  } else if (TestState.isRepeated) {
+    dontSave = true;
+  } else if (
+    (Config.mode === 'time' && completedEvent.mode2 < 15 && completedEvent.mode2 > 0) ||
+    (Config.mode === 'time' && completedEvent.mode2 == 0 && completedEvent.testDuration < 15) ||
+    (Config.mode === 'words' && completedEvent.mode2 < 10 && completedEvent.mode2 > 0) ||
+    (Config.mode === 'words' && completedEvent.mode2 == 0 && completedEvent.testDuration < 15) ||
+    (Config.mode === 'custom' &&
+      !CustomText.isWordRandom &&
+      !CustomText.isTimeRandom &&
+      CustomText.text.length < 10) ||
+    (Config.mode === 'custom' &&
+      CustomText.isWordRandom &&
+      !CustomText.isTimeRandom &&
+      CustomText.word < 10) ||
+    (Config.mode === 'custom' &&
+      !CustomText.isWordRandom &&
+      CustomText.isTimeRandom &&
+      CustomText.time < 15) ||
+    (Config.mode === 'zen' && completedEvent.testDuration < 15)
+  ) {
+    tooShort = true;
+    dontSave = true;
+  } else if (completedEvent.wpm < 0 || completedEvent.wpm > 350) {
+    TestStats.setInvalid();
+    dontSave = true;
+  } else if (completedEvent.acc < 75 || completedEvent.acc > 100) {
+    TestStats.setInvalid();
+    dontSave = true;
+  }
+
+  TestStats.setLastResult(completedEvent);
+
+  resultSub.next({
+    completedEvent: completedEvent,
+    difficultyFailed: difficultyFailed,
+    failReason: failReason,
+    afkDetected: afkDetected,
+    isRepeated: TestState.isRepeated,
+    tooShort: tooShort,
+    randomQuote: TestWords.randomQuote,
+    dontSave: dontSave,
+    wpmHistory: TestInput.wpmHistory,
+  });
+
+  if (completedEvent.chartData !== 'toolong') {
+    delete completedEvent.chartData.unsmoothedRaw;
+  }
+
+  if (completedEvent.testDuration > 122) {
+    completedEvent.chartData = 'toolong';
+    completedEvent.keySpacing = 'toolong';
+    completedEvent.keyDuration = 'toolong';
+    TestInput.setKeypressTimingsTooLong();
+  }
+
+  if (
+    Config.difficulty == 'normal' ||
+    ((Config.difficulty == 'master' || Config.difficulty == 'expert') && !difficultyFailed)
+  ) {
+    TestStats.resetIncomplete();
+  }
+}
+
+export function fail(reason: string): void {
+  failReason = reason;
+  TestInput.pushKeypressesToHistory();
+  finish(true);
+  const testSeconds = TestStats.calculateTestSeconds(performance.now());
+  const afkseconds = TestStats.calculateAfkSeconds(testSeconds);
+  let tt = testSeconds - afkseconds;
+  if (tt < 0) tt = 0;
+  TestStats.incrementIncompleteSeconds(tt);
+  TestStats.incrementRestartCount();
+}
+
+TimerEvent.subscribe((eventKey, eventValue) => {
+  if (eventKey === 'fail' && eventValue !== undefined) fail(eventValue);
+  if (eventKey === 'finish') finish();
+});