@quesmed/types-rn 2.4.4 → 2.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quesmed/types-rn",
-  "version": "2.4.4",
+  "version": "2.4.6",
   "description": "Typescript types for Quesmed",
   "keywords": [
     "quesmed",
@@ -23,7 +23,9 @@
     "@apollo/client": "^3.5.7",
     "@react-native-async-storage/async-storage": "^1.15.16",
     "@types/react-native": "^0.64",
+    "decimal.js": "^10.4.3",
     "localforage": "^1.10.0",
+    "luxon": "^3.2.1",
     "react-native": "0.64.0",
     "react-native-expo-image-cache": "^4.1.0"
   },

package/utils/index.d.ts

@@ -2,6 +2,7 @@ export * from './commonFunctions';
 export * from './lightgallery';
 export * from './offlineLink';
 export * from './random';
+export * from './supermemo';
 export * from './webSocketLink';
 export * from './wordsToNumber';
 import uuid from './uuid4';

package/utils/index.js

@@ -18,6 +18,7 @@ __exportStar(require("./commonFunctions"), exports);
 __exportStar(require("./lightgallery"), exports);
 __exportStar(require("./offlineLink"), exports);
 __exportStar(require("./random"), exports);
+__exportStar(require("./supermemo"), exports);
 __exportStar(require("./webSocketLink"), exports);
 __exportStar(require("./wordsToNumber"), exports);
 const uuid4_1 = __importDefault(require("./uuid4"));

package/utils/supermemo.d.ts

@@ -0,0 +1,25 @@
+import Decimal from 'decimal.js';
+import { Id, IUserCompletedCard } from '../models';
+export declare const ALGO_FRACTION: Decimal;
+export interface IScoreQuesCardInput {
+    cardId: number;
+    score: number;
+    timeTaken: number;
+}
+export interface IScoreQuesCardVar {
+    input: IScoreQuesCardInput;
+    completedCard: IUserCompletedCard;
+    userId: Id;
+}
+export interface IScoreQuesCardData {
+    cardId: Id;
+    userId: Id;
+    lastSeen: Date;
+    reviewDate: Date;
+    score: number;
+    iteration: number;
+    optimalFactor: number;
+}
+export declare function scoreQuesCard({ input, completedCard, userId, }: IScoreQuesCardVar): IScoreQuesCardData;
+export declare function supermemo(EF: number, quality: number): number;
+export declare function calcOptimalFactor(iteration: number, quality: number, prevOF: number): number;

package/utils/supermemo.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcOptimalFactor = exports.supermemo = exports.scoreQuesCard = exports.ALGO_FRACTION = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const luxon_1 = require("luxon");
+exports.ALGO_FRACTION = new decimal_js_1.default(0.5);
+function scoreQuesCard({ input, completedCard, userId, }) {
+    const lastSeen = luxon_1.DateTime.now();
+    let prevScore = 2.5;
+    let iteration = 1;
+    let optimalFactor = 2;
+    if (completedCard) {
+        prevScore = completedCard.score;
+        if (input.score >= 3) {
+            iteration = completedCard.iteration + 1;
+        }
+        else {
+            iteration = 1;
+        }
+        optimalFactor = calcOptimalFactor(iteration, input.score, completedCard.optimalFactor);
+    }
+    const EF = supermemo(prevScore, input.score);
+    let reviewDate = lastSeen.plus({ days: 1 });
+    if (optimalFactor !== 2) {
+        let daysToReview = 1;
+        if (iteration > 1) {
+            daysToReview = optimalFactor * (iteration - 1) * EF;
+        }
+        reviewDate = lastSeen.plus({ days: daysToReview });
+    }
+    return {
+        score: EF,
+        iteration,
+        lastSeen: lastSeen.toJSDate(),
+        cardId: input.cardId,
+        userId,
+        optimalFactor,
+        reviewDate: reviewDate.toJSDate(),
+    };
+}
+exports.scoreQuesCard = scoreQuesCard;
+function supermemo(EF, quality) {
+    // EF':=EF-0.8+0.28*q-0.02*q*q
+    // EF':=EF+(0.1-(5-q)*(0.08+(5-q)*0.02))
+    const qFactor = new decimal_js_1.default(5 - quality);
+    let newEF = new decimal_js_1.default(EF).plus(new decimal_js_1.default(0.1)
+        .minus(qFactor)
+        .mul(new decimal_js_1.default(0.08).plus(qFactor).mul(new decimal_js_1.default(0.02))));
+    if (newEF.lessThan(1.3)) {
+        newEF = new decimal_js_1.default(1.3);
+    }
+    else if (newEF.greaterThan(2.5)) {
+        newEF = new decimal_js_1.default(2.5);
+    }
+    return newEF.toNearest(0.01).toNumber();
+}
+exports.supermemo = supermemo;
+function calcOptimalFactor(iteration, quality, prevOF) {
+    const iter = new decimal_js_1.default(iteration);
+    const q = new decimal_js_1.default(quality);
+    const pOF = new decimal_js_1.default(prevOF);
+    const one = new decimal_js_1.default(1);
+    let modifier = new decimal_js_1.default(0);
+    let mod5 = iter.plus(one).div(iter);
+    const one_05 = new decimal_js_1.default(1.05);
+    if (mod5.lessThan(one_05)) {
+        mod5 = one_05;
+    }
+    let mod2 = iter.minus(one).div(iter);
+    const zero_75 = new decimal_js_1.default(0.75);
+    if (mod2.greaterThan(zero_75)) {
+        mod2 = zero_75;
+    }
+    const four = new decimal_js_1.default(4);
+    if (q.greaterThan(four)) {
+        modifier = one.plus(mod5.minus(one).mul(q.minus(four)));
+    }
+    else {
+        modifier = one.minus(one.minus(mod2).div(new decimal_js_1.default(2)).mul(four.minus(q)));
+    }
+    if (modifier.lessThan(0.05)) {
+        modifier = new decimal_js_1.default(0.05);
+    }
+    let usedOF = four;
+    if (!iter.eq(1)) {
+        const tmp = pOF.mul(new decimal_js_1.default(0.72).plus(q).mul(new decimal_js_1.default(0.07)));
+        usedOF = pOF
+            .mul(new decimal_js_1.default(1).minus(exports.ALGO_FRACTION))
+            .plus(exports.ALGO_FRACTION.mul(tmp));
+    }
+    let newOF = usedOF.mul(modifier);
+    if (q.greaterThan(four)) {
+        if (newOF.lessThan(pOF)) {
+            newOF = pOF;
+        }
+    }
+    else if (q.lessThan(four)) {
+        if (newOF.greaterThan(pOF)) {
+            newOF = pOF;
+        }
+    }
+    newOF = newOF.mul(exports.ALGO_FRACTION).plus(pOF.mul(one.minus(exports.ALGO_FRACTION)));
+    const one_2 = new decimal_js_1.default(1.2);
+    if (newOF.lessThan(one_2)) {
+        newOF = one_2;
+    }
+    return newOF.toNearest(0.01).toNumber();
+}
+exports.calcOptimalFactor = calcOptimalFactor;