FSRS
class FSRS extends FSRSAlgorithm { }
constructor(param: Partial<FSRSParameters>);
private Schduler;
forget<R = RecordLogItem>(
now: DateInput,
reset_count?: boolean,
afterHandler?: (recordLogItem: RecordLogItem) => R,
): R;get_retrievability<T extends boolean>(
now?: DateInput,
format?: T,
): (T extends true ? string : number);next<R = RecordLogItem>(
now: DateInput,
grade: Grade,
afterHandler?: (recordLog: RecordLogItem) => R,
): R;§Constructors
§
new FSRS(param: Partial<FSRSParameters>)
[src]§Properties
§Methods
§
params_handler_proxy(): ProxyHandler<FSRSParameters> protected
[src]§
forget<R = RecordLogItem>(card: CardInput | Card, now: DateInput, reset_count?: boolean, afterHandler?: (recordLogItem: RecordLogItem) => R): R
[src]@param card
Card to be processed
@param now
Current time or scheduled time
@param reset_count
Should the review count information(reps,lapses) be reset. (Optional)
@param afterHandler
Convert the result to another type. (Optional)
@example
const now = new Date();
const f = fsrs();
const emptyCard = createEmptyCard(now);
const scheduling_cards = f.repeat(emptyCard, now);
const { card, log } = scheduling_cards[Rating.Hard];
const forgetCard = f.forget(card, new Date(), true);
@example
interface RepeatRecordLog {
card: CardUnChecked; //see method: createEmptyCard
log: RevLogUnchecked; //see method: fsrs.repeat()
}
function forgetAfterHandler(recordLogItem: RecordLogItem): RepeatRecordLog {
return {
card: {
...(recordLogItem.card as Card & { cid: string }),
due: recordLogItem.card.due.getTime(),
state: State[recordLogItem.card.state] as StateType,
last_review: recordLogItem.card.last_review
? recordLogItem.card.last_review!.getTime()
: null,
},
log: {
...recordLogItem.log,
cid: (recordLogItem.card as Card & { cid: string }).cid,
due: recordLogItem.log.due.getTime(),
review: recordLogItem.log.review.getTime(),
state: State[recordLogItem.log.state] as StateType,
rating: Rating[recordLogItem.log.rating] as RatingType,
},
};
}
const now = new Date();
const f = fsrs();
const emptyCardFormAfterHandler = createEmptyCard(now, cardAfterHandler); //see method: createEmptyCard
const repeatFormAfterHandler = f.repeat(emptyCardFormAfterHandler, now, repeatAfterHandler); //see method: fsrs.repeat()
const { card } = repeatFormAfterHandler[Rating.Hard];
const forgetFromAfterHandler = f.forget(card, date_scheduler(now, 1, true), false, forgetAfterHandler);
§
get_retrievability<T extends boolean>(card: CardInput | Card, now?: DateInput, format?: T): (T extends true ? string : number)
[src]Get the retrievability of the card
@param card
Card to be processed
@param now
Current time or scheduled time
@param format
default:true , Convert the result to another type. (Optional)
@return
The retrievability of the card,if format is true, the result is a string, otherwise it is a number
§
next<R = RecordLogItem>(card: CardInput | Card, now: DateInput, grade: Grade, afterHandler?: (recordLog: RecordLogItem) => R): R
[src]Display the collection of cards and logs for the card scheduled at the current time, after applying a specific grade rating.
@param card
Card to be processed
@param now
Current time or scheduled time
@param grade
Rating of the review (Again, Hard, Good, Easy)
@param afterHandler
Convert the result to another type. (Optional)
@example
const card: Card = createEmptyCard(new Date());
const f = fsrs();
const recordLogItem = f.next(card, new Date(), Rating.Again);
@example
interface RevLogUnchecked
extends Omit<ReviewLog, "due" | "review" | "state" | "rating"> {
cid: string;
due: Date | number;
state: StateType;
review: Date | number;
rating: RatingType;
}
interface NextRecordLog {
card: CardUnChecked; //see method: createEmptyCard
log: RevLogUnchecked;
}
function nextAfterHandler(recordLogItem: RecordLogItem) {
const recordItem = {
card: {
...(recordLogItem.card as Card & { cid: string }),
due: recordLogItem.card.due.getTime(),
state: State[recordLogItem.card.state] as StateType,
last_review: recordLogItem.card.last_review
? recordLogItem.card.last_review!.getTime()
: null,
},
log: {
...recordLogItem.log,
cid: (recordLogItem.card as Card & { cid: string }).cid,
due: recordLogItem.log.due.getTime(),
review: recordLogItem.log.review.getTime(),
state: State[recordLogItem.log.state] as StateType,
rating: Rating[recordLogItem.log.rating] as RatingType,
},
};
return recordItem
}
const card: Card = createEmptyCard(new Date(), cardAfterHandler); //see method: createEmptyCard
const f = fsrs();
const recordLogItem = f.repeat(card, new Date(), Rating.Again, nextAfterHandler);
§
repeat<R = IPreview>(card: CardInput | Card, now: DateInput, afterHandler?: (recordLog: IPreview) => R): R
[src]Display the collection of cards and logs for the four scenarios after scheduling the card at the current time.
@param card
Card to be processed
@param now
Current time or scheduled time
@param afterHandler
Convert the result to another type. (Optional)
@example
const card: Card = createEmptyCard(new Date());
const f = fsrs();
const recordLog = f.repeat(card, new Date());
@example
interface RevLogUnchecked
extends Omit<ReviewLog, "due" | "review" | "state" | "rating"> {
cid: string;
due: Date | number;
state: StateType;
review: Date | number;
rating: RatingType;
}
interface RepeatRecordLog {
card: CardUnChecked; //see method: createEmptyCard
log: RevLogUnchecked;
}
function repeatAfterHandler(recordLog: RecordLog) {
const record: { [key in Grade]: RepeatRecordLog } = {} as {
[key in Grade]: RepeatRecordLog;
};
for (const grade of Grades) {
record[grade] = {
card: {
...(recordLog[grade].card as Card & { cid: string }),
due: recordLog[grade].card.due.getTime(),
state: State[recordLog[grade].card.state] as StateType,
last_review: recordLog[grade].card.last_review
? recordLog[grade].card.last_review!.getTime()
: null,
},
log: {
...recordLog[grade].log,
cid: (recordLog[grade].card as Card & { cid: string }).cid,
due: recordLog[grade].log.due.getTime(),
review: recordLog[grade].log.review.getTime(),
state: State[recordLog[grade].log.state] as StateType,
rating: Rating[recordLog[grade].log.rating] as RatingType,
},
};
}
return record;
}
const card: Card = createEmptyCard(new Date(), cardAfterHandler); //see method: createEmptyCard
const f = fsrs();
const recordLog = f.repeat(card, new Date(), repeatAfterHandler);
§
@param cards
scheduled card collection
@param options
Reschedule options,fuzz is enabled by default.If the type of due is not Date, please implement dataHandler.
@example
type CardType = Card & {
cid: number;
};
const reviewCard: CardType = {
cid: 1,
due: new Date("2024-03-17 04:43:02"),
stability: 48.26139059062234,
difficulty: 5.67,
elapsed_days: 18,
scheduled_days: 51,
reps: 8,
lapses: 1,
state: State.Review,
last_review: new Date("2024-01-26 04:43:02"),
};
const f = fsrs();
const reschedule_cards = f.reschedule([reviewCard]);
§
rollback<R = Card>(card: CardInput | Card, log: ReviewLogInput, afterHandler?: (prevCard: Card) => R): R
[src]@param card
Card to be processed
@param log
last review log
@param afterHandler
Convert the result to another type. (Optional)
@example
const now = new Date();
const f = fsrs();
const emptyCardFormAfterHandler = createEmptyCard(now);
const repeatFormAfterHandler = f.repeat(emptyCardFormAfterHandler, now);
const { card, log } = repeatFormAfterHandler[Rating.Hard];
const rollbackFromAfterHandler = f.rollback(card, log);
@example
const now = new Date();
const f = fsrs();
const emptyCardFormAfterHandler = createEmptyCard(now, cardAfterHandler); //see method: createEmptyCard
const repeatFormAfterHandler = f.repeat(emptyCardFormAfterHandler, now, repeatAfterHandler); //see method: fsrs.repeat()
const { card, log } = repeatFormAfterHandler[Rating.Hard];
const rollbackFromAfterHandler = f.rollback(card, log, cardAfterHandler);