ts-fsrs 1.2.0 → 2.0.2

package/README.md

@@ -1,7 +1,7 @@
 # About The
 
 ts-fsrs is a TypeScript package used to implement the Free Spaced Repetition Scheduler (FSRS) algorithm. It helps
-developers apply FSRS to their flashcard applications, thereby improving the user learning experience.,
+developers apply FSRS to their flashcard applications, thereby improving the user learning experience.
 
 # Usage
 
@@ -9,34 +9,38 @@ developers apply FSRS to their flashcard applications, thereby improving the use
 npm install ts-fsrs
 ```
 
-# [Have trouble importing Day.js?](https://day.js.org/docs/en/installation/typescript#have-trouble-importing-dayjs)
-
-If your `tsconfig.json` contains the following config, you must do the default import
-workflow `import dayjs from 'dayjs'`:
-
-```
-//tsconfig.json
-{
-  "compilerOptions": {
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-  }
-}
-```
-
 # Example
 
 ```typescript
-import { generatorParameters, fsrs, createEmptyCard } from 'ts-fsrs';
-import dayjs from 'dayjs'; // or import * as dayjs from "dayjs";
-
+import {createEmptyCard, formatDate, fsrs, generatorParameters, Rating} from 'ts-fsrs';
 
 const params = generatorParameters({ enable_fuzz: true });
 const f = fsrs(params);
-const card = createEmptyCard();
-const now = dayjs();
+const card = createEmptyCard(new Date('2022-2-1 10:00:00'));// createEmptyCard();
+const now = new Date('2022-2-2 10:00:00');// new Date();
 const scheduling_cards = f.repeat(card, now);
