ts-fsrs 2.0.2 → 2.1.1

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,46 @@
-# 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.
-
-# 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
+```
+
+# 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/{lib → dist}/fsrs.d.ts

@@ -1,126 +1,126 @@
-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: 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;
-    /**
-     *
-     * @param s scheduling Card
-     * @param last_d Difficulty
-     * @param last_s Stability
-     * @param retrievability Retrievability
-     */
-    next_ds(s: SchedulingCard, last_d: number, last_s: number, retrievability: number): void;
-    /**
-     * 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: number): number;
-    /**
-     * 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: number): number;
-    apply_fuzz(ivl: 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 g Grade (Rating[0.again,1.hard,2.good,3.easy])
-     * @return next_D
-     */
-    next_difficulty(d: number, g: number): number;
-    /**
-     * The formula used is :
-     * $$\min \{\max \{D_0,1\},10\}$$
-     */
-    constrain_difficulty(difficulty: number): number;
-    /**
-     * 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: number, current: number): number;
-    /**
-     * 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: number, s: number, r: number): number;
-    /**
-     * 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: number, s: number, r: number): number;
-    /**
-     * 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: number, s: number): number;
-}
+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: 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;
+    /**
+     *
+     * @param s scheduling Card
+     * @param last_d Difficulty
+     * @param last_s Stability
+     * @param retrievability Retrievability
+     */
+    next_ds(s: SchedulingCard, last_d: number, last_s: number, retrievability: number): void;
+    /**
+     * 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: number): number;
+    /**
+     * 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: number): number;
+    apply_fuzz(ivl: 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 g Grade (Rating[0.again,1.hard,2.good,3.easy])
+     * @return next_D
+     */
+    next_difficulty(d: number, g: number): number;
+    /**
+     * The formula used is :
+     * $$\min \{\max \{D_0,1\},10\}$$
+     */
+    constrain_difficulty(difficulty: number): number;
+    /**
+     * 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: number, current: number): number;
+    /**
+     * 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: number, s: number, r: number): number;
+    /**
+     * 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: number, s: number, r: number): number;
+    /**
+     * 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: number, s: number): number;
+}