only_ever_generator 8.4.6 → 8.4.8

package/src/parse/parse_card/parse_cloze_card.ts

@@ -1,146 +1,146 @@
-import { MongoConceptFactCards } from "../../types/mongo_concept_fact_type";
-import { RawClozeCardResponseType } from "../../types/raw_card_response_types/generated_card_response_type";
-
-export class ParseClozeCard {
-  parse(data: {
-    card_content: RawClozeCardResponseType;
-    type: string;
-    concepts_facts: MongoConceptFactCards[];
-    bloom_level: number;
-    explanation: string;
-  }) {
-    try {
-      const content = data.card_content;
-      let correctOptions = content.correct_options;
-      let incorrectOptions = content.incorrect_options;
-      let allOptions = [...correctOptions, ...incorrectOptions];
-      let displayTitle = this._generateClozeCardDisplayTitle(
-        data.card_content.prompt,
-        allOptions
-      );
-      let preparedData = this._prepareQuestionAndCorrectAnswers(
-        content.prompt,
-        correctOptions
-      );
-      let finalQuestion = preparedData.prompt;
-      let parsedCorrectOptions = preparedData.options;
-      let parsedIncorrectoptions = incorrectOptions.map((e: any) => {
-        return {
-          option: e,
-          cloze: "null",
-        };
-      });
-      const finalParsedOptions = [
-        ...parsedCorrectOptions,
-        ...parsedIncorrectoptions,
-      ];
-      let clozeCardData = {
-        type: {
-          category: "learning",
-          sub_type: data.type,
-        },
-        heading: "",
-        displayTitle: displayTitle,
-        content: {
-          question: finalQuestion,
-          options: finalParsedOptions,
-        },
-        concepts_facts: data.concepts_facts,
-        bloom_level: data.bloom_level,
-        explanation: data.explanation,
-      };
-
-      return this._validateCloze(clozeCardData);
-      // return clozeCardData;
-    } catch (e) {
-      return null;
-    }
-  }
-
-  _generateClozeCardDisplayTitle(question: string, answers: Array<any>) {
-    try {
-      let optionsString = "";
-      if (answers.length !== 0) {
-        optionsString = answers.join(", ");
-      }
-
-      return `${question} ---- ${optionsString}`;
-    } catch (e) {
-      throw Error("Error in generating display title");
-    }
-  }
-
-  /// validate the cloze card
-  // 1. Has Empty cloze
-  // 2. has Duplicate Clozes
-  // 3. doesnt have any valid option,
-  // 4. Question length 320
-  // 5. More than 6 options
-  // 6. Less than 2 options
-  // 7. Max character for individual cloze: 90
-
-  _prepareQuestionAndCorrectAnswers(
-    rawPrompt: String,
-    correctOptions: Array<any>
-  ) {
-    try {
-      var finalCorrectOptions = <any>[];
-      const regex = /{{(.*?)}}/g;
-
-      const transformed = rawPrompt.replace(regex, (match, p1) => {
-        // p1 is the captured group inside {{ }} (e.g., "fruit", "green")
-        const idx = correctOptions.indexOf(p1);
-        if (idx !== -1) {
-          let cloze = `c${idx}`;
-          finalCorrectOptions.push({
-            option: p1,
-            cloze: cloze,
-          });
-          return `{{c${idx}:${p1}}}`;
-        }
-        return match; // If not found in correct_options, leave as is or handle accordingly
-      });
-      return {
-        prompt: transformed,
-        options: finalCorrectOptions,
-      };
-    } catch (e) {
-      throw Error("Error in preparing question and correct answers");
-    }
-  }
-
-  _validateCloze(clozeCard: any) {
-    let clozeRegex = /\{\{c(\d+):([^}]+)\}\}/g;
-
-    try {
-      /// validate emptu cloze
-      let options = clozeCard.content.options ?? [];
-      let question = clozeCard.content.question;
-      if (options.length < 2 || options.length > 6) {
-        throw Error("Number of cloze options are invalid");
-      }
-
-      /// There are no correct clozes// or null cloze or empty cloze
-      let correctOptions = options.find(
-        (e: any) => e.cloze != "null" && e.cloze != null && e.cloze.trim() != ""
-      );
-      if (correctOptions) {
-      } else {
-        throw Error(" No valid clozes exists");
-      }
-
-      let rightClozes = options.filter((e: any) => e.cloze.startsWith("c"));
-
-      /// matches our cloze syntax
-      let clozeMatches = [...question.matchAll(clozeRegex)];
-      if (clozeMatches.length == 0) {
-        throw Error("Question Invalid");
-      } else if (clozeMatches.length != rightClozes.length) {
-        throw Error(" Clozes in question doesnt match to clozes in options");
-      }
-      return clozeCard;
-    } catch (e: any) {
-      throw Error(`Error in validating cloze card ${e.message}`);
-    }
-  }
-}
+import { MongoConceptFactCards } from "../../types/mongo_concept_fact_type";
+import { RawClozeCardResponseType } from "../../types/raw_card_response_types/generated_card_response_type";
+
+export class ParseClozeCard {
+  parse(data: {
+    card_content: RawClozeCardResponseType;
+    type: string;
+    concepts_facts: MongoConceptFactCards[];
+    bloom_level: number;
+    explanation: string;
+  }) {
+    try {
+      const content = data.card_content;
+      let correctOptions = content.correct_options;
+      let incorrectOptions = content.incorrect_options;
+      let allOptions = [...correctOptions, ...incorrectOptions];
+      let displayTitle = this._generateClozeCardDisplayTitle(
+        data.card_content.prompt,
+        allOptions
+      );
+      let preparedData = this._prepareQuestionAndCorrectAnswers(
+        content.prompt,
+        correctOptions
+      );
+      let finalQuestion = preparedData.prompt;
+      let parsedCorrectOptions = preparedData.options;
+      let parsedIncorrectoptions = incorrectOptions.map((e: any) => {
+        return {
+          option: e,
+          cloze: "null",
+        };
+      });
+      const finalParsedOptions = [
+        ...parsedCorrectOptions,
+        ...parsedIncorrectoptions,
+      ];
+      let clozeCardData = {
+        type: {
+          category: "learning",
+          sub_type: data.type,
+        },
+        heading: "",
+        displayTitle: displayTitle,
+        content: {
+          question: finalQuestion,
+          options: finalParsedOptions,
+        },
+        concepts_facts: data.concepts_facts,
+        bloom_level: data.bloom_level,
+        explanation: data.explanation,
+      };
+
+      return this._validateCloze(clozeCardData);
+      // return clozeCardData;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  _generateClozeCardDisplayTitle(question: string, answers: Array<any>) {
+    try {
+      let optionsString = "";
+      if (answers.length !== 0) {
+        optionsString = answers.join(", ");
+      }
+
+      return `${question} ---- ${optionsString}`;
+    } catch (e) {
+      throw Error("Error in generating display title");
+    }
+  }
+
+  /// validate the cloze card
+  // 1. Has Empty cloze
+  // 2. has Duplicate Clozes
+  // 3. doesnt have any valid option,
+  // 4. Question length 320
+  // 5. More than 6 options
+  // 6. Less than 2 options
+  // 7. Max character for individual cloze: 90
+
+  _prepareQuestionAndCorrectAnswers(
+    rawPrompt: String,
+    correctOptions: Array<any>
+  ) {
+    try {
+      var finalCorrectOptions = <any>[];
+      const regex = /{{(.*?)}}/g;
+
+      const transformed = rawPrompt.replace(regex, (match, p1) => {
+        // p1 is the captured group inside {{ }} (e.g., "fruit", "green")
+        const idx = correctOptions.indexOf(p1);
+        if (idx !== -1) {
+          let cloze = `c${idx}`;
+          finalCorrectOptions.push({
+            option: p1,
+            cloze: cloze,
+          });
+          return `{{c${idx}:${p1}}}`;
+        }
+        return match; // If not found in correct_options, leave as is or handle accordingly
+      });
+      return {
+        prompt: transformed,
+        options: finalCorrectOptions,
+      };
+    } catch (e) {
+      throw Error("Error in preparing question and correct answers");
+    }
+  }
+
+  _validateCloze(clozeCard: any) {
+    let clozeRegex = /\{\{c(\d+):([^}]+)\}\}/g;
+
+    try {
+      /// validate emptu cloze
+      let options = clozeCard.content.options ?? [];
+      let question = clozeCard.content.question;
+      if (options.length < 2 || options.length > 6) {
+        throw Error("Number of cloze options are invalid");
+      }
+
+      /// There are no correct clozes// or null cloze or empty cloze
+      let correctOptions = options.find(
+        (e: any) => e.cloze != "null" && e.cloze != null && e.cloze.trim() != ""
+      );
+      if (correctOptions) {
+      } else {
+        throw Error(" No valid clozes exists");
+      }
+
+      let rightClozes = options.filter((e: any) => e.cloze.startsWith("c"));
+
+      /// matches our cloze syntax
+      let clozeMatches = [...question.matchAll(clozeRegex)];
+      if (clozeMatches.length == 0) {
+        throw Error("Question Invalid");
+      } else if (clozeMatches.length != rightClozes.length) {
+        throw Error(" Clozes in question doesnt match to clozes in options");
+      }
+      return clozeCard;
+    } catch (e: any) {
+      throw Error(`Error in validating cloze card ${e.message}`);
+    }
+  }
+}

