@testgorilla/tgo-typing-test 2.0.0 → 2.0.1

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

@@ -1,17 +0,0 @@
-import { MonkeyTypes } from '../../types/types';
-
-export let isRepeated = false;
-export let isPaceRepeat = false;
-export let activeChallenge: null | MonkeyTypes.Challenge = null;
-
-export function setRepeated(tf: boolean): void {
-  isRepeated = tf;
-}
-
-export function setPaceRepeat(tf: boolean): void {
-  isPaceRepeat = tf;
-}
-
-export function setActiveChallenge(val: null | MonkeyTypes.Challenge): void {
-  activeChallenge = val;
-}

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

@@ -1,442 +0,0 @@
-import Config from '../../helpers/config';
-import * as Misc from '../../utils/misc';
-import * as TestInput from './test-input';
-import * as TestWords from './test-words';
-import { MonkeyTypes } from '../../types/types';
-interface CharCount {
-  spaces: number;
-  correctWordChars: number;
-  allCorrectChars: number;
-  incorrectChars: number;
-  extraChars: number;
-  missedChars: number;
-  correctSpaces: number;
-}
-
-interface Keypress {
-  count: number;
-  errors: number;
-  words: number[];
-  afk: boolean;
-}
-
-interface KeypressTimings {
-  spacing: {
-    current: number;
-    array: number[] | 'toolong';
-  };
-  duration: {
-    current: number;
-    array: number[] | 'toolong';
-  };
-}
-
-interface DebugStats {
-  lastResult?: MonkeyTypes.Result<MonkeyTypes.Mode>;
-  start: number;
-  end: number;
-  wpmHistory: number[];
-  rawHistory: number[];
-  burstHistory: number[];
-  keypressPerSecond: Keypress[];
-  currentKeypress: {
-    count: number;
-    errors: number;
-    words: number[];
-    afk: boolean;
-  };
-  lastKeypress: number;
-  currentBurstStart: number;
-  lastSecondNotRound: boolean;
-  missedWords: {
-    [word: string]: number;
-  };
-  accuracy: {
-    correct: number;
-    incorrect: number;
-  };
-  keypressTimings: KeypressTimings;
-  keySpacingStats?: {
-    average: number;
-    sd: number;
-  };
-  keyDurationStats?: {
-    average: number;
-    sd: number;
-  };
-}
-
-interface Stats {
-  wpm: number;
-  wpmRaw: number;
-  acc: number;
-  correctChars: number;
-  incorrectChars: number;
-  missedChars: number;
-  extraChars: number;
-  allChars: number;
-  time: number;
-  spaces: number;
-  correctSpaces: number;
-}
-
-export let invalid = false;
-export let start: number, end: number;
-export let start2: number, end2: number;
-export let lastSecondNotRound = false;
-
-export let lastTestWpm = 0;
-
-export function setLastTestWpm(wpm: number): void {
-  lastTestWpm = wpm;
-}
-
-export let lastResult: MonkeyTypes.Result<MonkeyTypes.Mode>;
-
-export function setLastResult(result: MonkeyTypes.Result<MonkeyTypes.Mode>): void {
-  lastResult = result;
-}
-
-let wpmCalcDebug = false;
-export function wpmCalculationDebug(): void {
-  console.log('wpm calculation debug enabled');
-  wpmCalcDebug = true;
-}
-
-export function getStats(): DebugStats {
-  const ret: DebugStats = {
-    lastResult,
-    start,
-    end,
-    wpmHistory: TestInput.wpmHistory,
-    rawHistory: TestInput.wpmHistory,
-    burstHistory: TestInput.burstHistory,
-    keypressPerSecond: TestInput.keypressPerSecond,
-    currentKeypress: TestInput.currentKeypress,
-    lastKeypress: TestInput.lastKeypress,
-    currentBurstStart: TestInput.currentBurstStart,
-    lastSecondNotRound,
-    missedWords: TestInput.missedWords,
-    accuracy: TestInput.accuracy,
-    keypressTimings: TestInput.keypressTimings,
-  };
-
-  try {
-    ret.keySpacingStats = {
-      average:
-        (TestInput.keypressTimings.spacing.array as number[]).reduce(
-          (previous, current) => (current += previous)
-        ) / TestInput.keypressTimings.spacing.array.length,
-      sd: Misc.stdDev(TestInput.keypressTimings.spacing.array as number[]),
-    };
-  } catch (e) {
-    //
-  }
-  try {
-    ret.keyDurationStats = {
-      average:
-        (TestInput.keypressTimings.duration.array as number[]).reduce(
-          (previous, current) => (current += previous)
-        ) / TestInput.keypressTimings.duration.array.length,
-      sd: Misc.stdDev(TestInput.keypressTimings.duration.array as number[]),
-    };
-  } catch (e) {
-    //
-  }
-
-  return ret;
-}
-
-export function restart(): void {
-  start = 0;
-  end = 0;
-  invalid = false;
-  lastSecondNotRound = false;
-}
-
-export let restartCount = 0;
-export let incompleteSeconds = 0;
-
-export function incrementRestartCount(): void {
-  restartCount++;
-}
-
-export function incrementIncompleteSeconds(val: number): void {
-  incompleteSeconds += val;
-}
-
-export function resetIncomplete(): void {
-  restartCount = 0;
-  incompleteSeconds = 0;
-}
-
-export function setInvalid(): void {
-  invalid = true;
-}
-
-export function calculateTestSeconds(now?: number): number {
-  if (now === undefined) {
-    const endAfkSeconds = (end - TestInput.lastKeypress) / 1000;
-    if ((Config.mode == 'zen' || TestInput.bailout) && endAfkSeconds < 7) {
-      return (TestInput.lastKeypress - start) / 1000;
-    } else {
-      return (end - start) / 1000;
-    }
-  } else {
-    return (now - start) / 1000;
-  }
-}
-
-export function calculateWpmAndRaw(): MonkeyTypes.WordsPerMinuteAndRaw {
-  let chars = 0;
-  let correctWordChars = 0;
-  let spaces = 0;
-  //check input history
-  for (let i = 0; i < TestInput.input.history.length; i++) {
-    const word = Config.mode == 'zen' ? TestInput.input.getHistory(i) : TestWords.words.get(i);
-    if (TestInput.input.getHistory(i) == word) {
-      //the word is correct
-      //+1 for space
-      correctWordChars += word.length;
-      if (
-        i < TestInput.input.history.length - 1 &&
-        Misc.getLastChar(TestInput.input.getHistory(i) as string) !== '\n'
-      ) {
-        spaces++;
-      }
-    }
-    chars += TestInput.input.getHistory(i).length;
-  }
-  if (TestInput.input.current !== '') {
-    const word = Config.mode == 'zen' ? TestInput.input.current : TestWords.words.getCurrent();
-    //check whats currently typed
-    const toAdd = {
-      correct: 0,
-      incorrect: 0,
-      missed: 0,
-    };
-    for (let c = 0; c < word.length; c++) {
-      if (c < TestInput.input.current.length) {
-        //on char that still has a word list pair
-        if (TestInput.input.current[c] == word[c]) {
-          toAdd.correct++;
-        } else {
-          toAdd.incorrect++;
-        }
-      } else {
-        //on char that is extra
-        toAdd.missed++;
-      }
-    }
-    chars += toAdd.correct;
-    chars += toAdd.incorrect;
-    chars += toAdd.missed;
-    if (toAdd.incorrect == 0) {
-      //word is correct so far, add chars
-      correctWordChars += toAdd.correct;
-    }
-  }
-  if (Config.funbox === 'nospace' || Config.funbox === 'arrows') {
-    spaces = 0;
-  }
-  chars += TestInput.input.current.length;
-  const testSeconds = calculateTestSeconds(performance.now());
-  const wpm = Math.round(((correctWordChars + spaces) * (60 / testSeconds)) / 5);
-  const raw = Math.round(((chars + spaces) * (60 / testSeconds)) / 5);
-  return {
-    wpm: wpm,
-    raw: raw,
-  };
-}
-
-export function setEnd(e: number): void {
-  end = e;
-  end2 = Date.now();
-}
-
-export function setStart(s: number): void {
-  start = s;
-  start2 = Date.now();
-}
-
-export function calculateAfkSeconds(testSeconds: number): number {
-  let extraAfk = 0;
-  if (testSeconds !== undefined) {
-    if (Config.mode === 'time') {
-      extraAfk = Math.round(testSeconds) - TestInput.keypressPerSecond.length;
-    } else {
-      extraAfk = Math.ceil(testSeconds) - TestInput.keypressPerSecond.length;
-    }
-    if (extraAfk < 0) extraAfk = 0;
-    // console.log("-- extra afk debug");
-    // console.log("should be " + Math.ceil(testSeconds));
-    // console.log(keypressPerSecond.length);
-    // console.log(
-    //   `gonna add extra ${extraAfk} seconds of afk because of no keypress data`
-    // );
-  }
-  const ret = TestInput.keypressPerSecond.filter(x => x.afk).length;
-  return ret + extraAfk;
-}
-
-export function setLastSecondNotRound(): void {
-  lastSecondNotRound = true;
-}
-
-export function calculateBurst(): number {
-  const timeToWrite = (performance.now() - TestInput.currentBurstStart) / 1000;
-  let wordLength: number;
-  wordLength = TestInput.input.current.length;
-  if (wordLength == 0) {
-    wordLength = TestInput.input.getHistoryLast()?.length ?? 0;
-  }
-  if (wordLength == 0) return 0;
-  const speed = Misc.roundTo2((wordLength * (60 / timeToWrite)) / 5);
-  return Math.round(speed);
-}
-
-export function calculateAccuracy(): number {
-  const acc =
-    (TestInput.accuracy.correct / (TestInput.accuracy.correct + TestInput.accuracy.incorrect)) *
-    100;
-  return isNaN(acc) ? 0 : acc;
-}
-
-export function removeAfkData(): void {
-  const testSeconds = calculateTestSeconds();
-  TestInput.keypressPerSecond.splice(testSeconds);
-  TestInput.wpmHistory.splice(testSeconds);
-  TestInput.burstHistory.splice(testSeconds);
-  TestInput.rawHistory.splice(testSeconds);
-}
-
-function countChars(): CharCount {
-  let correctWordChars = 0;
-  let correctChars = 0;
-  let incorrectChars = 0;
-  let extraChars = 0;
-  let missedChars = 0;
-  let spaces = 0;
-  let correctspaces = 0;
-  for (let i = 0; i < TestInput.input.history.length; i++) {
-    const word = Config.mode == 'zen' ? TestInput.input.getHistory(i) : TestWords.words.get(i);
-    if (TestInput.input.getHistory(i) === '') {
-      //last word that was not started
-      continue;
-    }
-    if (TestInput.input.getHistory(i) == word) {
-      //the word is correct
-      correctWordChars += word.length;
-      correctChars += word.length;
-      if (
-        i < TestInput.input.history.length - 1 &&
-        Misc.getLastChar(TestInput.input.getHistory(i) as string) !== '\n'
-      ) {
-        correctspaces++;
-      }
-    } else if (TestInput.input.getHistory(i).length >= word.length) {
-      //too many chars
-      for (let c = 0; c < TestInput.input.getHistory(i).length; c++) {
-        if (c < word.length) {
-          //on char that still has a word list pair
-          if (TestInput.input.getHistory(i)[c] == word[c]) {
-            correctChars++;
-          } else {
-            incorrectChars++;
-          }
-        } else {
-          //on char that is extra
-          extraChars++;
-        }
-      }
-    } else {
-      //not enough chars
-      const toAdd = {
-        correct: 0,
-        incorrect: 0,
-        missed: 0,
-      };
-      for (let c = 0; c < word.length; c++) {
-        if (c < TestInput.input.getHistory(i).length) {
-          //on char that still has a word list pair
-          if (TestInput.input.getHistory(i)[c] == word[c]) {
-            toAdd.correct++;
-          } else {
-            toAdd.incorrect++;
-          }
-        } else {
-          //on char that is extra
-          toAdd.missed++;
-        }
-      }
-      correctChars += toAdd.correct;
-      incorrectChars += toAdd.incorrect;
-      if (i === TestInput.input.history.length - 1 && Config.mode == 'time') {
-        //last word - check if it was all correct - add to correct word chars
-        if (toAdd.incorrect === 0) correctWordChars += toAdd.correct;
-      } else {
-        missedChars += toAdd.missed;
-      }
-    }
-    if (i < TestInput.input.history.length - 1) {
-      spaces++;
-    }
-  }
-  if (Config.funbox === 'nospace' || Config.funbox === 'arrows') {
-    spaces = 0;
-    correctspaces = 0;
-  }
-  return {
-    spaces: spaces,
-    correctWordChars: correctWordChars,
-    allCorrectChars: correctChars,
-    incorrectChars: Config.mode == 'zen' ? TestInput.accuracy.incorrect : incorrectChars,
-    extraChars: extraChars,
-    missedChars: missedChars,
-    correctSpaces: correctspaces,
-  };
-}
-
-export function calculateStats(): Stats {
-  let testSeconds = calculateTestSeconds();
-  if (wpmCalcDebug) {
-    console.log('date based time', (end2 - start2) / 1000);
-    console.log('performance.now based time', testSeconds);
-  }
-  if (Config.mode != 'custom') {
-    testSeconds = Misc.roundTo2(testSeconds);
-    if (wpmCalcDebug) {
-      console.log('mode is not custom - wounding');
-      console.log('new time', testSeconds);
-    }
-  }
-  const chars = countChars();
-  const wpm = Misc.roundTo2(
-    ((chars.correctWordChars + chars.correctSpaces) * (60 / testSeconds)) / 5
-  );
-  const wpmraw = Misc.roundTo2(
-    ((chars.allCorrectChars + chars.spaces + chars.incorrectChars + chars.extraChars) *
-      (60 / testSeconds)) /
-      5
-  );
-  if (wpmCalcDebug) {
-    console.log('chars', chars);
-    console.log('wpm', ((chars.correctWordChars + chars.correctSpaces) * (60 / testSeconds)) / 5);
-    console.log('wpm rounded to 2', wpm);
-    console.log('wpmraw', wpmraw);
-  }
-  const acc = Misc.roundTo2(calculateAccuracy());
-  return {
-    wpm: isNaN(wpm) ? 0 : wpm,
-    wpmRaw: isNaN(wpmraw) ? 0 : wpmraw,
-    acc: acc,
-    correctChars: chars.correctWordChars,
-    incorrectChars: chars.incorrectChars,
-    missedChars: chars.missedChars,
-    extraChars: chars.extraChars,
-    allChars: chars.allCorrectChars + chars.spaces + chars.incorrectChars + chars.extraChars,
-    time: Misc.roundTo2(testSeconds),
-    spaces: chars.spaces,
-    correctSpaces: chars.correctSpaces,
-  };
-}

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

