impr(polyglot): Remove slices.

Add IWordset.
Replace Wordset on IWordset in PolyglotWordset.
Change signature of PolyglotWordset constructor. (@IliyaZinoviev)

Author: IliyaZinoviev

frontend/src/ts/test/funbox/funbox-functions.ts

@@ -1,4 +1,9 @@
-import { FunboxWordsFrequency, WordsetPick, Wordset } from "../wordset";
+import {
+  FunboxWordsFrequency,
+  WordsetPick,
+  Wordset,
+  IWordset,
+} from "../wordset";
 import * as GetText from "../../utils/generate";
 import { Config } from "../../config/store";
 import { setConfig, toggleFunbox } from "../../config/setters";
@@ -30,9 +35,9 @@ import { Language, LanguageObject } from "@monkeytype/schemas/languages";
 import { qs } from "../../utils/dom";
 
 export type FunboxFunctions = {
-  getWord?: (wordset?: Wordset, wordIndex?: number) => string;
+  getWord?: (wordset?: IWordset, wordIndex?: number) => string;
   punctuateWord?: (word: string) => string;
-  withWords?: (words?: string[]) => Promise<Wordset | PolyglotWordset>;
+  withWords?: (words?: string[]) => Promise<IWordset>;
   alterText?: (word: string, wordIndex: number, wordsBound: number) => string;
   applyConfig?: () => void;
   applyGlobalCSS?: () => void;
@@ -149,25 +154,34 @@ class PseudolangWordGenerator extends Wordset {
   }
 }
 