package/src/parse/parse_card/parse_flash_cards.ts

@@ -1,42 +1,42 @@
-import { MongoConceptFactCards } from "../../types/mongo_concept_fact_type";
-import { RawFlashCardResponseType } from "../../types/raw_card_response_types/generated_card_response_type";
-
-export class ParseFlashCard {
-  parse(data: {
-    card_content: RawFlashCardResponseType;
-    type: string;
-    concepts_facts: MongoConceptFactCards[];
-    bloom_level: number;
-    explanation: string;
-  }) {
-    try {
-      let displayTitle = this.generateFlashCardDisplayTitle(
-        data.card_content.front,
-        data.card_content.back
-      );
-      let flashCardData = {
-        type: {
-          category: "learning",
-          sub_type: "flash",
-        },
-        heading: "",
-        displayTitle: displayTitle,
-        content: {
-          front_content: data.card_content.front,
-          back_content: data.card_content.back,
-        },
-        concepts_facts: data.concepts_facts,
-        explanation: data.explanation,
-        bloom_level: data.bloom_level,
-      };
-
-      return flashCardData;
-    } catch (e) {
-      return null;
-    }
-  }
-
-  generateFlashCardDisplayTitle(front: string, back: string) {
-    return `${front} ---- ${back}`;
-  }
-}
+import { MongoConceptFactCards } from "../../types/mongo_concept_fact_type";
+import { RawFlashCardResponseType } from "../../types/raw_card_response_types/generated_card_response_type";
+
+export class ParseFlashCard {
+  parse(data: {
+    card_content: RawFlashCardResponseType;
+    type: string;
+    concepts_facts: MongoConceptFactCards[];
+    bloom_level: number;
+    explanation: string;
+  }) {
+    try {
+      let displayTitle = this.generateFlashCardDisplayTitle(
+        data.card_content.front,
+        data.card_content.back
+      );
+      let flashCardData = {
+        type: {
+          category: "learning",
+          sub_type: "flash",
+        },
+        heading: "",
+        displayTitle: displayTitle,
+        content: {
+          front_content: data.card_content.front,
+          back_content: data.card_content.back,
+        },
+        concepts_facts: data.concepts_facts,
+        explanation: data.explanation,
+        bloom_level: data.bloom_level,
+      };
+
+      return flashCardData;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  generateFlashCardDisplayTitle(front: string, back: string) {
+    return `${front} ---- ${back}`;
+  }
+}

package/src/parse/parse_card/parse_match_card.ts

@@ -1,104 +1,104 @@
-import { match } from "assert";
-import { RawMatchCardResponseType } from "../../types/raw_card_response_types/generated_card_response_type";
-import { MongoConceptFactCards } from "../../types/mongo_concept_fact_type";
-
-type InputItem = {
-  left_item: string;
-  right_item: string;
-};
-
-type OutputItem = {
-  left_item: string;
-  right_item: string[];
-};
-
-export class ParseMatchCard {
-  parse(cardData: {
-    card_content: RawMatchCardResponseType;
-    type: string;
-    concepts_facts: MongoConceptFactCards[];
-    bloom_level: number;
-    explanation: string;
-  }) {
-    try {
-      let content = cardData.card_content;
-      const finalContent = this._parseMatchContent(content);
-
-      let displayTitle = this._generateMatchCardDisplayTitle(content);
-      let matchCard = {
-        type: {
-          category: "learning",
-          sub_type: cardData.type,
-        },
-        heading: "",
-        content: finalContent,
-        //  content: cardData.card_content,
-        displayTitle: displayTitle,
-        concepts_facts: cardData.concepts_facts,
-        bloom_level: cardData.bloom_level,
-        explanation: cardData.explanation,
-      };
-
-      return this._validateMatch(matchCard);
-      return matchCard;
-    } catch (e) {
-      return null;
-    }
-  }
-
-  _generateMatchCardDisplayTitle(answers: any) {
-    let titles: string[] = [];
-    let counter = 65;
-    for (let data of answers) {
-      let value = data.right_item;
-      let leftData = data.left_item;
-      let letter = String.fromCharCode(counter);
-      titles.push(`${letter}. ${leftData} -- ${value}`);
-      counter++;
-    }
-    let displayTitle = titles.join(",");
-    return displayTitle;
-  }
-
-  _parseMatchContent = (input: InputItem[]): OutputItem[] => {
-    const grouped = input.reduce<Record<string, OutputItem>>(
-      (acc, { left_item, right_item }) => {
-        if (!acc[left_item]) {
-          acc[left_item] = { left_item, right_item: [] };
-        }
-        acc[left_item].right_item.push(right_item);
-        return acc;
-      },
-      {}
-    );
-
-    return Object.values(grouped);
-  };
-
-  _validateMatch(matchCard: any) {
-    let matches = matchCard.content;
-    let content = [];
-    try {
-      if (matches.length < 1 || matches.length > 4) {
-        throw Error("Invalid number of matches");
-      }
-
-      for (let elem of matches) {
-        if (
-          (elem.left_item ?? "").length != 0 &&
-          (elem.right_item ?? "").length != 0
-        ) {
-          content.push(elem);
-        }
-      }
-      if (content.length >= 2) {
-        matchCard.content = content;
-      } else {
-        throw Error("Invalid content");
-      }
-      return matchCard;
-    } catch (e) {
-      return null;
-    }
-  }
-}
+import { match } from "assert";
+import { RawMatchCardResponseType } from "../../types/raw_card_response_types/generated_card_response_type";
+import { MongoConceptFactCards } from "../../types/mongo_concept_fact_type";
+
+type InputItem = {
+  left_item: string;
+  right_item: string;
+};
+
+type OutputItem = {
+  left_item: string;
+  right_item: string[];
+};
+
+export class ParseMatchCard {
+  parse(cardData: {
+    card_content: RawMatchCardResponseType;
+    type: string;
+    concepts_facts: MongoConceptFactCards[];
+    bloom_level: number;
+    explanation: string;
+  }) {
+    try {
+      let content = cardData.card_content;
+      const finalContent = this._parseMatchContent(content);
+
+      let displayTitle = this._generateMatchCardDisplayTitle(content);
+      let matchCard = {
+        type: {
+          category: "learning",
+          sub_type: cardData.type,
+        },
+        heading: "",
+        content: finalContent,
+        //  content: cardData.card_content,
+        displayTitle: displayTitle,
+        concepts_facts: cardData.concepts_facts,
+        bloom_level: cardData.bloom_level,
+        explanation: cardData.explanation,
+      };
+
+      return this._validateMatch(matchCard);
+      return matchCard;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  _generateMatchCardDisplayTitle(answers: any) {
+    let titles: string[] = [];
+    let counter = 65;
+    for (let data of answers) {
+      let value = data.right_item;
+      let leftData = data.left_item;
+      let letter = String.fromCharCode(counter);
+      titles.push(`${letter}. ${leftData} -- ${value}`);
+      counter++;
+    }
+    let displayTitle = titles.join(",");
+    return displayTitle;
+  }
+
+  _parseMatchContent = (input: InputItem[]): OutputItem[] => {
+    const grouped = input.reduce<Record<string, OutputItem>>(
+      (acc, { left_item, right_item }) => {
+        if (!acc[left_item]) {
+          acc[left_item] = { left_item, right_item: [] };
+        }
+        acc[left_item].right_item.push(right_item);
+        return acc;
+      },
+      {}
+    );
+
+    return Object.values(grouped);
+  };
+
+  _validateMatch(matchCard: any) {
+    let matches = matchCard.content;
+    let content = [];
+    try {
+      if (matches.length < 1 || matches.length > 4) {
+        throw Error("Invalid number of matches");
+      }
+
+      for (let elem of matches) {
+        if (
+          (elem.left_item ?? "").length != 0 &&
+          (elem.right_item ?? "").length != 0
+        ) {
+          content.push(elem);
+        }
+      }
+      if (content.length >= 2) {
+        matchCard.content = content;
+      } else {
+        throw Error("Invalid content");
+      }
+      return matchCard;
+    } catch (e) {
+      return null;
+    }
+  }
+}