@testgorilla/tgo-typing-test 0.0.1 → 1.0.0

package/esm2022/lib/helpers/test/test-state.mjs

@@ -0,0 +1,13 @@
+export let isRepeated = false;
+export let isPaceRepeat = false;
+export let activeChallenge = null;
+export function setRepeated(tf) {
+    isRepeated = tf;
+}
+export function setPaceRepeat(tf) {
+    isPaceRepeat = tf;
+}
+export function setActiveChallenge(val) {
+    activeChallenge = val;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC1zdGF0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3Rnby10eXBpbmctdGVzdC9zcmMvbGliL2hlbHBlcnMvdGVzdC90ZXN0LXN0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxJQUFJLFVBQVUsR0FBRyxLQUFLLENBQUM7QUFDOUIsTUFBTSxDQUFDLElBQUksWUFBWSxHQUFHLEtBQUssQ0FBQztBQUNoQyxNQUFNLENBQUMsSUFBSSxlQUFlLEdBQWlDLElBQUksQ0FBQztBQUVoRSxNQUFNLFVBQVUsV0FBVyxDQUFDLEVBQVc7SUFDckMsVUFBVSxHQUFHLEVBQUUsQ0FBQztBQUNsQixDQUFDO0FBRUQsTUFBTSxVQUFVLGFBQWEsQ0FBQyxFQUFXO0lBQ3ZDLFlBQVksR0FBRyxFQUFFLENBQUM7QUFDcEIsQ0FBQztBQUVELE1BQU0sVUFBVSxrQkFBa0IsQ0FBQyxHQUFpQztJQUNsRSxlQUFlLEdBQUcsR0FBRyxDQUFDO0FBQ3hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNb25rZXlUeXBlcyB9IGZyb20gJy4uLy4uL3R5cGVzL3R5cGVzJztcblxuZXhwb3J0IGxldCBpc1JlcGVhdGVkID0gZmFsc2U7XG5leHBvcnQgbGV0IGlzUGFjZVJlcGVhdCA9IGZhbHNlO1xuZXhwb3J0IGxldCBhY3RpdmVDaGFsbGVuZ2U6IG51bGwgfCBNb25rZXlUeXBlcy5DaGFsbGVuZ2UgPSBudWxsO1xuXG5leHBvcnQgZnVuY3Rpb24gc2V0UmVwZWF0ZWQodGY6IGJvb2xlYW4pOiB2b2lkIHtcbiAgaXNSZXBlYXRlZCA9IHRmO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gc2V0UGFjZVJlcGVhdCh0ZjogYm9vbGVhbik6IHZvaWQge1xuICBpc1BhY2VSZXBlYXQgPSB0Zjtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHNldEFjdGl2ZUNoYWxsZW5nZSh2YWw6IG51bGwgfCBNb25rZXlUeXBlcy5DaGFsbGVuZ2UpOiB2b2lkIHtcbiAgYWN0aXZlQ2hhbGxlbmdlID0gdmFsO1xufVxuIl19

package/esm2022/lib/helpers/test/test-stats.mjs

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

package/esm2022/lib/helpers/test/test-timer.mjs

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