ts-fsrs 2.0.3 → 2.2.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2023 ishiko
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2023 ishiko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,46 +1,55 @@
-# About The
-
-ts-fsrs is a TypeScript package used to implement the [Free Spaced Repetition Scheduler (FSRS) algorithm](https://github.com/open-spaced-repetition/free-spaced-repetition-scheduler). It helps
-developers apply FSRS to their flashcard applications, there by improving the user learning experience.
-
-# Usage
-
-```
-npm install ts-fsrs
-```
-
-# Example
-
-```typescript
-import {createEmptyCard, formatDate, fsrs, generatorParameters, Rating} from 'ts-fsrs';
-
-const params = generatorParameters({ enable_fuzz: true });
-const f = fsrs(params);
-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);
-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)
+# About The
+
+ts-fsrs is a TypeScript package used to implement the [Free Spaced Repetition Scheduler (FSRS) algorithm](https://github.com/open-spaced-repetition/free-spaced-repetition-scheduler). It helps
+developers apply FSRS to their flashcard applications, there by improving the user learning experience.
+
+# Usage
+
+```
+npm install ts-fsrs
+```
+
+# Environment Variables
+If you need to customize default parameters, you can modify the values using `.env`/`.env.local`/`.env.production`/`.env.development`.
+
+Copy the [.env.local.example](./example/.env.local.example) file in this directory to .env.local (which will be ignored by Git):
+
+```bash
+cp .env.local.example .env.local
+```
+
+# Example
+
+```typescript
+import {createEmptyCard, formatDate, fsrs, generatorParameters, Rating} from 'ts-fsrs';
+
+const params = generatorParameters({ enable_fuzz: true });
+const f = fsrs(params);
+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);
+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/example/index.ts)

package/dist/default.d.ts

@@ -0,0 +1,20 @@
+import { Card, FSRSParameters, FSRS } from "./index";
+import { EnvParams } from "./type";
+export declare const envParams: EnvParams;
+export declare const default_request_retention: number;
+export declare const default_maximum_interval: number;
+export declare const default_easy_bonus: number;
+export declare const default_hard_factor: number;
+export declare const default_w: number[];
+export declare const default_enable_fuzz: boolean;
+export declare const FSRSVersion: string;
+export declare const generatorParameters: (props?: Partial<FSRSParameters>) => {
+    request_retention: number;
+    maximum_interval: number;
+    easy_bonus: number;
+    hard_factor: number;
+    w: number[];
+    enable_fuzz: boolean;
+};
+export declare const createEmptyCard: (now?: Date) => Card;
+export declare const fsrs: (params?: Partial<FSRSParameters>) => FSRS;

package/dist/default.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsrs = exports.createEmptyCard = exports.generatorParameters = exports.FSRSVersion = exports.default_enable_fuzz = exports.default_w = exports.default_hard_factor = exports.default_easy_bonus = exports.default_maximum_interval = exports.default_request_retention = exports.envParams = void 0;
+const index_1 = require("./index");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config({ path: `./.env.local` });
+dotenv_1.default.config({ path: `./.env.production` });
+dotenv_1.default.config({ path: `./.env.` });
+dotenv_1.default.config({ path: `./.env.development` });
+exports.envParams = {
+    FSRS_REQUEST_RETENTION: Number(process.env.FSRS_REQUEST_RETENTION),
+    FSRS_MAXIMUM_INTERVAL: Number(process.env.FSRS_MAXIMUM_INTERVAL),
+    FSRS_EASY_BOUND: Number(process.env.FSRS_EASY_BOUND),
+    FSRS_HARD_FACTOR: Number(process.env.FSRS_HARD_FACTOR),
+    FSRS_W: process.env.FSRS_W
+        ? JSON.parse(process.env.FSRS_W)
+        : undefined,
+    FSRS_ENABLE_FUZZ: Boolean(process.env.FSRS_ENABLE_FUZZ),
+};
+exports.default_request_retention = !isNaN(exports.envParams.FSRS_REQUEST_RETENTION)
+    ? exports.envParams.FSRS_REQUEST_RETENTION
+    : 0.9;
+exports.default_maximum_interval = !isNaN(exports.envParams.FSRS_MAXIMUM_INTERVAL)
+    ? exports.envParams.FSRS_MAXIMUM_INTERVAL
+    : 36500;
+exports.default_easy_bonus = !isNaN(exports.envParams.FSRS_EASY_BOUND)
+    ? exports.envParams.FSRS_EASY_BOUND
+    : 1.3;
+exports.default_hard_factor = !isNaN(exports.envParams.FSRS_HARD_FACTOR)
+    ? exports.envParams.FSRS_HARD_FACTOR
+    : 1.2;
+exports.default_w = exports.envParams.FSRS_W || [
+    1, 1, 5, -0.5, -0.5, 0.2, 1.4, -0.12, 0.8, 2, -0.2, 0.2, 1,
+];
+exports.default_enable_fuzz = exports.envParams.FSRS_ENABLE_FUZZ || false;
+exports.FSRSVersion = "2.2.0";
+const generatorParameters = (props) => {
+    return {
+        request_retention: props?.request_retention || exports.default_request_retention,
+        maximum_interval: props?.maximum_interval || exports.default_maximum_interval,
+        easy_bonus: props?.easy_bonus || exports.default_easy_bonus,
+        hard_factor: props?.hard_factor || exports.default_hard_factor,
+        w: props?.w || exports.default_w,
+        enable_fuzz: props?.enable_fuzz || exports.default_enable_fuzz,
+    };
+};
+exports.generatorParameters = generatorParameters;
+const createEmptyCard = (now) => {
+    return {
+        due: now || new Date(),
+        stability: 0,
+        difficulty: 0,
+        elapsed_days: 0,
+        scheduled_days: 0,
+        reps: 0,
+        lapses: 0,
+        state: index_1.State.New,
+    };
+};
+exports.createEmptyCard = createEmptyCard;
+const fsrs = (params) => {
+    return new index_1.FSRS(params || {});
+};
+exports.fsrs = fsrs;