-console.log(scheduling_cards);
+
+// console.log(scheduling_cards);
+Object.keys(Rating).filter(key => typeof Rating[key as any] === 'number').forEach(key => {
+  // @ts-ignore
+  const { log, card } = scheduling_cards[Rating[key]];
+  console.group(`${key}`);
+  console.table({
+    [`card_${key}`]: {
+      ...card,
+      due: formatDate(card.due),
+      last_review: formatDate(card.last_review),
+    },
+  });
+  console.table({
+    [`log_${key}`]: {
+      ...log,
+      review: formatDate(log.review),
+    },
+  });
+  console.groupEnd();
+  console.log('----------------------------------------------------------------');
+});
 ```
 
 > More examples refer to the [Example](https://github.com/ishiko732/ts-fsrs/blob/master/test/index.ts)

package/lib/fsrs.d.ts

@@ -1,12 +1,53 @@
-import dayjs from "dayjs";
-import { Card, FSRSParameters, SchedulingCard } from "./index";
+import { Card, FSRSParameters, Rating, SchedulingCard, State } from "./index";
+import { int } from './help';
 export default class FSRS {
     private param;
     private readonly intervalModifier;
     private seed?;
     constructor(param?: FSRSParameters);
-    repeat: (card: Card, now: dayjs.Dayjs) => import("./models").SchedulingLog;
-    get_retrievability: (card: Card, now: dayjs.Dayjs) => undefined | string;
+    repeat: (card: Card, now: Date) => {
+        0: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+        1: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+        2: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+        3: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+    };
+    get_retrievability: (card: Card, now: Date) => undefined | string;
     init_ds(s: SchedulingCard): void;
     /**
      *
@@ -33,16 +74,16 @@ export default class FSRS {
      */
     init_difficulty(g: number): number;
     apply_fuzz(ivl: number): number;
-    next_interval(s: number): number;
+    next_interval(s: number): int;
     /**
      * The formula used is :
      * $$next_d = D + w_4 \cdot (R - 2)$$
      * $$D^\prime(D,R) = w_5 \cdot D_0(2) +(1 - w_5) \cdot next_d$$
      * @param d
-     * @param r Rating[0.again,1.hard,2.good,3.easy]
+     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
      * @return next_D
      */
-    next_difficulty(d: number, r: number): number;
+    next_difficulty(d: number, g: number): number;
     /**
      * The formula used is :
      * $$\min \{\max \{D_0,1\},10\}$$

package/lib/fsrs.js

@@ -3,30 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const dayjs_1 = __importDefault(require("dayjs"));
 const seedrandom_1 = __importDefault(require("seedrandom"));
 const index_1 = require("./index");
 class FSRS {
     constructor(param) {
         this.repeat = (card, now) => {
             card = Object.assign({}, card);
-            now = now.clone();
-            card.elapsed_days = card.state === index_1.State.New ? 0 : now.diff((0, dayjs_1.default)(card.last_review), "days"); //相距时间
+            now = new Date(now.getTime());
+            card.elapsed_days = card.state === index_1.State.New ? 0 : now.diff(card.last_review, "days"); //相距时间
             card.last_review = now; // 上次复习时间
             card.reps += 1;
             const s = new index_1.SchedulingCard(card);
             s.update_state(card.state);
-            this.seed = String(card.last_review.unix()) + String(card.elapsed_days);
+            this.seed = String(card.last_review.getTime()) + String(card.elapsed_days);
             let easy_interval, good_interval, hard_interval;
             switch (card.state) {
                 case index_1.State.New:
                     this.init_ds(s);
-                    s.again.due = now.add(1, 'minutes');
-                    s.hard.due = now.add(5, "minutes");
-                    s.good.due = now.add(10, "minutes");
+                    s.again.due = now.scheduler(1);
+                    s.hard.due = now.scheduler(5);
+                    s.good.due = now.scheduler(10);
                     easy_interval = this.next_interval(s.easy.stability * this.param.easy_bonus);
                     s.easy.scheduled_days = easy_interval;
-                    s.easy.due = now.add(easy_interval, "days");
+                    s.easy.due = now.scheduler(easy_interval, true);
                     break;
                 case index_1.State.Learning:
                 case index_1.State.Relearning:
@@ -45,7 +44,7 @@ class FSRS {
                     good_interval = this.next_interval(s.good.stability);
                     hard_interval = Math.min(hard_interval, good_interval);
                     good_interval = Math.max(good_interval, hard_interval + 1);
-                    easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.hard_factor), good_interval + 1);
+                    easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.easy_bonus), good_interval + 1);
                     s.schedule(now, hard_interval, good_interval, easy_interval);
                     break;
             }
@@ -55,7 +54,7 @@ class FSRS {
             if (card.state !== index_1.State.Review) {
                 return undefined;
             }
-            const t = Math.max(now.diff((0, dayjs_1.default)(card.last_review), "days"), 0);
+            const t = Math.max(now.diff(card.last_review, "days"), 0);
             return (this.current_retrievability(t, card.stability) * 100).toFixed(2) + '%';
         };
         this.param = param || (0, index_1.generatorParameters)();
@@ -127,11 +126,11 @@ class FSRS {
      * $$next_d = D + w_4 \cdot (R - 2)$$
      * $$D^\prime(D,R) = w_5 \cdot D_0(2) +(1 - w_5) \cdot next_d$$
      * @param d
-     * @param r Rating[0.again,1.hard,2.good,3.easy]
+     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
      * @return next_D
      */
-    next_difficulty(d, r) {
-        const next_d = d + this.param.w[4] * (r - 2);
+    next_difficulty(d, g) {
+        const next_d = d + this.param.w[4] * (g - 2);
         return this.constrain_difficulty(this.mean_reversion(this.param.w[2], next_d));
     }
     /**

package/lib/help.d.ts

@@ -0,0 +1,19 @@
+export type unit = 'days' | 'minutes';
+export type int = number & {
+    __int__: void;
+};
+export type double = number & {
+    __double__: void;
+};
+declare global {
+    export interface Date {
+        scheduler(t: int, isDay?: boolean): Date;
+        diff(pre: Date, unit: unit): int;
+        format(): string;
+        dueFormat(last_review: Date, unit?: boolean): string;
+    }
+}
+export declare function date_scheduler(now: Date, t: number, isDay?: boolean): Date;
+export declare function date_diff(now: Date, pre: Date, unit: unit): number;
+export declare function formatDate(date: Date): string;
+export declare function show_diff_message(due: Date, last_review: Date, unit?: boolean): string;

package/lib/help.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.show_diff_message = exports.formatDate = exports.date_diff = exports.date_scheduler = void 0;
+Date.prototype.scheduler = function (t, isDay) {
+    return date_scheduler(this, t, isDay);
+};
+/**
+ * 当前时间与之前的时间差值
+ * @param pre 比当前时间还要之前
+ * @param unit 单位: days | minutes
+ */
+Date.prototype.diff = function (pre, unit) {
+    return date_diff(this, pre, unit);
+};
+Date.prototype.format = function () {
+    return formatDate(this);
+};
+Date.prototype.dueFormat = function (last_review, unit) {
+    return show_diff_message(this, last_review, unit);
+};
+function date_scheduler(now, t, isDay) {
+    return new Date(isDay ? now.getTime() + t * 24 * 60 * 60 * 1000 : now.getTime() + t * 60 * 1000);
+}
+exports.date_scheduler = date_scheduler;
+function date_diff(now, pre, unit) {
+    const diff = now.getTime() - pre.getTime();
+    let r = 0;
+    switch (unit) {
+        case 'days':
+            r = Math.floor((diff) / (24 * 60 * 60 * 1000));
+            break;
+        case 'minutes':
+            r = Math.floor((diff) / (60 * 1000));
+            break;
+    }
+    return r;
+}
+exports.date_diff = date_diff;
+function formatDate(date) {
+    const year = date.getFullYear();
+    const month = date.getMonth() + 1;
+    const day = date.getDate();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const seconds = date.getSeconds();
+    return `${year}-${padZero(month)}-${padZero(day)} ${padZero(hours)}:${padZero(minutes)}:${padZero(seconds)}`;
+}
+exports.formatDate = formatDate;
+function padZero(num) {
+    return num < 10 ? `0${num}` : `${num}`;
+}
+function show_diff_message(due, last_review, unit) {
+    const diff = due.getTime() - last_review.getTime();
+    if (diff < 1000 * 60 * 60) { // 小于1小时
+        return unit ? Math.floor((diff) / (60 * 1000)) + 'min' : String(Math.floor((diff) / (60 * 1000)));
+    }
+    else if (diff >= 1000 * 60 * 60 && diff < 1000 * 60 * 60 * 24) { // 大于1小时,小于1天
+        return unit ? Math.floor((diff) / (60 * 60 * 1000)) + 'hour' : String(Math.floor((diff) / (60 * 60 * 1000)));
+    }
+    else if (diff >= 1000 * 60 * 60 * 24 && diff < 1000 * 60 * 60 * 24 * 31) { // 大于1天,小于31天
+        return unit ? Math.floor((diff) / (24 * 60 * 60 * 1000)) + 'day' : String(Math.floor((diff) / (24 * 60 * 60 * 1000 * 1000)));
+    }
+    else if (diff >= 1000 * 60 * 60 * 24 * 31 && diff < 1000 * 60 * 60 * 24 * 365) { // 大于31天,小于365天
+        return unit ? ((diff) / (30 * 24 * 60 * 60 * 1000)).toFixed(2) + 'month' : ((diff) / (30 * 24 * 60 * 60 * 1000)).toFixed(2);
+    }
+    else { // 大于365天
+        return unit ? ((diff) / (365 * 24 * 60 * 60 * 1000)).toFixed(2) + 'year' : ((diff) / (365 * 24 * 60 * 60 * 1000)).toFixed(2);
+    }
+}
+exports.show_diff_message = show_diff_message;

package/lib/index.d.ts

@@ -2,7 +2,7 @@ import FSRS from "./fsrs";
 import { Card, default_easy_bonus, default_enable_fuzz, default_hard_factor, default_maximum_interval, default_request_retention, default_w, FSRSParameters, Rating, RatingType, ReviewLog, SchedulingLog, State, StateType } from "./models";
 import { SchedulingCard } from "./scheduler";
 declare const fsrs: (param?: FSRSParameters) => FSRS;
-declare const createEmptyCard: () => Card;
+declare const createEmptyCard: (now?: Date) => Card;
 declare const generatorParameters: (props?: {
     request_retention?: number;
     maximum_interval?: number;
@@ -18,7 +18,8 @@ declare const generatorParameters: (props?: {
     w: number[];
     enable_fuzz: boolean;
 };
-declare const FSRS_Version = 1.2;
+declare const FSRS_Version = "2.0.2";
 export { fsrs, FSRS_Version, State, Rating, SchedulingCard, createEmptyCard, generatorParameters };
 export type { StateType, RatingType, ReviewLog, Card, SchedulingLog, FSRSParameters };
 export { default_request_retention, default_maximum_interval, default_easy_bonus, default_hard_factor, default_w, default_enable_fuzz };
+export { date_scheduler, date_diff, formatDate, show_diff_message } from './help';

package/lib/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default_enable_fuzz = exports.default_w = exports.default_hard_factor = exports.default_easy_bonus = exports.default_maximum_interval = exports.default_request_retention = exports.generatorParameters = exports.createEmptyCard = exports.SchedulingCard = exports.Rating = exports.State = exports.FSRS_Version = exports.fsrs = void 0;
+exports.show_diff_message = exports.formatDate = exports.date_diff = exports.date_scheduler = exports.default_enable_fuzz = exports.default_w = exports.default_hard_factor = exports.default_easy_bonus = exports.default_maximum_interval = exports.default_request_retention = exports.generatorParameters = exports.createEmptyCard = exports.SchedulingCard = exports.Rating = exports.State = exports.FSRS_Version = exports.fsrs = void 0;
 const fsrs_1 = __importDefault(require("./fsrs"));
 const models_1 = require("./models");
 Object.defineProperty(exports, "default_easy_bonus", { enumerable: true, get: function () { return models_1.default_easy_bonus; } });
@@ -16,14 +16,13 @@ Object.defineProperty(exports, "Rating", { enumerable: true, get: function () {
 Object.defineProperty(exports, "State", { enumerable: true, get: function () { return models_1.State; } });
 const scheduler_1 = require("./scheduler");
 Object.defineProperty(exports, "SchedulingCard", { enumerable: true, get: function () { return scheduler_1.SchedulingCard; } });
-const dayjs_1 = __importDefault(require("dayjs"));
 const fsrs = (param) => {
     return new fsrs_1.default(param);
 };
 exports.fsrs = fsrs;
-const createEmptyCard = () => {
+const createEmptyCard = (now) => {
     return {
-        due: (0, dayjs_1.default)(),
+        due: now || new Date(),
         stability: 0,
         difficulty: 0,
         elapsed_days: 0,
@@ -56,5 +55,10 @@ const generatorParameters = (props) => {
     };
 };
 exports.generatorParameters = generatorParameters;
-const FSRS_Version = 1.20;
+const FSRS_Version = "2.0.2";
 exports.FSRS_Version = FSRS_Version;
+var help_1 = require("./help");
+Object.defineProperty(exports, "date_scheduler", { enumerable: true, get: function () { return help_1.date_scheduler; } });
+Object.defineProperty(exports, "date_diff", { enumerable: true, get: function () { return help_1.date_diff; } });
+Object.defineProperty(exports, "formatDate", { enumerable: true, get: function () { return help_1.formatDate; } });
+Object.defineProperty(exports, "show_diff_message", { enumerable: true, get: function () { return help_1.show_diff_message; } });

package/lib/models.d.ts

@@ -1,4 +1,3 @@
-import { Dayjs } from 'dayjs';
 export type StateType = "Learning" | "New" | "Review" | "Relearning";
 export declare enum State {
     New = 0,
@@ -18,10 +17,10 @@ export interface ReviewLog {
     state: State;
     elapsed_days: number;
     scheduled_days: number;
-    review: Dayjs;
+    review: Date;
 }
 export interface Card {
-    due: Dayjs;
+    due: Date;
     stability: number;
     difficulty: number;
     elapsed_days: number;
@@ -29,7 +28,7 @@ export interface Card {
     reps: number;
     lapses: number;
     state: State;
-    last_review?: Dayjs;
+    last_review?: Date;
 }
 export interface SchedulingLog {
     [key: number]: {

package/lib/scheduler.d.ts

@@ -1,5 +1,4 @@
-import { Card, SchedulingLog, State } from "./models";
-import { Dayjs } from "dayjs";
+import { Card, Rating, State } from './models';
 export declare class SchedulingCard {
     again: Card;
     hard: Card;
@@ -8,6 +7,47 @@ export declare class SchedulingCard {
     private copy;
     constructor(card: Card);
     update_state(state: State): this;
-    schedule(now: Dayjs, hard_interval: number, good_interval: number, easy_interval: number): SchedulingCard;
-    record_log(card: Card, now: Dayjs): SchedulingLog;
+    schedule(now: Date, hard_interval: number, good_interval: number, easy_interval: number): SchedulingCard;
+    record_log(card: Card, now: Date): {
+        0: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+        1: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+        2: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+        3: {
+            card: Card;
+            log: {
+                rating: Rating;
+                state: State;
+                elapsed_days: number;
+                scheduled_days: number;
+                review: Date;
+            };
+        };
+    };
 }

package/lib/scheduler.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchedulingCard = void 0;
 const models_1 = require("./models");
+const help_1 = require("./help");
 class SchedulingCard {
     copy(card) {
-        var _a;
-        return Object.assign(Object.assign({}, card), { due: card.due.clone(), last_review: (_a = card.last_review) === null || _a === void 0 ? void 0 : _a.clone() });
+        return Object.assign({}, card);
     }
     constructor(card) {
         this.again = this.copy(card);
@@ -41,15 +41,15 @@ class SchedulingCard {
         this.hard.scheduled_days = hard_interval;
         this.good.scheduled_days = good_interval;
         this.easy.scheduled_days = easy_interval;
-        this.again.due = now.add(5, 'minutes');
-        this.hard.due = hard_interval > 0 ? now.add(hard_interval, 'days') : now.add(10, 'minutes');
-        this.good.due = now.add(good_interval, 'days');
-        this.easy.due = now.add(easy_interval, 'days');
+        this.again.due = (0, help_1.date_scheduler)(now, 5);
+        this.hard.due = hard_interval > 0 ? (0, help_1.date_scheduler)(now, hard_interval, true) : (0, help_1.date_scheduler)(now, 10);
+        this.good.due = (0, help_1.date_scheduler)(now, good_interval, true);
+        this.easy.due = (0, help_1.date_scheduler)(now, easy_interval, true);
         return this;
     }
     record_log(card, now) {
         return {
-            0: {
+            [models_1.Rating.Again]: {
                 card: this.again,
                 log: {
                     rating: models_1.Rating.Again,
@@ -59,7 +59,7 @@ class SchedulingCard {
                     review: now
                 }
             },
-            1: {
+            [models_1.Rating.Hard]: {
                 card: this.hard,
                 log: {
                     rating: models_1.Rating.Hard,
@@ -69,7 +69,7 @@ class SchedulingCard {
                     review: now
                 }
             },
-            2: {
+            [models_1.Rating.Good]: {
                 card: this.good,
                 log: {
                     rating: models_1.Rating.Good,
@@ -79,7 +79,7 @@ class SchedulingCard {
                     review: now
                 }
             },
-            3: {
+            [models_1.Rating.Easy]: {
                 card: this.easy,
                 log: {
                     rating: models_1.Rating.Easy,

package/package.json

@@ -1,41 +1,43 @@
-{
-  "name": "ts-fsrs",
-  "version": "1.2.0",
-  "description": "ts-fsrs is a TypeScript package used to implement the Free Spaced Repetition Scheduler (FSRS) algorithm. It helps developers apply FSRS to their flashcard applications, thereby improving the user learning experience.",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "keywords": [
-    "SuperMemo",
-    "Anki",
-    "FSRS"
-  ],
-  "dependencies": {
-    "@types/seedrandom": "^3.0.5",
-    "dayjs": "^1.11.7",
-    "seedrandom": "^3.0.5"
-  },
-  "devDependencies": {
-    "eslint": "^8.34.0",
-    "typescript": "^4.9.5"
-  },
-  "scripts": {
-    "test": "ts-node test/index.ts",
-    "build": "tsc",
-    "test_publish": "yalc publish"
-  },
-  "author": "ishiko",
-  "license": "MIT",
-  "files": [
-    "lib/**/*",
-    "README.md",
-    "LICENSE"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ishiko732/ts-fsrs.git"
-  },
-  "bugs": {
-    "url": "https://github.com/ishiko732/ts-fsrs/issues"
-  },
-  "homepage": "https://github.com/ishiko732/ts-fsrs#readme"
-}
+{
+  "name": "ts-fsrs",
+  "version": "2.0.2",
+  "description": "ts-fsrs is a TypeScript package used to implement the Free Spaced Repetition Scheduler (FSRS) algorithm. It helps developers apply FSRS to their flashcard applications, thereby improving the user learning experience.",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "keywords": [
+    "SuperMemo",
+    "Anki",
+    "FSRS"
+  ],
+  "dependencies": {
+    "seedrandom": "^3.0.5"
+  },
+  "devDependencies": {
+    "@types/seedrandom": "^3.0.5",
+    "eslint": "^8.34.0",
+    "typescript": "^4.9.5"
+  },
+  "scripts": {
+    "test": "ts-node test/index.ts",
+    "build": "tsc",
+    "test_publish": "yalc publish",
+    "major": "npm version major",
+    "minor": "npm version minor",
+    "patch": "npm version patch"
+  },
+  "author": "ishiko",
+  "license": "MIT",
+  "files": [
+    "lib/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ishiko732/ts-fsrs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ishiko732/ts-fsrs/issues"
+  },
+  "homepage": "https://github.com/ishiko732/ts-fsrs#readme"
+}