-export class PolyglotWordset extends Wordset {
+export class PolyglotWordset implements IWordset {
   readonly wordsetMap: Map<Language, Wordset>;
   readonly languageProperties: Map<Language, JSONData.LanguageProperties>;
   readonly langs: Language[];
-
-  constructor(
-    words: string[],
-    wordsetMap: Map<Language, Wordset>,
-    languageProperties: Map<Language, JSONData.LanguageProperties>,
-  ) {
-    super(words);
-    this.languageProperties = languageProperties;
-    this.langs = Array.from(languageProperties.keys());
-    this.wordsetMap = wordsetMap;
+  length: number;
+
+  constructor(languages: LanguageObject[]) {
+    this.languageProperties = new Map<Language, JSONData.LanguageProperties>();
+    this.wordsetMap = new Map<Language, Wordset>();
+    this.length = 0;
+    this.langs = [];
+
+    for (const lang of languages) {
+      const count = lang.words.length;
+      this.length += count;
+      this.langs.push(lang.name);
+      this.languageProperties.set(lang.name, {
+        noLazyMode: lang.noLazyMode,
+        ligatures: lang.ligatures,
+        rightToLeft: lang.rightToLeft,
+        additionalAccents: lang.additionalAccents,
+      });
+      this.wordsetMap.set(lang.name, new Wordset(lang.words));
+    }
     this.resetIndexes();
-    this.length = words.length;
   }
 
-  override resetIndexes(): void {
+  resetIndexes(): void {
     this.wordsetMap.forEach((ws) => {
       ws.resetIndexes();
     });
@@ -183,20 +197,36 @@ export class PolyglotWordset extends Wordset {
     return { wordset: this.wordsetMap.get(language) as Wordset, language };
   }
 
-  override randomWord(mode: FunboxWordsFrequency): WordsetPick {
+  randomWord(mode: FunboxWordsFrequency): WordsetPick {
     const { wordset, language } = this.getWordsetAndLang();
     return { word: wordset.randomWord(mode).word, language };
   }
 
-  override shuffledWord(): WordsetPick {
+  shuffledWord(): WordsetPick {
     const { wordset, language } = this.getWordsetAndLang();
     return { word: wordset.shuffledWord().word, language };
   }
 
-  override nextWord(): WordsetPick {
+  nextWord(): WordsetPick {
     const { wordset, language } = this.getWordsetAndLang();
     return { word: wordset.nextWord().word, language };
   }
+
+  hasLigatures(): boolean {
+    for (const props of this.languageProperties.values()) {
+      if (props.ligatures) return true;
+    }
+    return false;
+  }
+
+  hasChar(char: string): boolean {
+    for (const wordset of this.wordsetMap.values()) {
+      if (wordset.hasChar(char)) {
+        return true;
+      }
+    }
+    return false;
+  }
 }
 
 const list: Partial<Record<FunboxName, FunboxFunctions>> = {
@@ -580,9 +610,9 @@ const list: Partial<Record<FunboxName, FunboxFunctions>> = {
     },
   },
   weakspot: {
-    getWord(wordset?: Wordset): string {
+    getWord(wordset?: IWordset): string {
       if (wordset !== undefined) return WeakSpot.getWord(wordset);
-      else return "";
+      return "";
     },
   },
   pseudolang: {
@@ -713,7 +743,7 @@ const list: Partial<Record<FunboxName, FunboxFunctions>> = {
     },
   },
   polyglot: {
-    async withWords(_words) {
+    async withWords(_words): Promise<PolyglotWordset> {
       const promises = Config.customPolyglot.map(async (language) =>
         JSONData.getLanguage(language).catch(() => {
           showNoticeNotification(
@@ -772,30 +802,7 @@ const list: Partial<Record<FunboxName, FunboxFunctions>> = {
         throw new WordGenError("");
       }
 
-      // build languageProperties
-      const languageProperties: Map<Language, JSONData.LanguageProperties> =
-        new Map(
-          languages.map((lang) => [
-            lang.name,
-            {
-              noLazyMode: lang.noLazyMode,
-              ligatures: lang.ligatures,
-              rightToLeft: lang.rightToLeft,
-              additionalAccents: lang.additionalAccents,
-            },
-          ]),
-        );
-      // build wordsetMap and words
-      const wordsetMap = new Map<Language, Wordset>();
-      let end = 0;
-      const words: string[] = [];
-      for (const lang of languages) {
-        const start = end;
-        end += lang.words.length;
-        words.push(...lang.words);
-        wordsetMap.set(lang.name, new Wordset(words.slice(start, end)));
-      }
-      return new PolyglotWordset(words, wordsetMap, languageProperties);
+      return new PolyglotWordset(languages);
     },
   },
 };

frontend/src/ts/test/weak-spot.ts

@@ -1,5 +1,5 @@
 import * as TestInput from "./test-input";
-import { Wordset } from "./wordset";
+import { IWordset } from "./wordset";
 
 // Changes how quickly it 'learns' scores - very roughly the score for a char
 // is based on last perCharCount occurrences. Make it smaller to adjust faster.
@@ -59,7 +59,7 @@ function score(word: string): number {
   return numChars === 0 ? 0.0 : total / numChars;
 }
 
-export function getWord(wordset: Wordset): string {
+export function getWord(wordset: IWordset): string {
   let highScore;
   let randomWord = "";
   for (let i = 0; i < wordSamples; i++) {

frontend/src/ts/test/words-generator.ts

@@ -1,7 +1,7 @@
 import { Config } from "../config/store";
 import { setConfig, setQuoteLengthAll, toggleFunbox } from "../config/setters";
 import * as CustomText from "./custom-text";
-import { Wordset, FunboxWordsFrequency, withWords } from "./wordset";
+import { IWordset, Wordset, FunboxWordsFrequency, withWords } from "./wordset";
 import QuotesController, {
   Quote,
   QuoteWithTextSplit,
@@ -348,7 +348,7 @@ async function getFunboxSection(): Promise<string[]> {
 function getFunboxWord(
   word: string,
   wordIndex: number,
-  wordset?: Wordset,
+  wordset?: IWordset,
 ): string {
   const funbox = findSingleActiveFunboxWithFunction("getWord");
 
@@ -495,8 +495,10 @@ async function getQuoteWordList(
   wordOrder?: FunboxWordOrder,
 ): Promise<string[]> {
   if (TestState.isRepeated) {
-    if (currentWordset === null) {
-      throw new WordGenError("Current wordset is null");
+    if (currentWordset === null || !(currentWordset instanceof Wordset)) {
+      throw new WordGenError(
+        "Current wordset is null or not instance of Wordset",
+      );
     }
 
     TestWords.setCurrentQuote(previousRandomQuote);
@@ -587,7 +589,7 @@ async function getQuoteWordList(
   return TestWords.currentQuote.textSplit;
 }
 
-let currentWordset: Wordset | null = null;
+let currentWordset: IWordset | null = null;
 let currentLanguage: LanguageObject | null = null;
 let isCurrentlyUsingFunboxSection = false;
 
@@ -655,9 +657,7 @@ export async function generateWords(
     // PolyglotWordset if polyglot otherwise Wordset
     if (currentWordset instanceof PolyglotWordset) {
       // set allLigatures if any language in languageProperties has ligatures true
-      ret.allLigatures = Array.from(
-        currentWordset.languageProperties.values(),
-      ).some((props) => !!props.ligatures);
+      ret.allLigatures = currentWordset.hasLigatures();
     }
   } else {
     currentWordset = await withWords(wordList);
@@ -704,12 +704,13 @@ export async function generateWords(
 
   ret.hasTab =
     ret.words.some((w) => w.includes("\t")) ||
-    currentWordset.words.some((w) => w.includes("\t")) ||
+    currentWordset.hasChar("\t") ||
     (Config.mode === "quote" &&
       (quote as QuoteWithTextSplit).textSplit.some((w) => w.includes("\t")));
+
   ret.hasNewline =
     ret.words.some((w) => w.includes("\n")) ||
-    currentWordset.words.some((w) => w.includes("\n")) ||
+    currentWordset.hasChar("\n") ||
     (Config.mode === "quote" &&
       (quote as QuoteWithTextSplit).textSplit.some((w) => w.includes("\n")));
 

frontend/src/ts/test/wordset.ts

@@ -8,7 +8,16 @@ export type WordsetPick = { word: string; language?: Language };
 
 let currentWordset: Wordset | null = null;
 
-export class Wordset {
+export type IWordset = {
+  length: number;
+  resetIndexes(): void;
+  randomWord(mode: FunboxWordsFrequency): WordsetPick;
+  shuffledWord(): WordsetPick;
+  nextWord(): WordsetPick;
+  hasChar(char: string): boolean;
+};
+
+export class Wordset implements IWordset {
   words: string[];
   length: number;
   orderedIndex: number;
@@ -59,6 +68,10 @@ export class Wordset {
     }
     return { word: this.words[this.orderedIndex++] as string };
   }
+
+  hasChar(char: string): boolean {
+    return this.words.some((w) => w.includes(char));
+  }
 }
 
 export async function withWords(words: string[]): Promise<Wordset> {