package/{lib → dist}/fsrs.d.ts

@@ -1,10 +1,11 @@
-import { Card, FSRSParameters, Rating, SchedulingCard, State } from "./index";
-import { int } from './help';
-export default class FSRS {
+import { SchedulingCard } from "./index";
+import { FSRSParameters, Card, State, Rating } from "./models";
+import type { int } from "./type";
+export declare class FSRS {
     private param;
     private readonly intervalModifier;
     private seed?;
-    constructor(param?: FSRSParameters);
+    constructor(param: Partial<FSRSParameters>);
     repeat: (card: Card, now: Date) => {
         0: {
             card: Card;

package/dist/fsrs.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FSRS = void 0;
+const seedrandom_1 = __importDefault(require("seedrandom"));
+const index_1 = require("./index");
+const help_1 = require("./help");
+const models_1 = require("./models");
+class FSRS {
+    param;
+    intervalModifier;
+    seed;
+    constructor(param) {
+        this.param = (0, index_1.generatorParameters)(param);
+        this.intervalModifier =
+            Math.log(this.param.request_retention) / Math.log(0.9);
+    }
+    repeat = (card, now) => {
+        card = {
+            ...card,
+            last_review: card.last_review ? (0, help_1.fixDate)(card.last_review) : undefined,
+        };
+        now = new Date((0, help_1.fixDate)(now));
+        card.elapsed_days =
+            card.state === models_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.getTime()) + String(card.elapsed_days);
+        let easy_interval, good_interval, hard_interval;
+        switch (card.state) {
+            case models_1.State.New:
+                this.init_ds(s);
+                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.scheduler(easy_interval, true);
+                break;
+            case models_1.State.Learning:
+            case models_1.State.Relearning:
+                hard_interval = 0;
+                good_interval = this.next_interval(s.good.stability);
+                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;
+            case models_1.State.Review: {
+                const interval = card.elapsed_days;
+                const last_d = card.difficulty;
+                const last_s = card.stability;
+                const retrievability = this.current_retrievability(interval, last_s);
+                this.next_ds(s, last_d, last_s, retrievability);
+                hard_interval = this.next_interval(last_s * this.param.hard_factor);
+                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.easy_bonus), good_interval + 1);
+                s.schedule(now, hard_interval, good_interval, easy_interval);
+                break;
+            }
+        }
+        return s.record_log(card, now);
+    };
+    get_retrievability = (card, now) => {
+        if (card.state !== models_1.State.Review) {
+            return undefined;
+        }
+        const t = Math.max(now.diff(card.last_review, "days"), 0);
+        return ((this.current_retrievability(t, card.stability) * 100).toFixed(2) + "%");
+    };
+    init_ds(s) {
+        s.again.difficulty = this.init_difficulty(models_1.Rating.Again);
+        s.again.stability = this.init_stability(models_1.Rating.Again);
+        s.hard.difficulty = this.init_difficulty(models_1.Rating.Hard);
+        s.hard.stability = this.init_stability(models_1.Rating.Hard);
+        s.good.difficulty = this.init_difficulty(models_1.Rating.Good);
+        s.good.stability = this.init_stability(models_1.Rating.Good);
+        s.easy.difficulty = this.init_difficulty(models_1.Rating.Easy);
+        s.easy.stability = this.init_stability(models_1.Rating.Easy);
+    }
+    /**
+     *
+     * @param s scheduling Card
+     * @param last_d Difficulty
+     * @param last_s Stability
+     * @param retrievability Retrievability
+     */
+    next_ds(s, last_d, last_s, retrievability) {
+        s.again.difficulty = this.next_difficulty(last_d, models_1.Rating.Again);
+        s.again.stability = this.next_forget_stability(s.again.difficulty, last_s, retrievability);
+        s.hard.difficulty = this.next_difficulty(last_d, models_1.Rating.Hard);
+        s.hard.stability = this.next_recall_stability(s.hard.difficulty, last_s, retrievability);
+        s.good.difficulty = this.next_difficulty(last_d, models_1.Rating.Good);
+        s.good.stability = this.next_recall_stability(s.good.difficulty, last_s, retrievability);
+        s.easy.difficulty = this.next_difficulty(last_d, models_1.Rating.Easy);
+        s.easy.stability = this.next_recall_stability(s.easy.difficulty, last_s, retrievability);
+    }
+    /**
+     * The formula used is :
+     * $$S_0(G) = w_0 + G \cdot w_1$$
+     * $$\max \{S_0,0.1\}$$
+     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * @return Stability (interval when R=90%)
+     */
+    init_stability(g) {
+        return Math.max(this.param.w[0] + this.param.w[1] * g, 0.1);
+    }
+    /**
+     * The formula used is :
+     * $$D_0(G) = w_2 + (G-2) \cdot w_3$$
+     * $$\min \{\max \{D_0(G),1\},10\}$$
+     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * @return Difficulty D \in [1,10]
+     */
+    init_difficulty(g) {
+        return Math.min(Math.max(this.param.w[2] + this.param.w[3] * (g - 2), 1), 10);
+    }
+    apply_fuzz(ivl) {
+        if (!this.param.enable_fuzz || ivl < 2.5)
+            return ivl;
+        const generator = (0, seedrandom_1.default)(this.seed);
+        const fuzz_factor = generator();
+        ivl = Math.round(ivl);
+        const min_ivl = Math.max(2, Math.round(ivl * 0.95 - 1));
+        const max_ivl = Math.round(ivl * 1.05 + 1);
+        return Math.floor(fuzz_factor * (max_ivl - min_ivl + 1) + min_ivl);
+    }
+    next_interval(s) {
+        const newInterval = this.apply_fuzz(s * this.intervalModifier);
+        return Math.min(Math.max(Math.round(newInterval), 1), this.param.maximum_interval);
+    }
+    /**
+     * 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 g Grade (Rating[0.again,1.hard,2.good,3.easy])
+     * @return next_D
+     */
+    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));
+    }
+    /**
+     * The formula used is :
+     * $$\min \{\max \{D_0,1\},10\}$$
+     */
+    constrain_difficulty(difficulty) {
+        return Math.min(Math.max(Number(difficulty.toFixed(2)), 1), 10);
+    }
+    /**
+     * The formula used is :
+     * $$w_5 \cdot init +(1 - w_5) \cdot current$$
+     * @param init $$w_2 : D_0(2) = w_2 + (R-2) \cdot w_3= w_2$$
+     * @param current $$D + w_4 \cdot (R - 2)$$
+     * @return difficulty
+     */
+    mean_reversion(init, current) {
+        return this.param.w[5] * init + (1 - this.param.w[5]) * current;
+    }
+    /**
+     * The formula used is :
+     * $$S^\prime_r(D,S,R) = S\cdot(e^{w_6}\cdot (11-D)\cdot S^{w_7}\cdot(e^{w_8\cdot(1-R)}-1)+1)$$
+     * @param d Difficulty D \in [1,10]
+     * @param s Stability (interval when R=90%)
+     * @param r Retrievability (probability of recall)
+     * @return S^\prime_r new stability after recall
+     */
+    next_recall_stability(d, s, r) {
+        return (s *
+            (1 +
+                Math.exp(this.param.w[6]) *
+                    (11 - d) *
+                    Math.pow(s, this.param.w[7]) *
+                    (Math.exp((1 - r) * this.param.w[8]) - 1)));
+    }
+    /**
+     * The formula used is :
+     * $$S^\prime_f(D,S,R) = w_9\cdot D^{w_{10}}\cdot S^{w_{11}}\cdot e^{w_{12}\cdot(1-R)}.$$
+     * @param d Difficulty D \in [1,10]
+     * @param s Stability (interval when R=90%)
+     * @param r Retrievability (probability of recall)
+     * @return S^\prime_f new stability after forgetting
+     */
+    next_forget_stability(d, s, r) {
+        return (this.param.w[9] *
+            Math.pow(d, this.param.w[10]) *
+            Math.pow(s, this.param.w[11]) *
+            Math.exp((1 - r) * this.param.w[12]));
+    }
+    /**
+     * The formula used is :
+     * $$R(t,S) = 0.9^{\frac{t}{S}}$$
+     * @param t t days since the last review
+     * @param s Stability (interval when R=90%)
+     * @return r Retrievability (probability of recall)
+     */
+    current_retrievability(t, s) {
+        return Math.exp((Math.log(0.9) * t) / s);
+    }
+}
+exports.FSRS = FSRS;