@@ -1,209 +0,0 @@
-// Most of the code is thanks to
-// https://stackoverflow.com/questions/29971898/how-to-create-an-accurate-timer-in-javascript
-
-import Config from '../../helpers/config';
-import { MonkeyTypes } from '../../types/types';
-import * as Misc from '../../utils/misc';
-import * as TimerEvent from '../observables/timer-event';
-import * as SlowTimer from '../states/slow-timer';
-import * as TestActive from '../states/test-active';
-import * as Time from '../states/time';
-import * as Caret from './caret';
-import * as CustomText from './custom-text';
-import * as TestInput from './test-input';
-import * as TestStats from './test-stats';
-import * as TestWords from './test-words';
-import * as TimerProgress from './timer-progress';
-let slowTimerCount = 0;
-let timer: NodeJS.Timeout | null = null;
-const interval = 1000;
-let expected = 0;
-
-let timerDebug = false;
-export function enableTimerDebug(): void {
-  timerDebug = true;
-}
-
-let checkIfTimeIsUpDisabled = false;
-export function disableCheckIfTimeIsUp(): void {
-  checkIfTimeIsUpDisabled = true;
-}
-
-export function clear(): void {
-  Time.set(0);
-  if (timer !== null) clearTimeout(timer);
-}
-
-function premid(): void {
-  if (timerDebug) console.time('premid');
-  const premidSecondsLeft = document.querySelector('#premidSecondsLeft');
-
-  if (premidSecondsLeft !== null) {
-    premidSecondsLeft.innerHTML = (Config.time - Time.get()).toString();
-  }
-  if (timerDebug) console.timeEnd('premid');
-}
-
-function updateTimer(): void {
-  if (timerDebug) console.time('timer progress update');
-  if (Config.mode === 'time' || (Config.mode === 'custom' && CustomText.isTimeRandom)) {
-    TimerProgress.update();
-  }
-  if (timerDebug) console.timeEnd('timer progress update');
-}
-
-function calculateWpmRaw(): MonkeyTypes.WordsPerMinuteAndRaw {
-  if (timerDebug) console.time('calculate wpm and raw');
-  const wpmAndRaw = TestStats.calculateWpmAndRaw();
-  if (timerDebug) console.timeEnd('calculate wpm and raw');
-  if (timerDebug) console.time('push to history');
-  TestInput.pushToWpmHistory(wpmAndRaw.wpm);
-  TestInput.pushToRawHistory(wpmAndRaw.raw);
-  if (timerDebug) console.timeEnd('push to history');
-  return wpmAndRaw;
-}
-
-function monkey(wpmAndRaw: MonkeyTypes.WordsPerMinuteAndRaw): void {
-  if (timerDebug) console.time('update monkey');
-  const num = Config.blindMode ? wpmAndRaw.raw : wpmAndRaw.wpm;
-  if (timerDebug) console.timeEnd('update monkey');
-}
-
-function calculateAcc(): number {
-  if (timerDebug) console.time('calculate acc');
-  const acc = Misc.roundTo2(TestStats.calculateAccuracy());
-  if (timerDebug) console.timeEnd('calculate acc');
-  return acc;
-}
-
-function layoutfluid(): void {
-  if (timerDebug) console.time('layoutfluid');
-  if (Config.funbox === 'layoutfluid' && Config.mode === 'time') {
-    const layouts = Config.customLayoutfluid
-      ? Config.customLayoutfluid.split('#')
-      : ['qwerty', 'dvorak', 'colemak'];
-    const switchTime = Config.time / layouts.length;
-    const time = Time.get();
-    const index = Math.floor(time / switchTime);
-    const layout = layouts[index];
-    const flooredSwitchTimes = [];
-
-    for (let i = 1; i < layouts.length; i++) {
-      flooredSwitchTimes.push(Math.floor(switchTime * i));
-    }
-  }
-  if (timerDebug) console.timeEnd('layoutfluid');
-}
-
-function checkIfFailed(wpmAndRaw: MonkeyTypes.WordsPerMinuteAndRaw, acc: number): void {
-  if (timerDebug) console.time('fail conditions');
-  TestInput.pushKeypressesToHistory();
-  if (
-    Config.minWpm === 'custom' &&
-    wpmAndRaw.wpm < Config.minWpmCustomSpeed &&
-    TestWords.words.currentIndex > 3
-  ) {
-    if (timer !== null) clearTimeout(timer);
-    SlowTimer.clear();
-    slowTimerCount = 0;
-    TimerEvent.dispatch('fail', 'min wpm');
-    return;
-  }
-  if (Config.minAcc === 'custom' && acc < Config.minAccCustom) {
-    if (timer !== null) clearTimeout(timer);
-    SlowTimer.clear();
-    slowTimerCount = 0;
-    TimerEvent.dispatch('fail', 'min accuracy');
-    return;
-  }
-  if (timerDebug) console.timeEnd('fail conditions');
-}
-
-function checkIfTimeIsUp(): void {
-  if (timerDebug) console.time('times up check');
-  if (Config.mode == 'time' || (Config.mode === 'custom' && CustomText.isTimeRandom)) {
-    if (
-      (Time.get() >= Config.time && Config.time !== 0 && Config.mode === 'time') ||
-      (Time.get() >= CustomText.time && CustomText.time !== 0 && Config.mode === 'custom')
-    ) {
-      //times up
-      if (timer !== null) clearTimeout(timer);
-      Caret.hide();
-      TestInput.input.pushHistory();
-      TestInput.corrected.pushHistory();
-      SlowTimer.clear();
-      slowTimerCount = 0;
-      TimerEvent.dispatch('finish');
-      return;
-    }
-  }
-  if (timerDebug) console.timeEnd('times up check');
-}
-
-// ---------------------------------------
-
-let timerStats: MonkeyTypes.TimerStats[] = [];
-
-export function getTimerStats(): MonkeyTypes.TimerStats[] {
-  return timerStats;
-}
-
-async function timerStep(): Promise<void> {
-  if (timerDebug) console.time('timer step -----------------------------');
-  Time.increment();
-  premid();
-  updateTimer();
-  const wpmAndRaw = calculateWpmRaw();
-  const acc = calculateAcc();
-  monkey(wpmAndRaw);
-  layoutfluid();
-  checkIfFailed(wpmAndRaw, acc);
-  if (!checkIfTimeIsUpDisabled) {
-    checkIfTimeIsUp();
-  }
-  if (timerDebug) console.timeEnd('timer step -----------------------------');
-}
-
-export async function start(): Promise<void> {
-  SlowTimer.clear();
-  slowTimerCount = 0;
-  timerStats = [];
-  expected = TestStats.start + interval;
-  (function loop(): void {
-    const delay = expected - performance.now();
-    timerStats.push({
-      dateNow: Date.now(),
-      now: performance.now(),
-      expected: expected,
-      nextDelay: delay,
-    });
-    if (
-      (Config.mode === 'time' && Config.time < 130 && Config.time > 0) ||
-      (Config.mode === 'words' && Config.words < 250 && Config.words > 0)
-    ) {
-      if (delay < interval / 2) {
-        //slow timer
-        SlowTimer.set();
-      }
-      if (delay < interval / 10) {
-        slowTimerCount++;
-        if (slowTimerCount > 5) {
-          TimerEvent.dispatch('fail', 'slow timer');
-        }
-      }
-    }
-    timer = setTimeout(function () {
-      if (!TestActive.get()) {
-        if (timer !== null) clearTimeout(timer);
-        SlowTimer.clear();
-        slowTimerCount = 0;
-        return;
-      }
-
-      timerStep();
-
-      expected += interval;
-      loop();
-    }, delay);
-  })();
-}