[pull] master from monkeytypegame:master

frontend/src/ts/constants/languages.ts

@@ -188,7 +188,12 @@ export const LanguageGroups: Record<string, Language[]> = {
   swahili: ["swahili_1k"],
   maori: ["maori_1k"],
   catalan: ["catalan", "catalan_1k"],
-  bulgarian: ["bulgarian", "bulgarian_latin"],
+  bulgarian: [
+    "bulgarian",
+    "bulgarian_1k",
+    "bulgarian_latin",
+    "bulgarian_latin_1k",
+  ],
   bosnian: ["bosnian", "bosnian_4k"],
   esperanto: [
     "esperanto",

frontend/src/ts/elements/scroll-to-top.ts

@@ -1,27 +1,30 @@
 import * as ActivePage from "../states/active-page";
 import { prefersReducedMotion } from "../utils/misc";
+import { qsr } from "../utils/dom";
 
 let visible = false;
 
+const button = qsr(".scrollToTopButton");
+
 export function hide(): void {
-  $(".scrollToTopButton").addClass("invisible");
+  button.addClass("invisible");
   visible = false;
 }
 
 function show(): void {
-  $(".scrollToTopButton").removeClass("invisible");
+  button.removeClass("invisible");
   visible = true;
 }
 
-$(document).on("click", ".scrollToTopButton", () => {
-  $(".scrollToTopButton").addClass("invisible");
+button.on("click", () => {
+  button.addClass("invisible");
   window.scrollTo({
     top: 0,
     behavior: prefersReducedMotion() ? "instant" : "smooth",
   });
 });
 
-$(window).on("scroll", () => {
+window.addEventListener("scroll", () => {
   const page = ActivePage.get();
   if (page === "test") return;
 

frontend/src/ts/states/remember-lazy-mode.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { LocalStorageWithSchema } from "../utils/local-storage-with-schema";
+
+const rememberLazyModeLS = new LocalStorageWithSchema({
+  key: "rememberLazyMode",
+  schema: z.boolean(),
+  fallback: false,
+});
+
+const arabicLazyModeLS = new LocalStorageWithSchema({
+  key: "prefersArabicLazyMode",
+  schema: z.boolean(),
+  fallback: true,
+});
+
+export function getRemember(): boolean {
+  return rememberLazyModeLS.get();
+}
+
+export function setRemember(value: boolean): void {
+  rememberLazyModeLS.set(value);
+}
+
+export function getArabicPref(): boolean {
+  return arabicLazyModeLS.get();
+}
+
+export function setArabicPref(value: boolean): void {
+  arabicLazyModeLS.set(value);
+}

frontend/src/ts/states/time.ts

@@ -4,8 +4,8 @@ export function get(): number {
   return time;
 }
 
-export function set(active: number): void {
-  time = active;
+export function set(number: number): void {
+  time = number;
 }
 
 export function increment(): void {

frontend/src/ts/test/test-logic.ts

@@ -39,7 +39,7 @@ import * as AnalyticsController from "../controllers/analytics-controller";
 import { getAuthenticatedUser, isAuthenticated } from "../firebase";
 import * as ConnectionState from "../states/connection";
 import * as KeymapEvent from "../observables/keymap-event";
-import * as ArabicLazyMode from "../states/arabic-lazy-mode";
+import * as LazyModeState from "../states/remember-lazy-mode";
 import Format from "../utils/format";
 import { QuoteLength, QuoteLengthConfig } from "@monkeytype/schemas/configs";
 import { Mode } from "@monkeytype/schemas/shared";
@@ -68,6 +68,7 @@ import { canQuickRestart } from "../utils/quick-restart";
 import { animate } from "animejs";
 import { setInputElementValue } from "../input/input-element";
 import { debounce } from "throttle-debounce";
+import * as Time from "../states/time";
 
 let failReason = "";
 
@@ -100,6 +101,7 @@ export function startTest(now: number): boolean {
   Replay.startReplayRecording();
   Replay.replayGetWordsList(TestWords.words.list);
   TestInput.resetKeypressTimings();
+  Time.set(0);
   TestTimer.clear();
 
   for (const fb of getActiveFunboxesWithFunction("start")) {
@@ -342,7 +344,6 @@ export function restart(options = {} as RestartOptions): void {
 }
 
 let lastInitError: Error | null = null;
-let rememberLazyMode: boolean;
 let showedLazyModeNotification: boolean = false;
 let testReinitCount = 0;
 
@@ -421,39 +422,43 @@ async function init(): Promise<boolean> {
       .some((lang) => !lang.noLazyMode);
 
     if (Config.lazyMode && !anySupportsLazyMode) {
-      rememberLazyMode = true;
-      Notifications.add(
-        "None of the selected polyglot languages support lazy mode.",
-        0,
-        {
-          important: true,
-        },
-      );
+      LazyModeState.setRemember(true);
+      if (!showedLazyModeNotification) {
+        Notifications.add(
+          "None of the selected polyglot languages support lazy mode.",
+          0,
+          {
+            important: true,
+          },
+        );
+        showedLazyModeNotification = true;
+      }
       setConfig("lazyMode", false);
-    } else if (rememberLazyMode && anySupportsLazyMode) {
-      setConfig("lazyMode", true, {
-        nosave: true,
-      });
+    } else if (LazyModeState.getRemember() && anySupportsLazyMode) {
+      setConfig("lazyMode", true);
+      LazyModeState.setRemember(false);
+      showedLazyModeNotification = false;
     }
   } else {
     // normal mode
     if (Config.lazyMode && !allowLazyMode) {
-      rememberLazyMode = true;
-      showedLazyModeNotification = true;
-      Notifications.add("This language does not support lazy mode.", 0, {
-        important: true,
-      });
-
+      LazyModeState.setRemember(true);
+      if (!showedLazyModeNotification) {
+        Notifications.add("This language does not support lazy mode.", 0, {
+          important: true,
+        });
+        showedLazyModeNotification = true;
+      }
       setConfig("lazyMode", false);
-    } else if (rememberLazyMode && !language.noLazyMode) {
-      setConfig("lazyMode", true, {
-        nosave: true,
-      });
+    } else if (LazyModeState.getRemember() && allowLazyMode) {
+      setConfig("lazyMode", true);
+      LazyModeState.setRemember(false);
+      showedLazyModeNotification = false;
     }
   }
 
   if (!Config.lazyMode && !language.noLazyMode) {
-    rememberLazyMode = false;
+    LazyModeState.setRemember(false);
   }
 
   if (Config.mode === "custom") {
@@ -1549,7 +1554,10 @@ ConfigEvent.subscribe(({ key, newValue, nosave }) => {
   if (ActivePage.get() === "test") {
     if (key === "language") {
       //automatically enable lazy mode for arabic
-      if ((newValue as string)?.startsWith("arabic") && ArabicLazyMode.get()) {
+      if (
+        (newValue as string)?.startsWith("arabic") &&
+        LazyModeState.getArabicPref()
+      ) {
         setConfig("lazyMode", true, {
           nosave: true,
         });
@@ -1582,13 +1590,7 @@ ConfigEvent.subscribe(({ key, newValue, nosave }) => {
   }
   if (key === "lazyMode" && !nosave) {
     if (Config.language.startsWith("arabic")) {
-      ArabicLazyMode.set(newValue);
-    }
-    if (newValue) {
-      if (!showedLazyModeNotification) {
-        rememberLazyMode = false;
-      }
-      showedLazyModeNotification = false;
+      LazyModeState.setArabicPref(newValue);
     }
   }
 });

frontend/src/ts/test/test-timer.ts

@@ -62,7 +62,6 @@ export function enableTimerDebug(): void {
 
 export function clear(): void {
   clearLowFpsMode();
-  Time.set(0);
   newTimer.reset();
   if (timer !== null) clearTimeout(timer);
 }

frontend/src/ts/utils/caret.ts

@@ -450,6 +450,9 @@ export class Caret {
     let left = 0;
     let top = 0;
 
+    const tapeOffset =
+      wordsWrapperCache.getOffsetWidth() * (Config.tapeMargin / 100);
+
     // yes, this is all super verbose, but its easier to maintain and understand
     if (isWordRTL) {
       let afterLetterCorrection = 0;
@@ -475,8 +478,7 @@ export class Caret {
         left += options.letter.getOffsetLeft();
         left += afterLetterCorrection;
         if (this.isMainCaret && lockedMainCaretInTape) {
-          left +=
-            wordsWrapperCache.getOffsetWidth() * (Config.tapeMargin / 100);
+          left += wordsWrapperCache.getOffsetWidth() - tapeOffset;
         } else {
           left += options.word.getOffsetLeft();
           left += options.word.getOffsetWidth();
@@ -486,8 +488,7 @@ export class Caret {
           left += width * -1;
         }
         if (this.isMainCaret && lockedMainCaretInTape) {
-          left +=
-            wordsWrapperCache.getOffsetWidth() * (Config.tapeMargin / 100);
+          left += wordsWrapperCache.getOffsetWidth() - tapeOffset;
         } else {
           left += options.letter.getOffsetLeft();
           left += options.word.getOffsetLeft();
@@ -508,15 +509,13 @@ export class Caret {
         left += options.letter.getOffsetLeft();
         left += afterLetterCorrection;
         if (this.isMainCaret && lockedMainCaretInTape) {
-          left +=
-            wordsWrapperCache.getOffsetWidth() * (Config.tapeMargin / 100);
+          left += tapeOffset;
         } else {
           left += options.word.getOffsetLeft();
         }
       } else if (Config.tapeMode === "letter") {
         if (this.isMainCaret && lockedMainCaretInTape) {
-          left +=
-            wordsWrapperCache.getOffsetWidth() * (Config.tapeMargin / 100);
+          left += tapeOffset;
         } else {
           left += options.letter.getOffsetLeft();
           left += options.word.getOffsetLeft();

frontend/static/languages/bulgarian.json

@@ -1,5 +1,9 @@
 {
   "name": "bulgarian",
+  "rightToLeft": false,
+  "ligatures": false,
+  "orderedByFrequency": false,
+  "bcp47": "bg",
   "noLazyMode": true,
   "words": [
     "а",