package/{lib → dist}/help.d.ts

@@ -1,10 +1,4 @@
-export type unit = 'days' | 'minutes';
-export type int = number & {
-    __int__: void;
-};
-export type double = number & {
-    __double__: void;
-};
+import type { int, unit } from "./type";
 declare global {
     export interface Date {
         scheduler(t: int, isDay?: boolean): Date;
@@ -16,4 +10,5 @@ declare global {
 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;
+export declare function show_diff_message(due: Date, last_review: Date, unit?: boolean, timeUnit?: string[]): string;
+export declare function fixDate(value: unknown): Date;

package/dist/help.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixDate = 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}`;
+}
+const TIMEUNIT = [60, 60, 24, 31, 12];
+const TIMEUNITFORMAT = ["second", "min", "hour", "day", "month", "year"];
+function show_diff_message(due, last_review, unit, timeUnit = TIMEUNITFORMAT) {
+    due = fixDate(due);
+    last_review = fixDate(last_review);
+    if (timeUnit.length !== TIMEUNITFORMAT.length) {
+        timeUnit = TIMEUNITFORMAT;
+    }
+    let diff = due.getTime() - last_review.getTime();
+    let i;
+    diff /= 1000;
+    for (i = 0; i < TIMEUNIT.length; i++) {
+        if (diff < TIMEUNIT[i]) {
+            break;
+        }
+        else {
+            diff /= TIMEUNIT[i];
+        }
+    }
+    return `${Math.floor(diff)}${unit ? timeUnit[i] : ""}`;
+}
+exports.show_diff_message = show_diff_message;
+function fixDate(value) {
+    if (typeof value === "object" && value instanceof Date) {
+        return value;
+    }
+    else if (typeof value === "string") {
+        const timestamp = Date.parse(value);
+        if (!isNaN(timestamp)) {
+            return new Date(timestamp);
+        }
+        else {
+            throw new Error(`Invalid date:[${value}]`);
+        }
+    }
+    else if (typeof value === "number") {
+        return new Date(value);
+    }
+    throw new Error(`Invalid date:[${value}]`);
+}
+exports.fixDate = fixDate;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { SchedulingCard } from "./scheduler";
+export { default_request_retention, default_maximum_interval, default_easy_bonus, default_hard_factor, default_w, default_enable_fuzz, FSRSVersion, generatorParameters, createEmptyCard, fsrs, envParams } from "./default";
+export { date_scheduler, date_diff, formatDate, show_diff_message, } from "./help";
+export type { int, double } from "./type";
+export type { FSRSParameters, Card, ReviewLog, StateType, RatingType, } from "./models";
+export { State, Rating } from "./models";
+export { FSRS } from "./fsrs";

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FSRS = exports.Rating = exports.State = exports.show_diff_message = exports.formatDate = exports.date_diff = exports.date_scheduler = exports.envParams = exports.fsrs = exports.createEmptyCard = exports.generatorParameters = exports.FSRSVersion = exports.default_enable_fuzz = exports.default_w = exports.default_hard_factor = exports.default_easy_bonus = exports.default_maximum_interval = exports.default_request_retention = exports.SchedulingCard = void 0;
+var scheduler_1 = require("./scheduler");
+Object.defineProperty(exports, "SchedulingCard", { enumerable: true, get: function () { return scheduler_1.SchedulingCard; } });
+var default_1 = require("./default");
+Object.defineProperty(exports, "default_request_retention", { enumerable: true, get: function () { return default_1.default_request_retention; } });
+Object.defineProperty(exports, "default_maximum_interval", { enumerable: true, get: function () { return default_1.default_maximum_interval; } });
+Object.defineProperty(exports, "default_easy_bonus", { enumerable: true, get: function () { return default_1.default_easy_bonus; } });
+Object.defineProperty(exports, "default_hard_factor", { enumerable: true, get: function () { return default_1.default_hard_factor; } });
+Object.defineProperty(exports, "default_w", { enumerable: true, get: function () { return default_1.default_w; } });
+Object.defineProperty(exports, "default_enable_fuzz", { enumerable: true, get: function () { return default_1.default_enable_fuzz; } });
+Object.defineProperty(exports, "FSRSVersion", { enumerable: true, get: function () { return default_1.FSRSVersion; } });
+Object.defineProperty(exports, "generatorParameters", { enumerable: true, get: function () { return default_1.generatorParameters; } });
+Object.defineProperty(exports, "createEmptyCard", { enumerable: true, get: function () { return default_1.createEmptyCard; } });
+Object.defineProperty(exports, "fsrs", { enumerable: true, get: function () { return default_1.fsrs; } });
+Object.defineProperty(exports, "envParams", { enumerable: true, get: function () { return default_1.envParams; } });
+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; } });
+var models_1 = require("./models");
+Object.defineProperty(exports, "State", { enumerable: true, get: function () { return models_1.State; } });
+Object.defineProperty(exports, "Rating", { enumerable: true, get: function () { return models_1.Rating; } });
+var fsrs_1 = require("./fsrs");
+Object.defineProperty(exports, "FSRS", { enumerable: true, get: function () { return fsrs_1.FSRS; } });

package/{lib → dist}/models.d.ts

@@ -30,12 +30,6 @@ export interface Card {
     state: State;
     last_review?: Date;
 }
-export interface SchedulingLog {
-    [key: number]: {
-        card: Card;
-        log: ReviewLog;
-    };
-}
 export interface FSRSParameters {
     request_retention: number;
     maximum_interval: number;
@@ -44,9 +38,3 @@ export interface FSRSParameters {
     w: number[];
     enable_fuzz: boolean;
 }
-export declare const default_request_retention = 0.9;
-export declare const default_maximum_interval = 36500;
-export declare const default_easy_bonus = 1.3;
-export declare const default_hard_factor = 1.2;
-export declare const default_w: number[];
-export declare const default_enable_fuzz = false;

package/{lib → dist}/models.js

@@ -1,6 +1,6 @@
 "use strict";
 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.Rating = exports.State = void 0;
+exports.Rating = exports.State = void 0;
 var State;
 (function (State) {
     State[State["New"] = 0] = "New";
@@ -15,9 +15,3 @@ var Rating;
     Rating[Rating["Good"] = 2] = "Good";
     Rating[Rating["Easy"] = 3] = "Easy";
 })(Rating || (exports.Rating = Rating = {}));
-exports.default_request_retention = 0.9;
-exports.default_maximum_interval = 36500;
-exports.default_easy_bonus = 1.3;
-exports.default_hard_factor = 1.2;
-exports.default_w = [1, 1, 5, -0.5, -0.5, 0.2, 1.4, -0.12, 0.8, 2, -0.2, 0.2, 1];
-exports.default_enable_fuzz = false;

package/{lib → dist}/scheduler.d.ts

@@ -1,4 +1,4 @@
-import { Card, Rating, State } from './models';
+import { Card, Rating, State } from "./models";
 export declare class SchedulingCard {
     again: Card;
     hard: Card;

package/{lib → dist}/scheduler.js

@@ -4,8 +4,14 @@ exports.SchedulingCard = void 0;
 const models_1 = require("./models");
 const help_1 = require("./help");
 class SchedulingCard {
+    again;
+    hard;
+    good;
+    easy;
     copy(card) {
-        return Object.assign({}, card);
+        return {
+            ...card,
+        };
     }
     constructor(card) {
         this.again = this.copy(card);
@@ -42,7 +48,10 @@ class SchedulingCard {
         this.good.scheduled_days = good_interval;
         this.easy.scheduled_days = easy_interval;
         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.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;
@@ -56,8 +65,8 @@ class SchedulingCard {
                     state: card.state,
                     elapsed_days: this.again.scheduled_days,
                     scheduled_days: card.elapsed_days,
-                    review: now
-                }
+                    review: now,
+                },
             },
             [models_1.Rating.Hard]: {
                 card: this.hard,
@@ -66,8 +75,8 @@ class SchedulingCard {
                     state: card.state,
                     elapsed_days: this.hard.scheduled_days,
                     scheduled_days: card.elapsed_days,
-                    review: now
-                }
+                    review: now,
+                },
             },
             [models_1.Rating.Good]: {
                 card: this.good,
@@ -76,8 +85,8 @@ class SchedulingCard {
                     state: card.state,
                     elapsed_days: this.good.scheduled_days,
                     scheduled_days: card.elapsed_days,
-                    review: now
-                }
+                    review: now,
+                },
             },
             [models_1.Rating.Easy]: {
                 card: this.easy,
@@ -86,9 +95,9 @@ class SchedulingCard {
                     state: card.state,
                     elapsed_days: this.easy.scheduled_days,
                     scheduled_days: card.elapsed_days,
-                    review: now
-                }
-            }
+                    review: now,
+                },
+            },
         };
     }
 }

package/dist/type.d.ts

@@ -0,0 +1,15 @@
+export type unit = "days" | "minutes";
+export type int = number & {
+    __int__: void;
+};
+export type double = number & {
+    __double__: void;
+};
+export interface EnvParams {
+    FSRS_REQUEST_RETENTION: number;
+    FSRS_MAXIMUM_INTERVAL: number;
+    FSRS_EASY_BOUND: number;
+    FSRS_HARD_FACTOR: number;
+    FSRS_W?: number[];
+    FSRS_ENABLE_FUZZ?: boolean;
+}

package/dist/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,43 +1,55 @@
-{
-  "name": "ts-fsrs",
-  "version": "2.0.3",
-  "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.44.0",
-    "typescript": "^5.1.6"
-  },
-  "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"
-}
+{
+  "name": "ts-fsrs",
+  "version": "2.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": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "SuperMemo",
+    "Anki",
+    "FSRS"
+  ],
+  "dependencies": {
+    "dotenv": "^16.3.1",
+    "seedrandom": "^3.0.5"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.5",
+    "@types/node": "^20.6.2",
+    "@types/seedrandom": "^3.0.5",
+    "@typescript-eslint/eslint-plugin": "^6.7.0",
+    "@typescript-eslint/parser": "^6.7.0",
+    "eslint": "^8.44.0",
+    "eslint-config-prettier": "^9.0.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.0.3",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.6"
+  },
+  "scripts": {
+    "lint": "eslint --fix src/ && prettier --write src/",
+    "dev": "ts-node src/fsrs/index.ts",
+    "test": "jest --passWithNoTests",
+    "build": "tsc --project ./tsconfig.json",
+    "major": "npm version major",
+    "minor": "npm version minor",
+    "patch": "npm version patch",
+    "test_publish": "yalc publish"
+  },
+  "author": "ishiko",
+  "license": "MIT",
+  "files": [
+    "dist/**/*",
+    "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"
+}

package/lib/fsrs.js

@@ -1,189 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const seedrandom_1 = __importDefault(require("seedrandom"));
-const index_1 = require("./index");
-class FSRS {
-    constructor(param) {
-        this.repeat = (card, now) => {
-            card = Object.assign({}, card);
-            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.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.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.scheduler(easy_interval, true);
-                    break;
-                case index_1.State.Learning:
-                case index_1.State.Relearning:
-                    hard_interval = 0;
-                    good_interval = this.next_interval(s.good.stability);
-                    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;
-                case index_1.State.Review:
-                    const interval = card.elapsed_days;
-                    const last_d = card.difficulty;
-                    const last_s = card.stability;
-                    const retrievability = this.current_retrievability(interval, last_s);
-                    this.next_ds(s, last_d, last_s, retrievability);
-                    hard_interval = this.next_interval(last_s * this.param.hard_factor);
-                    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.easy_bonus), good_interval + 1);
-                    s.schedule(now, hard_interval, good_interval, easy_interval);
-                    break;
-            }
-            return s.record_log(card, now);
-        };
-        this.get_retrievability = (card, now) => {
-            if (card.state !== index_1.State.Review) {
-                return undefined;
-            }
-            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)();
-        this.intervalModifier = Math.log(this.param.request_retention) / Math.log(0.9);
-    }
-    init_ds(s) {
-        s.again.difficulty = this.init_difficulty(index_1.Rating.Again);
-        s.again.stability = this.init_stability(index_1.Rating.Again);
-        s.hard.difficulty = this.init_difficulty(index_1.Rating.Hard);
-        s.hard.stability = this.init_stability(index_1.Rating.Hard);
-        s.good.difficulty = this.init_difficulty(index_1.Rating.Good);
-        s.good.stability = this.init_stability(index_1.Rating.Good);
-        s.easy.difficulty = this.init_difficulty(index_1.Rating.Easy);
-        s.easy.stability = this.init_stability(index_1.Rating.Easy);
-    }
-    /**
-     *
-     * @param s scheduling Card
-     * @param last_d Difficulty
-     * @param last_s Stability
-     * @param retrievability Retrievability
-     */
-    next_ds(s, last_d, last_s, retrievability) {
-        s.again.difficulty = this.next_difficulty(last_d, index_1.Rating.Again);
-        s.again.stability = this.next_forget_stability(s.again.difficulty, last_s, retrievability);
-        s.hard.difficulty = this.next_difficulty(last_d, index_1.Rating.Hard);
-        s.hard.stability = this.next_recall_stability(s.hard.difficulty, last_s, retrievability);
-        s.good.difficulty = this.next_difficulty(last_d, index_1.Rating.Good);
-        s.good.stability = this.next_recall_stability(s.good.difficulty, last_s, retrievability);
-        s.easy.difficulty = this.next_difficulty(last_d, index_1.Rating.Easy);
-        s.easy.stability = this.next_recall_stability(s.easy.difficulty, last_s, retrievability);
-    }
-    /**
-     * The formula used is :
-     * $$S_0(G) = w_0 + G \cdot w_1$$
-     * $$\max \{S_0,0.1\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
-     * @return Stability (interval when R=90%)
-     */
-    init_stability(g) {
-        return Math.max(this.param.w[0] + this.param.w[1] * g, 0.1);
-    }
-    /**
-     * The formula used is :
-     * $$D_0(G) = w_2 + (G-2) \cdot w_3$$
-     * $$\min \{\max \{D_0(G),1\},10\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
-     * @return Difficulty D \in [1,10]
-     */
-    init_difficulty(g) {
-        return Math.min(Math.max(this.param.w[2] + this.param.w[3] * (g - 2), 1), 10);
-    }
-    apply_fuzz(ivl) {
-        if (!this.param.enable_fuzz || ivl < 2.5)
-            return ivl;
-        const generator = (0, seedrandom_1.default)(this.seed);
-        const fuzz_factor = generator();
-        ivl = Math.round(ivl);
-        const min_ivl = Math.max(2, Math.round(ivl * 0.95 - 1));
-        const max_ivl = Math.round(ivl * 1.05 + 1);
-        return Math.floor(fuzz_factor * (max_ivl - min_ivl + 1) + min_ivl);
-    }
-    next_interval(s) {
-        const newInterval = this.apply_fuzz(s * this.intervalModifier);
-        return Math.min(Math.max(Math.round(newInterval), 1), this.param.maximum_interval);
-    }
-    /**
-     * 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 g Grade (Rating[0.again,1.hard,2.good,3.easy])
-     * @return next_D
-     */
-    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));
-    }
-    /**
-     * The formula used is :
-     * $$\min \{\max \{D_0,1\},10\}$$
-     */
-    constrain_difficulty(difficulty) {
-        return Math.min(Math.max(Number(difficulty.toFixed(2)), 1), 10);
-    }
-    /**
-     * The formula used is :
-     * $$w_5 \cdot init +(1 - w_5) \cdot current$$
-     * @param init $$w_2 : D_0(2) = w_2 + (R-2) \cdot w_3= w_2$$
-     * @param current $$D + w_4 \cdot (R - 2)$$
-     * @return difficulty
-     */
-    mean_reversion(init, current) {
-        return this.param.w[5] * init + (1 - this.param.w[5]) * current;
-    }
-    /**
-     * The formula used is :
-     * $$S^\prime_r(D,S,R) = S\cdot(e^{w_6}\cdot (11-D)\cdot S^{w_7}\cdot(e^{w_8\cdot(1-R)}-1)+1)$$
-     * @param d Difficulty D \in [1,10]
-     * @param s Stability (interval when R=90%)
-     * @param r Retrievability (probability of recall)
-     * @return S^\prime_r new stability after recall
-     */
-    next_recall_stability(d, s, r) {
-        return s * (1 + Math.exp(this.param.w[6]) *
-            (11 - d) *
-            Math.pow(s, this.param.w[7]) *
-            (Math.exp((1 - r) * this.param.w[8]) - 1));
-    }
-    /**
-     * The formula used is :
-     * $$S^\prime_f(D,S,R) = w_9\cdot D^{w_{10}}\cdot S^{w_{11}}\cdot e^{w_{12}\cdot(1-R)}.$$
-     * @param d Difficulty D \in [1,10]
-     * @param s Stability (interval when R=90%)
-     * @param r Retrievability (probability of recall)
-     * @return S^\prime_f new stability after forgetting
-     */
-    next_forget_stability(d, s, r) {
-        return this.param.w[9] * Math.pow(d, this.param.w[10]) * Math.pow(s, this.param.w[11]) * Math.exp((1 - r) * this.param.w[12]);
-    }
-    /**
-     * The formula used is :
-     * $$R(t,S) = 0.9^{\frac{t}{S}}$$
-     * @param t t days since the last review
-     * @param s Stability (interval when R=90%)
-     * @return r Retrievability (probability of recall)
-     */
-    current_retrievability(t, s) {
-        return Math.exp(Math.log(0.9) * t / s);
-    }
-}
-exports.default = FSRS;

package/lib/help.js

@@ -1,70 +0,0 @@
-"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

@@ -1,25 +0,0 @@
-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: (now?: Date) => Card;
-declare const generatorParameters: (props?: {
-    request_retention?: number;
-    maximum_interval?: number;
-    easy_bonus?: number;
-    hard_factor?: number;
-    w?: number[];
-    enable_fuzz?: boolean;
-}) => {
-    request_retention: number;
-    maximum_interval: number;
-    easy_bonus: number;
-    hard_factor: number;
-    w: number[];
-    enable_fuzz: boolean;
-};
-declare const FSRS_Version = "2.0.3";
-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

@@ -1,64 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-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; } });
-Object.defineProperty(exports, "default_enable_fuzz", { enumerable: true, get: function () { return models_1.default_enable_fuzz; } });
-Object.defineProperty(exports, "default_hard_factor", { enumerable: true, get: function () { return models_1.default_hard_factor; } });
-Object.defineProperty(exports, "default_maximum_interval", { enumerable: true, get: function () { return models_1.default_maximum_interval; } });
-Object.defineProperty(exports, "default_request_retention", { enumerable: true, get: function () { return models_1.default_request_retention; } });
-Object.defineProperty(exports, "default_w", { enumerable: true, get: function () { return models_1.default_w; } });
-Object.defineProperty(exports, "Rating", { enumerable: true, get: function () { return models_1.Rating; } });
-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 fsrs = (param) => {
-    return new fsrs_1.default(param);
-};
-exports.fsrs = fsrs;
-const createEmptyCard = (now) => {
-    return {
-        due: now || new Date(),
-        stability: 0,
-        difficulty: 0,
-        elapsed_days: 0,
-        scheduled_days: 0,
-        reps: 0,
-        lapses: 0,
-        state: models_1.State.New,
-    };
-};
-exports.createEmptyCard = createEmptyCard;
-const generatorParameters = (props) => {
-    if (!props) {
-        return {
-            request_retention: models_1.default_request_retention,
-            maximum_interval: models_1.default_maximum_interval,
-            easy_bonus: models_1.default_easy_bonus,
-            hard_factor: models_1.default_hard_factor,
-            w: models_1.default_w,
-            enable_fuzz: models_1.default_enable_fuzz,
-        };
-    }
-    const { w, request_retention, hard_factor, maximum_interval, enable_fuzz, easy_bonus } = props;
-    return {
-        request_retention: request_retention || models_1.default_request_retention,
-        maximum_interval: maximum_interval || models_1.default_maximum_interval,
-        easy_bonus: easy_bonus || models_1.default_easy_bonus,
-        hard_factor: hard_factor || models_1.default_hard_factor,
-        w: w || models_1.default_w,
-        enable_fuzz: enable_fuzz || models_1.default_enable_fuzz,
-    };
-};
-exports.generatorParameters = generatorParameters;
-const FSRS_Version = "2.0.3";
-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; } });